[khornicek] 47779: [OPENGL32_WINETEST] Add opengl32 winetest, patch by Jerome Gardou. Not used for now.
Author: khornicek Date: Mon Jun 14 12:41:15 2010 New Revision: 47779
URL: http://svn.reactos.org/svn/reactos?rev=47779&view=rev Log: [OPENGL32_WINETEST] Add opengl32 winetest, patch by Jerome Gardou. Not used for now.
Added: trunk/rostests/winetests/opengl32/ trunk/rostests/winetests/opengl32/opengl.c (with props) trunk/rostests/winetests/opengl32/opengl32.rbuild (with props) trunk/rostests/winetests/opengl32/testlist.c (with props)
Added: trunk/rostests/winetests/opengl32/opengl.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/opengl32/opengl.... ============================================================================== --- trunk/rostests/winetests/opengl32/opengl.c (added) +++ trunk/rostests/winetests/opengl32/opengl.c [iso-8859-1] Mon Jun 14 12:41:15 2010 @@ -1,0 +1,762 @@ +/* + * Some tests for OpenGL functions + * + * Copyright (C) 2007-2008 Roderick Colenbrander + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA + */ + +#include <windows.h> +#include <wingdi.h> +#include "wine/test.h" + +const unsigned char * WINAPI glGetString(unsigned int); +#define GL_VENDOR 0x1F00 +#define GL_RENDERER 0x1F01 +#define GL_VERSION 0x1F02 + +#define MAX_FORMATS 256 +typedef void* HPBUFFERARB; + +/* WGL_ARB_create_context */ +HGLRC (WINAPI *pwglCreateContextAttribsARB)(HDC hDC, HGLRC hShareContext, const int *attribList); +/* GetLastError */ +#define ERROR_INVALID_VERSION_ARB 0x2095 +#define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092 +#define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093 +#define WGL_CONTEXT_FLAGS_ARB 0x2094 +/* Flags for WGL_CONTEXT_FLAGS_ARB */ +#define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001 +#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002 + +/* WGL_ARB_extensions_string */ +static const char* (WINAPI *pwglGetExtensionsStringARB)(HDC); +static int (WINAPI *pwglReleasePbufferDCARB)(HPBUFFERARB, HDC); + +/* WGL_ARB_make_current_read */ +static BOOL (WINAPI *pwglMakeContextCurrentARB)(HDC hdraw, HDC hread, HGLRC hglrc); +static HDC (WINAPI *pwglGetCurrentReadDCARB)(void); + +/* WGL_ARB_pixel_format */ +#define WGL_ACCELERATION_ARB 0x2003 +#define WGL_COLOR_BITS_ARB 0x2014 +#define WGL_RED_BITS_ARB 0x2015 +#define WGL_GREEN_BITS_ARB 0x2017 +#define WGL_BLUE_BITS_ARB 0x2019 +#define WGL_ALPHA_BITS_ARB 0x201B +#define WGL_SUPPORT_GDI_ARB 0x200F +#define WGL_DOUBLE_BUFFER_ARB 0x2011 +#define WGL_NO_ACCELERATION_ARB 0x2025 +#define WGL_GENERIC_ACCELERATION_ARB 0x2026 +#define WGL_FULL_ACCELERATION_ARB 0x2027 + +static BOOL (WINAPI *pwglChoosePixelFormatARB)(HDC, const int *, const FLOAT *, UINT, int *, UINT *); +static BOOL (WINAPI *pwglGetPixelFormatAttribivARB)(HDC, int, int, UINT, const int *, int *); + +/* WGL_ARB_pbuffer */ +#define WGL_DRAW_TO_PBUFFER_ARB 0x202D +static HPBUFFERARB* (WINAPI *pwglCreatePbufferARB)(HDC, int, int, int, const int *); +static HDC (WINAPI *pwglGetPbufferDCARB)(HPBUFFERARB); + +static const char* wgl_extensions = NULL; + +static void init_functions(void) +{ +#define GET_PROC(func) \ + p ## func = (void*)wglGetProcAddress(#func); \ + if(!p ## func) \ + trace("wglGetProcAddress(%s) failed\n", #func); + + /* WGL_ARB_create_context */ + GET_PROC(wglCreateContextAttribsARB); + + /* WGL_ARB_extensions_string */ + GET_PROC(wglGetExtensionsStringARB) + + /* WGL_ARB_make_current_read */ + GET_PROC(wglMakeContextCurrentARB); + GET_PROC(wglGetCurrentReadDCARB); + + /* WGL_ARB_pixel_format */ + GET_PROC(wglChoosePixelFormatARB) + GET_PROC(wglGetPixelFormatAttribivARB) + + /* WGL_ARB_pbuffer */ + GET_PROC(wglCreatePbufferARB) + GET_PROC(wglGetPbufferDCARB) + GET_PROC(wglReleasePbufferDCARB) + +#undef GET_PROC +} + +static void test_pbuffers(HDC hdc) +{ + const int iAttribList[] = { WGL_DRAW_TO_PBUFFER_ARB, 1, /* Request pbuffer support */ + 0 }; + int iFormats[MAX_FORMATS]; + unsigned int nOnscreenFormats; + unsigned int nFormats; + int i, res; + int iPixelFormat = 0; + + nOnscreenFormats = DescribePixelFormat(hdc, 0, 0, NULL); + + /* When you want to render to a pbuffer you need to call wglGetPbufferDCARB which + * returns a 'magic' HDC which you can then pass to wglMakeCurrent to switch rendering + * to the pbuffer. Below some tests are performed on what happens if you use standard WGL calls + * on this 'magic' HDC for both a pixelformat that support onscreen and offscreen rendering + * and a pixelformat that's only available for offscreen rendering (this means that only + * wglChoosePixelFormatARB and friends know about the format. + * + * The first thing we need are pixelformats with pbuffer capabilities. + */ + res = pwglChoosePixelFormatARB(hdc, iAttribList, NULL, MAX_FORMATS, iFormats, &nFormats); + if(res <= 0) + { + skip("No pbuffer compatible formats found while WGL_ARB_pbuffer is supported\n"); + return; + } + trace("nOnscreenFormats: %d\n", nOnscreenFormats); + trace("Total number of pbuffer capable pixelformats: %d\n", nFormats); + + /* Try to select an onscreen pixelformat out of the list */ + for(i=0; i < nFormats; i++) + { + /* Check if the format is onscreen, if it is choose it */ + if(iFormats[i] <= nOnscreenFormats) + { + iPixelFormat = iFormats[i]; + trace("Selected iPixelFormat=%d\n", iPixelFormat); + break; + } + } + + /* A video driver supports a large number of onscreen and offscreen pixelformats. + * The traditional WGL calls only see a subset of the whole pixelformat list. First + * of all they only see the onscreen formats (the offscreen formats are at the end of the + * pixelformat list) and second extended pixelformat capabilities are hidden from the + * standard WGL calls. Only functions that depend on WGL_ARB_pixel_format can see them. + * + * Below we check if the pixelformat is also supported onscreen. + */ + if(iPixelFormat != 0) + { + HDC pbuffer_hdc; + HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL); + if(!pbuffer) + skip("Pbuffer creation failed!\n"); + + /* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */ + pbuffer_hdc = pwglGetPbufferDCARB(pbuffer); + res = GetPixelFormat(pbuffer_hdc); + ok(res == iPixelFormat, "Unexpected iPixelFormat=%d returned by GetPixelFormat for format %d\n", res, iPixelFormat); + trace("iPixelFormat returned by GetPixelFormat: %d\n", res); + trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat); + + pwglReleasePbufferDCARB(pbuffer, hdc); + } + else skip("Pbuffer test for onscreen pixelformat skipped as no onscreen format with pbuffer capabilities have been found\n"); + + /* Search for a real offscreen format */ + for(i=0, iPixelFormat=0; i<nFormats; i++) + { + if(iFormats[i] > nOnscreenFormats) + { + iPixelFormat = iFormats[i]; + trace("Selected iPixelFormat: %d\n", iPixelFormat); + break; + } + } + + if(iPixelFormat != 0) + { + HDC pbuffer_hdc; + HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL); + if(!pbuffer) + skip("Pbuffer creation failed!\n"); + + /* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */ + pbuffer_hdc = pwglGetPbufferDCARB(pbuffer); + res = GetPixelFormat(pbuffer_hdc); + + ok(res == 1, "Unexpected iPixelFormat=%d (1 expected) returned by GetPixelFormat for offscreen format %d\n", res, iPixelFormat); + trace("iPixelFormat returned by GetPixelFormat: %d\n", res); + trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat); + pwglReleasePbufferDCARB(pbuffer, hdc); + } + else skip("Pbuffer test for offscreen pixelformat skipped as no offscreen-only format with pbuffer capabilities has been found\n"); +} + +static void test_setpixelformat(HDC winhdc) +{ + int res = 0; + int nCfgs; + int pf; + int i; + HWND hwnd; + PIXELFORMATDESCRIPTOR pfd = { + sizeof(PIXELFORMATDESCRIPTOR), + 1, /* version */ + PFD_DRAW_TO_WINDOW | + PFD_SUPPORT_OPENGL | + PFD_DOUBLEBUFFER, + PFD_TYPE_RGBA, + 24, /* 24-bit color depth */ + 0, 0, 0, 0, 0, 0, /* color bits */ + 0, /* alpha buffer */ + 0, /* shift bit */ + 0, /* accumulation buffer */ + 0, 0, 0, 0, /* accum bits */ + 32, /* z-buffer */ + 0, /* stencil buffer */ + 0, /* auxiliary buffer */ + PFD_MAIN_PLANE, /* main layer */ + 0, /* reserved */ + 0, 0, 0 /* layer masks */ + }; + + HDC hdc = GetDC(0); + ok(hdc != 0, "GetDC(0) failed!\n"); + + /* This should pass even on the main device context */ + pf = ChoosePixelFormat(hdc, &pfd); + ok(pf != 0, "ChoosePixelFormat failed on main device context\n"); + + /* SetPixelFormat on the main device context 'X root window' should fail, + * but some broken drivers allow it + */ + res = SetPixelFormat(hdc, pf, &pfd); + trace("SetPixelFormat on main device context %s\n", res ? "succeeded" : "failed"); + + /* Setting the same format that was set on the HDC is allowed; other + formats fail */ + nCfgs = DescribePixelFormat(winhdc, 0, 0, NULL); + pf = GetPixelFormat(winhdc); + for(i = 1;i <= nCfgs;i++) + { + int res = SetPixelFormat(winhdc, i, NULL); + if(i == pf) ok(res, "Failed to set the same pixel format\n"); + else ok(!res, "Unexpectedly set an alternate pixel format\n"); + } + + hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW, + 10, 10, 200, 200, NULL, NULL, NULL, NULL); + ok(hwnd != NULL, "err: %d\n", GetLastError()); + if (hwnd) + { + HDC hdc = GetDC( hwnd ); + pf = ChoosePixelFormat( hdc, &pfd ); + ok( pf != 0, "ChoosePixelFormat failed\n" ); + res = SetPixelFormat( hdc, pf, &pfd ); + ok( res != 0, "SetPixelFormat failed\n" ); + i = GetPixelFormat( hdc ); + ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf ); + ReleaseDC( hwnd, hdc ); + hdc = GetWindowDC( hwnd ); + i = GetPixelFormat( hdc ); + ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf ); + ReleaseDC( hwnd, hdc ); + DestroyWindow( hwnd ); + } + + hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW, + 10, 10, 200, 200, NULL, NULL, NULL, NULL); + ok(hwnd != NULL, "err: %d\n", GetLastError()); + if (hwnd) + { + HDC hdc = GetWindowDC( hwnd ); + pf = ChoosePixelFormat( hdc, &pfd ); + ok( pf != 0, "ChoosePixelFormat failed\n" ); + res = SetPixelFormat( hdc, pf, &pfd ); + ok( res != 0, "SetPixelFormat failed\n" ); + i = GetPixelFormat( hdc ); + ok( i == pf, "GetPixelFormat returned wrong format %d/%d\n", i, pf ); + ReleaseDC( hwnd, hdc ); + DestroyWindow( hwnd ); + } +} + +static void test_sharelists(HDC winhdc) +{ + HGLRC hglrc1, hglrc2, hglrc3; + int res; + + hglrc1 = wglCreateContext(winhdc); + res = wglShareLists(0, 0); + ok(res == FALSE, "Sharing display lists for no contexts passed!\n"); + + /* Test 1: Create a context and just share lists without doing anything special */ + hglrc2 = wglCreateContext(winhdc); + if(hglrc2) + { + res = wglShareLists(hglrc1, hglrc2); + ok(res, "Sharing of display lists failed\n"); + wglDeleteContext(hglrc2); + } + + /* Test 2: Share display lists with a 'destination' context which has been made current */ + hglrc2 = wglCreateContext(winhdc); + if(hglrc2) + { + res = wglMakeCurrent(winhdc, hglrc2); + ok(res, "Make current failed\n"); + res = wglShareLists(hglrc1, hglrc2); + todo_wine ok(res, "Sharing display lists with a destination context which has been made current failed\n"); + wglMakeCurrent(0, 0); + wglDeleteContext(hglrc2); + } + + /* Test 3: Share display lists with a context which already shares display lists with another context. + * According to MSDN the second parameter cannot share any display lists but some buggy drivers might allow it */ + hglrc3 = wglCreateContext(winhdc); + if(hglrc3) + { + res = wglShareLists(hglrc3, hglrc1); + ok(res == FALSE, "Sharing of display lists passed for a context which already shared lists before\n"); + wglDeleteContext(hglrc3); + } + + /* Test 4: Share display lists with a 'source' context which has been made current */ + hglrc2 = wglCreateContext(winhdc); + if(hglrc2) + { + res = wglMakeCurrent(winhdc, hglrc1); + ok(res, "Make current failed\n"); + res = wglShareLists(hglrc1, hglrc2); + ok(res, "Sharing display lists with a source context which has been made current failed\n"); + wglMakeCurrent(0, 0); + wglDeleteContext(hglrc2); + } +} + +static void test_makecurrent(HDC winhdc) +{ + BOOL ret; + HGLRC hglrc; + DWORD error; + + hglrc = wglCreateContext(winhdc); + ok( hglrc != 0, "wglCreateContext failed\n" ); + + ret = wglMakeCurrent( winhdc, hglrc ); + ok( ret, "wglMakeCurrent failed\n" ); + + ok( wglGetCurrentContext() == hglrc, "wrong context\n" ); + + /* set the same context again */ + ret = wglMakeCurrent( winhdc, hglrc ); + ok( ret, "wglMakeCurrent failed\n" ); + + /* check wglMakeCurrent(x, y) after another call to wglMakeCurrent(x, y) */ + ret = wglMakeCurrent( winhdc, NULL ); + ok( ret, "wglMakeCurrent failed\n" ); + + ret = wglMakeCurrent( winhdc, NULL ); + ok( ret, "wglMakeCurrent failed\n" ); + + SetLastError( 0xdeadbeef ); + ret = wglMakeCurrent( NULL, NULL ); + ok( !ret, "wglMakeCurrent succeeded\n" ); + error = GetLastError(); + ok( error == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got error=%x\n", error); + + ret = wglMakeCurrent( winhdc, NULL ); + ok( ret, "wglMakeCurrent failed\n" ); + + ret = wglMakeCurrent( winhdc, hglrc ); + ok( ret, "wglMakeCurrent failed\n" ); + + ret = wglMakeCurrent( NULL, NULL ); + ok( ret, "wglMakeCurrent failed\n" ); + + SetLastError( 0xdeadbeef ); + ret = wglMakeCurrent( NULL, NULL ); + ok( !ret, "wglMakeCurrent succeeded\n" ); + error = GetLastError(); + ok( error == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got error=%x\n", error); + + ret = wglMakeCurrent( winhdc, hglrc ); + ok( ret, "wglMakeCurrent failed\n" ); +} + +static void test_colorbits(HDC hdc) +{ + const int iAttribList[] = { WGL_COLOR_BITS_ARB, WGL_RED_BITS_ARB, WGL_GREEN_BITS_ARB, + WGL_BLUE_BITS_ARB, WGL_ALPHA_BITS_ARB }; + int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])]; + const int iAttribs[] = { WGL_ALPHA_BITS_ARB, 1, 0 }; + unsigned int nFormats; + int res; + int iPixelFormat = 0; + + if (!pwglChoosePixelFormatARB) + { + win_skip("wglChoosePixelFormatARB is not available\n"); + return; + } + + /* We need a pixel format with at least one bit of alpha */ + res = pwglChoosePixelFormatARB(hdc, iAttribs, NULL, 1, &iPixelFormat, &nFormats); + if(res == FALSE || nFormats == 0) + { + skip("No suitable pixel formats found\n"); + return; + } + + res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, + sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList, iAttribRet); + if(res == FALSE) + { + skip("wglGetPixelFormatAttribivARB failed\n"); + return; + } + iAttribRet[1] += iAttribRet[2]+iAttribRet[3]+iAttribRet[4]; + ok(iAttribRet[0] == iAttribRet[1], "WGL_COLOR_BITS_ARB (%d) does not equal R+G+B+A (%d)!\n", + iAttribRet[0], iAttribRet[1]); +} + +static void test_gdi_dbuf(HDC hdc) +{ + const int iAttribList[] = { WGL_SUPPORT_GDI_ARB, WGL_DOUBLE_BUFFER_ARB }; + int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])]; + unsigned int nFormats; + int iPixelFormat; + int res; + + if (!pwglGetPixelFormatAttribivARB) + { + win_skip("wglGetPixelFormatAttribivARB is not available\n"); + return; + } + + nFormats = DescribePixelFormat(hdc, 0, 0, NULL); + for(iPixelFormat = 1;iPixelFormat <= nFormats;iPixelFormat++) + { + res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, + sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList, + iAttribRet); + ok(res!=FALSE, "wglGetPixelFormatAttribivARB failed for pixel format %d\n", iPixelFormat); + if(res == FALSE) + continue; + + ok(!(iAttribRet[0] && iAttribRet[1]), "GDI support and double buffering on pixel format %d\n", iPixelFormat); + } +} + +static void test_acceleration(HDC hdc) +{ + const int iAttribList[] = { WGL_ACCELERATION_ARB }; + int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])]; + unsigned int nFormats; + int iPixelFormat; + int res; + PIXELFORMATDESCRIPTOR pfd; + + if (!pwglGetPixelFormatAttribivARB) + { + win_skip("wglGetPixelFormatAttribivARB is not available\n"); + return; + } + + nFormats = DescribePixelFormat(hdc, 0, 0, NULL); + for(iPixelFormat = 1; iPixelFormat <= nFormats; iPixelFormat++) + { + res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, + sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList, + iAttribRet); + ok(res!=FALSE, "wglGetPixelFormatAttribivARB failed for pixel format %d\n", iPixelFormat); + if(res == FALSE) + continue; + + memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR)); + DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd); + + switch(iAttribRet[0]) + { + case WGL_NO_ACCELERATION_ARB: + 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); + break; + case WGL_GENERIC_ACCELERATION_ARB: + 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); + break; + case WGL_FULL_ACCELERATION_ARB: + 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); + break; + } + } +} + +static void test_make_current_read(HDC hdc) +{ + int res; + HDC hread; + HGLRC hglrc = wglCreateContext(hdc); + + if(!hglrc) + { + skip("wglCreateContext failed!\n"); + return; + } + + res = wglMakeCurrent(hdc, hglrc); + if(!res) + { + skip("wglMakeCurrent failed!\n"); + return; + } + + /* Test what wglGetCurrentReadDCARB does for wglMakeCurrent as the spec doesn't mention it */ + hread = pwglGetCurrentReadDCARB(); + trace("hread %p, hdc %p\n", hread, hdc); + ok(hread == hdc, "wglGetCurrentReadDCARB failed for standard wglMakeCurrent\n"); + + pwglMakeContextCurrentARB(hdc, hdc, hglrc); + hread = pwglGetCurrentReadDCARB(); + ok(hread == hdc, "wglGetCurrentReadDCARB failed for wglMakeContextCurrent\n"); +} + +static void test_dc(HWND hwnd, HDC hdc) +{ + int pf1, pf2; + HDC hdc2; + + /* Get another DC and make sure it has the same pixel format */ + hdc2 = GetDC(hwnd); + if(hdc != hdc2) + { + pf1 = GetPixelFormat(hdc); + pf2 = GetPixelFormat(hdc2); + ok(pf1 == pf2, "Second DC does not have the same format (%d != %d)\n", pf1, pf2); + } + else + skip("Could not get a different DC for the window\n"); + + if(hdc2) + { + ReleaseDC(hwnd, hdc2); + hdc2 = NULL; + } +} + +/* Nvidia converts win32 error codes to (0xc007 << 16) | win32_error_code */ +#define NVIDIA_HRESULT_FROM_WIN32(x) (HRESULT_FROM_WIN32(x) | 0x40000000) +static void test_opengl3(HDC hdc) +{ + /* Try to create a context compatible with OpenGL 1.x; 1.0-2.1 is allowed */ + { + HGLRC gl3Ctx; + int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 1, 0}; + + gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs); + ok(gl3Ctx != 0, "pwglCreateContextAttribsARB for a 1.x context failed!\n"); + wglDeleteContext(gl3Ctx); + } + + /* Try to pass an invalid HDC */ + { + HGLRC gl3Ctx; + DWORD error; + gl3Ctx = pwglCreateContextAttribsARB((HDC)0xdeadbeef, 0, 0); + ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid HDC passed\n"); + error = GetLastError(); + todo_wine ok(error == ERROR_DC_NOT_FOUND || + broken(error == NVIDIA_HRESULT_FROM_WIN32(ERROR_INVALID_DATA)), /* Nvidia Vista + Win7 */ + "Expected ERROR_DC_NOT_FOUND, got error=%x\n", error); + wglDeleteContext(gl3Ctx); + } + + /* Try to pass an invalid shareList */ + { + HGLRC gl3Ctx; + DWORD error; + gl3Ctx = pwglCreateContextAttribsARB(hdc, (HGLRC)0xdeadbeef, 0); + todo_wine ok(gl3Ctx == 0, "pwglCreateContextAttribsARB using an invalid shareList passed\n"); + error = GetLastError(); + /* The Nvidia implementation seems to return hresults instead of win32 error codes */ + todo_wine ok(error == ERROR_INVALID_OPERATION || + error == NVIDIA_HRESULT_FROM_WIN32(ERROR_INVALID_OPERATION), "Expected ERROR_INVALID_OPERATION, got error=%x\n", error); + wglDeleteContext(gl3Ctx); + } + + /* Try to create an OpenGL 3.0 context */ + { + int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0}; + HGLRC gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs); + + if(gl3Ctx == NULL) + { + skip("Skipping the rest of the WGL_ARB_create_context test due to lack of OpenGL 3.0\n"); + return; + } + + wglDeleteContext(gl3Ctx); + } + + /* 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 */ + { + HGLRC glCtx = wglCreateContext(hdc); + + int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0}; + 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}; + + HGLRC gl3Ctx = pwglCreateContextAttribsARB(hdc, glCtx, attribs); + ok(gl3Ctx != NULL, "Sharing of a display list between OpenGL 3.0 and OpenGL 1.x/2.x failed!\n"); + if(gl3Ctx) + wglDeleteContext(gl3Ctx); + + gl3Ctx = pwglCreateContextAttribsARB(hdc, glCtx, attribs_future); + ok(gl3Ctx != NULL, "Sharing of a display list between a forward compatible OpenGL 3.0 context and OpenGL 1.x/2.x failed!\n"); + if(gl3Ctx) + wglDeleteContext(gl3Ctx); + + if(glCtx) + wglDeleteContext(glCtx); + } + + /* Try to create an OpenGL 3.0 context and test windowless rendering */ + { + HGLRC gl3Ctx; + int attribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB, 3, WGL_CONTEXT_MINOR_VERSION_ARB, 0, 0}; + BOOL res; + + gl3Ctx = pwglCreateContextAttribsARB(hdc, 0, attribs); + ok(gl3Ctx != 0, "pwglCreateContextAttribsARB for a 3.0 context failed!\n"); + + /* OpenGL 3.0 allows offscreen rendering WITHOUT a drawable + * Neither AMD or Nvidia support it at this point. The WGL_ARB_create_context specs also say that + * it is hard because drivers use the HDC to enter the display driver and it sounds like they don't + * expect drivers to ever offer it. + */ + res = wglMakeCurrent(0, gl3Ctx); + ok(res == FALSE, "Wow, OpenGL 3.0 windowless rendering passed while it was expected not to!\n"); + if(res) + wglMakeCurrent(0, 0); + + if(gl3Ctx) + wglDeleteContext(gl3Ctx); + } +} + +START_TEST(opengl) +{ + HWND hwnd; + PIXELFORMATDESCRIPTOR pfd = { + sizeof(PIXELFORMATDESCRIPTOR), + 1, /* version */ + PFD_DRAW_TO_WINDOW | + PFD_SUPPORT_OPENGL | + PFD_DOUBLEBUFFER, + PFD_TYPE_RGBA, + 24, /* 24-bit color depth */ + 0, 0, 0, 0, 0, 0, /* color bits */ + 0, /* alpha buffer */ + 0, /* shift bit */ + 0, /* accumulation buffer */ + 0, 0, 0, 0, /* accum bits */ + 32, /* z-buffer */ + 0, /* stencil buffer */ + 0, /* auxiliary buffer */ + PFD_MAIN_PLANE, /* main layer */ + 0, /* reserved */ + 0, 0, 0 /* layer masks */ + }; + + hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW, + 10, 10, 200, 200, NULL, NULL, NULL, NULL); + ok(hwnd != NULL, "err: %d\n", GetLastError()); + if (hwnd) + { + HDC hdc; + int iPixelFormat, res; + HGLRC hglrc; + DWORD error; + ShowWindow(hwnd, SW_SHOW); + + hdc = GetDC(hwnd); + + iPixelFormat = ChoosePixelFormat(hdc, &pfd); + if(iPixelFormat == 0) + { + /* This should never happen as ChoosePixelFormat always returns a closest match, but currently this fails in Wine if we don't have glX */ + win_skip("Unable to find pixel format.\n"); + goto cleanup; + } + + /* We shouldn't be able to create a context from a hdc which doesn't have a pixel format set */ + hglrc = wglCreateContext(hdc); + ok(hglrc == NULL, "wglCreateContext should fail when no pixel format has been set, but it passed\n"); + error = GetLastError(); + ok(error == ERROR_INVALID_PIXEL_FORMAT, "expected ERROR_INVALID_PIXEL_FORMAT for wglCreateContext without a pixelformat set, but received %#x\n", error); + + res = SetPixelFormat(hdc, iPixelFormat, &pfd); + ok(res, "SetPixelformat failed: %x\n", GetLastError()); + + test_dc(hwnd, hdc); + + hglrc = wglCreateContext(hdc); + res = wglMakeCurrent(hdc, hglrc); + ok(res, "wglMakeCurrent failed!\n"); + if(res) + { + trace("OpenGL renderer: %s\n", glGetString(GL_RENDERER)); + trace("OpenGL driver version: %s\n", glGetString(GL_VERSION)); + trace("OpenGL vendor: %s\n", glGetString(GL_VENDOR)); + } + else + { + skip("Skipping OpenGL tests without a current context\n"); + return; + } + + /* Initialisation of WGL functions depends on an implicit WGL context. For this reason we can't load them before making + * any WGL call :( On Wine this would work but not on real Windows because there can be different implementations (software, ICD, MCD). + */ + init_functions(); + /* The lack of wglGetExtensionsStringARB in general means broken software rendering or the lack of decent OpenGL support, skip tests in such cases */ + if (!pwglGetExtensionsStringARB) + { + win_skip("wglGetExtensionsStringARB is not available\n"); + return; + } + + test_makecurrent(hdc); + test_setpixelformat(hdc); + test_sharelists(hdc); + test_colorbits(hdc); + test_gdi_dbuf(hdc); + test_acceleration(hdc); + + wgl_extensions = pwglGetExtensionsStringARB(hdc); + if(wgl_extensions == NULL) skip("Skipping opengl32 tests because this OpenGL implementation doesn't support WGL extensions!\n"); + + if(strstr(wgl_extensions, "WGL_ARB_create_context")) + test_opengl3(hdc); + + if(strstr(wgl_extensions, "WGL_ARB_make_current_read")) + test_make_current_read(hdc); + else + skip("WGL_ARB_make_current_read not supported, skipping test\n"); + + if(strstr(wgl_extensions, "WGL_ARB_pbuffer")) + test_pbuffers(hdc); + else + skip("WGL_ARB_pbuffer not supported, skipping pbuffer test\n"); + +cleanup: + ReleaseDC(hwnd, hdc); + DestroyWindow(hwnd); + } +}
Propchange: trunk/rostests/winetests/opengl32/opengl.c ------------------------------------------------------------------------------ svn:eol-style = native
Added: trunk/rostests/winetests/opengl32/opengl32.rbuild URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/opengl32/opengl3... ============================================================================== --- trunk/rostests/winetests/opengl32/opengl32.rbuild (added) +++ trunk/rostests/winetests/opengl32/opengl32.rbuild [iso-8859-1] Mon Jun 14 12:41:15 2010 @@ -1,0 +1,15 @@ +<?xml version="1.0"?> +<!DOCTYPE module SYSTEM "../../../tools/rbuild/project.dtd"> +<group> +<module name="opengl32_winetest" type="win32cui" installbase="bin" installname="opengl32_winetest.exe" allowwarnings="true"> + <compilerflag compiler="cc">-Wno-format</compilerflag> + <define name="__ROS_LONG64__" /> + <include base="opengl32_winetest">.</include> + <library>wine</library> + <library>opengl32</library> + <library>gdi32</library> + <library>user32</library> + <file>opengl.c</file> + <file>testlist.c</file> +</module> +</group>
Propchange: trunk/rostests/winetests/opengl32/opengl32.rbuild ------------------------------------------------------------------------------ svn:eol-style = native
Added: trunk/rostests/winetests/opengl32/testlist.c URL: http://svn.reactos.org/svn/reactos/trunk/rostests/winetests/opengl32/testlis... ============================================================================== --- trunk/rostests/winetests/opengl32/testlist.c (added) +++ trunk/rostests/winetests/opengl32/testlist.c [iso-8859-1] Mon Jun 14 12:41:15 2010 @@ -1,0 +1,15 @@ +/* Automatically generated file; DO NOT EDIT!! */ + +#define WIN32_LEAN_AND_MEAN +#include <windows.h> + +#define STANDALONE +#include "wine/test.h" + +extern void func_opengl(void); + +const struct test winetest_testlist[] = +{ + { "opengl", func_opengl }, + { 0, 0 } +};
Propchange: trunk/rostests/winetests/opengl32/testlist.c ------------------------------------------------------------------------------ svn:eol-style = native
-
khornicek＠svn.reactos.org