1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program Tester Core
3 * ----------------------------------------
5 * Copyright 2014 The Android Open Source Project
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
21 * \brief WGL Utilities.
22 *//*--------------------------------------------------------------------*/
25 #include "tcuWin32Window.hpp"
26 #include "deDynamicLibrary.hpp"
28 #include "deStringUtil.hpp"
29 #include "tcuFormatUtil.hpp"
30 #include "gluRenderConfig.hpp"
31 #include "glwEnums.hpp"
40 // WGL_ARB_pixel_format
41 #define WGL_NUMBER_PIXEL_FORMATS_ARB 0x2000
42 #define WGL_DRAW_TO_WINDOW_ARB 0x2001
43 #define WGL_DRAW_TO_BITMAP_ARB 0x2002
44 #define WGL_ACCELERATION_ARB 0x2003
45 #define WGL_NEED_PALETTE_ARB 0x2004
46 #define WGL_NEED_SYSTEM_PALETTE_ARB 0x2005
47 #define WGL_SWAP_LAYER_BUFFERS_ARB 0x2006
48 #define WGL_SWAP_METHOD_ARB 0x2007
49 #define WGL_NUMBER_OVERLAYS_ARB 0x2008
50 #define WGL_NUMBER_UNDERLAYS_ARB 0x2009
51 #define WGL_TRANSPARENT_ARB 0x200A
52 #define WGL_TRANSPARENT_RED_VALUE_ARB 0x2037
53 #define WGL_TRANSPARENT_GREEN_VALUE_ARB 0x2038
54 #define WGL_TRANSPARENT_BLUE_VALUE_ARB 0x2039
55 #define WGL_TRANSPARENT_ALPHA_VALUE_ARB 0x203A
56 #define WGL_TRANSPARENT_INDEX_VALUE_ARB 0x203B
57 #define WGL_SHARE_DEPTH_ARB 0x200C
58 #define WGL_SHARE_STENCIL_ARB 0x200D
59 #define WGL_SHARE_ACCUM_ARB 0x200E
60 #define WGL_SUPPORT_GDI_ARB 0x200F
61 #define WGL_SUPPORT_OPENGL_ARB 0x2010
62 #define WGL_DOUBLE_BUFFER_ARB 0x2011
63 #define WGL_STEREO_ARB 0x2012
64 #define WGL_PIXEL_TYPE_ARB 0x2013
65 #define WGL_COLOR_BITS_ARB 0x2014
66 #define WGL_RED_BITS_ARB 0x2015
67 #define WGL_RED_SHIFT_ARB 0x2016
68 #define WGL_GREEN_BITS_ARB 0x2017
69 #define WGL_GREEN_SHIFT_ARB 0x2018
70 #define WGL_BLUE_BITS_ARB 0x2019
71 #define WGL_BLUE_SHIFT_ARB 0x201A
72 #define WGL_ALPHA_BITS_ARB 0x201B
73 #define WGL_ALPHA_SHIFT_ARB 0x201C
74 #define WGL_ACCUM_BITS_ARB 0x201D
75 #define WGL_ACCUM_RED_BITS_ARB 0x201E
76 #define WGL_ACCUM_GREEN_BITS_ARB 0x201F
77 #define WGL_ACCUM_BLUE_BITS_ARB 0x2020
78 #define WGL_ACCUM_ALPHA_BITS_ARB 0x2021
79 #define WGL_DEPTH_BITS_ARB 0x2022
80 #define WGL_STENCIL_BITS_ARB 0x2023
81 #define WGL_AUX_BUFFERS_ARB 0x2024
83 #define WGL_NO_ACCELERATION_ARB 0x2025
84 #define WGL_GENERIC_ACCELERATION_ARB 0x2026
85 #define WGL_FULL_ACCELERATION_ARB 0x2027
87 #define WGL_TYPE_RGBA_ARB 0x202B
88 #define WGL_TYPE_COLORINDEX_ARB 0x202C
90 // WGL_ARB_color_buffer_float
91 #define WGL_TYPE_RGBA_FLOAT_ARB 0x21A0
93 // WGL_EXT_pixel_type_packed_float
94 #define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT 0x20A8
96 // WGL_ARB_multisample
97 #define WGL_SAMPLE_BUFFERS_ARB 0x2041
98 #define WGL_SAMPLES_ARB 0x2042
100 // WGL_EXT_colorspace
101 #define WGL_COLORSPACE_EXT 0x309D
102 #define WGL_COLORSPACE_SRGB_EXT 0x3089
103 #define WGL_COLORSPACE_LINEAR_EXT 0x308A
105 // WGL_ARB_create_context
106 #define WGL_CONTEXT_MAJOR_VERSION_ARB 0x2091
107 #define WGL_CONTEXT_MINOR_VERSION_ARB 0x2092
108 #define WGL_CONTEXT_LAYER_PLANE_ARB 0x2093
109 #define WGL_CONTEXT_FLAGS_ARB 0x2094
110 #define WGL_CONTEXT_PROFILE_MASK_ARB 0x9126
111 #define WGL_CONTEXT_DEBUG_BIT_ARB 0x0001
112 #define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x0002
113 #define WGL_CONTEXT_CORE_PROFILE_BIT_ARB 0x00000001
114 #define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
115 #define WGL_CONTEXT_ES_PROFILE_BIT_EXT 0x00000004
117 // WGL_ARB_create_context_robustness
118 #define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB 0x0004
119 #define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB 0x8256
120 #define WGL_NO_RESET_NOTIFICATION_ARB 0x8261
121 #define WGL_LOSE_CONTEXT_ON_RESET_ARB 0x8252
123 // WGL ARB_create_context_no_error
124 #define WGL_CONTEXT_OPENGL_NO_ERROR_ARB 0x31B3
129 typedef HGLRC (WINAPI* wglCreateContextFunc) (HDC hdc);
130 typedef BOOL (WINAPI* wglDeleteContextFunc) (HGLRC hglrc);
131 typedef BOOL (WINAPI* wglMakeCurrentFunc) (HDC hdc, HGLRC hglrc);
132 typedef PROC (WINAPI* wglGetProcAddressFunc) (LPCSTR lpszProc);
133 typedef BOOL (WINAPI* wglSwapLayerBuffersFunc) (HDC dhc, UINT fuPlanes);
135 // WGL_ARB_pixel_format
136 typedef BOOL (WINAPI* wglGetPixelFormatAttribivARBFunc) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
137 typedef BOOL (WINAPI* wglGetPixelFormatAttribfvARBFunc) (HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
138 typedef BOOL (WINAPI* wglChoosePixelFormatARBFunc) (HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
140 // WGL_ARB_create_context
141 typedef HGLRC (WINAPI* wglCreateContextAttribsARBFunc) (HDC hdc, HGLRC hshareContext, const int* attribList);
142 typedef const char* (WINAPI* wglGetExtensionsStringARBFunc) (HDC hdc);
144 // WGL_EXT_swap_control
145 typedef BOOL (WINAPI* wglSwapIntervalEXTFunc) (int interval);
159 wglCreateContextFunc createContext;
160 wglDeleteContextFunc deleteContext;
161 wglMakeCurrentFunc makeCurrent;
162 wglGetProcAddressFunc getProcAddress;
163 wglSwapLayerBuffersFunc swapLayerBuffers;
165 // WGL_ARB_pixel_format
166 wglGetPixelFormatAttribivARBFunc getPixelFormatAttribivARB;
167 wglGetPixelFormatAttribfvARBFunc getPixelFormatAttribfvARB;
168 wglChoosePixelFormatARBFunc choosePixelFormatARB;
170 // WGL_ARB_create_context
171 wglCreateContextAttribsARBFunc createContextAttribsARB;
172 wglGetExtensionsStringARBFunc getExtensionsStringARB;
174 // WGL_EXT_swap_control
175 wglSwapIntervalEXTFunc swapIntervalEXT;
179 : createContext (DE_NULL)
180 , deleteContext (DE_NULL)
181 , makeCurrent (DE_NULL)
182 , getProcAddress (DE_NULL)
183 , swapLayerBuffers (DE_NULL)
184 , getPixelFormatAttribivARB (DE_NULL)
185 , getPixelFormatAttribfvARB (DE_NULL)
186 , choosePixelFormatARB (DE_NULL)
187 , createContextAttribsARB (DE_NULL)
188 , getExtensionsStringARB (DE_NULL)
198 Library (HINSTANCE instance);
201 const Functions& getFunctions (void) const { return m_functions; }
202 const de::DynamicLibrary& getGLLibrary (void) const { return m_library; }
203 bool isWglExtensionSupported (const char* extName) const;
206 de::DynamicLibrary m_library;
207 Functions m_functions;
208 std::set<std::string> m_extensions;
211 Library::Library (HINSTANCE instance)
212 : m_library("opengl32.dll")
214 // Temporary 1x1 window for creating context
215 win32::Window tmpWindow(instance, 1, 1);
218 m_functions.createContext = (wglCreateContextFunc) m_library.getFunction("wglCreateContext");
219 m_functions.deleteContext = (wglDeleteContextFunc) m_library.getFunction("wglDeleteContext");
220 m_functions.getProcAddress = (wglGetProcAddressFunc) m_library.getFunction("wglGetProcAddress");
221 m_functions.makeCurrent = (wglMakeCurrentFunc) m_library.getFunction("wglMakeCurrent");
222 m_functions.swapLayerBuffers = (wglSwapLayerBuffersFunc) m_library.getFunction("wglSwapLayerBuffers");
224 if (!m_functions.createContext ||
225 !m_functions.deleteContext ||
226 !m_functions.getProcAddress ||
227 !m_functions.makeCurrent ||
228 !m_functions.swapLayerBuffers)
229 throw ResourceError("Failed to load core WGL functions");
232 PIXELFORMATDESCRIPTOR pixelFormatDesc;
233 deMemset(&pixelFormatDesc, 0, sizeof(pixelFormatDesc));
235 pixelFormatDesc.nSize = sizeof(pixelFormatDesc);
236 pixelFormatDesc.nVersion = 1;
237 pixelFormatDesc.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
238 pixelFormatDesc.iPixelType = PFD_TYPE_RGBA;
239 pixelFormatDesc.iLayerType = PFD_MAIN_PLANE;
241 int pixelFormat = ChoosePixelFormat(tmpWindow.getDeviceContext(), &pixelFormatDesc);
242 if (!SetPixelFormat(tmpWindow.getDeviceContext(), pixelFormat, &pixelFormatDesc))
243 throw ResourceError("Failed to set pixel format for temporary context creation");
246 // Create temporary context for loading extension functions.
247 HGLRC tmpCtx = m_functions.createContext(tmpWindow.getDeviceContext());
248 if (!tmpCtx || !m_functions.makeCurrent(tmpWindow.getDeviceContext(), tmpCtx))
251 m_functions.deleteContext(tmpCtx);
252 throw ResourceError("Failed to create temporary WGL context");
255 // WGL_ARB_pixel_format
256 m_functions.getPixelFormatAttribivARB = (wglGetPixelFormatAttribivARBFunc)m_functions.getProcAddress("wglGetPixelFormatAttribivARB");
257 m_functions.getPixelFormatAttribfvARB = (wglGetPixelFormatAttribfvARBFunc)m_functions.getProcAddress("wglGetPixelFormatAttribfvARB");
258 m_functions.choosePixelFormatARB = (wglChoosePixelFormatARBFunc)m_functions.getProcAddress("wglChoosePixelFormatARB");
260 // WGL_ARB_create_context
261 m_functions.createContextAttribsARB = (wglCreateContextAttribsARBFunc)m_functions.getProcAddress("wglCreateContextAttribsARB");
262 m_functions.getExtensionsStringARB = (wglGetExtensionsStringARBFunc)m_functions.getProcAddress("wglGetExtensionsStringARB");
264 // WGL_EXT_swap_control
265 m_functions.swapIntervalEXT = (wglSwapIntervalEXTFunc)m_functions.getProcAddress("wglSwapIntervalEXT");
267 m_functions.makeCurrent(tmpWindow.getDeviceContext(), NULL);
268 m_functions.deleteContext(tmpCtx);
270 if (!m_functions.getPixelFormatAttribivARB ||
271 !m_functions.getPixelFormatAttribfvARB ||
272 !m_functions.choosePixelFormatARB ||
273 !m_functions.createContextAttribsARB ||
274 !m_functions.getExtensionsStringARB)
275 throw ResourceError("Failed to load WGL extension functions");
277 const char* extensions = m_functions.getExtensionsStringARB(tmpWindow.getDeviceContext());
278 std::istringstream extStream(extensions);
279 m_extensions = std::set<std::string>(std::istream_iterator<std::string>(extStream),
280 std::istream_iterator<std::string>());
283 Library::~Library (void)
287 bool Library::isWglExtensionSupported (const char* extName) const
289 return m_extensions.find(extName) != m_extensions.end();
294 Core::Core (HINSTANCE instance)
295 : m_library(new Library(instance))
304 std::vector<int> Core::getPixelFormats (HDC deviceCtx) const
306 const Functions& wgl = m_library->getFunctions();
308 int attribs[] = { WGL_NUMBER_PIXEL_FORMATS_ARB };
309 int values[DE_LENGTH_OF_ARRAY(attribs)];
311 if (!wgl.getPixelFormatAttribivARB(deviceCtx, 0, 0, DE_LENGTH_OF_ARRAY(attribs), &attribs[0], &values[0]))
312 TCU_THROW(ResourceError, "Failed to query number of WGL pixel formats");
314 std::vector<int> pixelFormats(values[0]);
315 for (int i = 0; i < values[0]; i++)
316 pixelFormats[i] = i+1;
321 static PixelFormatInfo::Acceleration translateAcceleration (int accel)
325 case WGL_NO_ACCELERATION_ARB: return PixelFormatInfo::ACCELERATION_NONE;
326 case WGL_GENERIC_ACCELERATION_ARB: return PixelFormatInfo::ACCELERATION_GENERIC;
327 case WGL_FULL_ACCELERATION_ARB: return PixelFormatInfo::ACCELERATION_FULL;
328 default: return PixelFormatInfo::ACCELERATION_UNKNOWN;
332 static PixelFormatInfo::PixelType translatePixelType (int type)
336 case WGL_TYPE_RGBA_ARB: return PixelFormatInfo::PIXELTYPE_RGBA;
337 case WGL_TYPE_RGBA_FLOAT_ARB: return PixelFormatInfo::PIXELTYPE_RGBA_FLOAT;
338 case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT: return PixelFormatInfo::PIXELTYPE_RGBA_UNSIGNED_FLOAT;
339 case WGL_TYPE_COLORINDEX_ARB: return PixelFormatInfo::PIXELTYPE_COLOR_INDEX;
340 default: return PixelFormatInfo::PIXELTYPE_UNKNOWN;
344 static void getPixelFormatAttribs (const Functions& wgl, HDC deviceCtx, int pixelFormat, int numAttribs, const int* attribs, std::map<int, int>* dst)
346 std::vector<int> values (numAttribs);
348 if (!wgl.getPixelFormatAttribivARB(deviceCtx, pixelFormat, 0, numAttribs, &attribs[0], &values[0]))
349 TCU_THROW(ResourceError, "Pixel format query failed");
351 for (int ndx = 0; ndx < numAttribs; ++ndx)
352 (*dst)[attribs[ndx]] = values[ndx];
355 PixelFormatInfo Core::getPixelFormatInfo (HDC deviceCtx, int pixelFormat) const
357 std::vector<int> s_attribsToQuery
359 WGL_DRAW_TO_WINDOW_ARB,
360 WGL_DRAW_TO_BITMAP_ARB,
361 WGL_ACCELERATION_ARB,
362 WGL_NEED_PALETTE_ARB,
363 WGL_NEED_SYSTEM_PALETTE_ARB,
364 WGL_NUMBER_OVERLAYS_ARB,
365 WGL_NUMBER_UNDERLAYS_ARB,
366 WGL_SUPPORT_OPENGL_ARB,
367 WGL_DOUBLE_BUFFER_ARB,
376 WGL_STENCIL_BITS_ARB,
378 WGL_SAMPLE_BUFFERS_ARB,
381 if (getLibrary()->isWglExtensionSupported("WGL_EXT_colorspace"))
382 s_attribsToQuery.push_back(WGL_COLORSPACE_EXT);
384 const Functions& wgl = m_library->getFunctions();
385 std::map<int, int> values;
387 getPixelFormatAttribs(wgl, deviceCtx, pixelFormat, static_cast<int>(s_attribsToQuery.size()), s_attribsToQuery.data(), &values);
390 PixelFormatInfo info;
392 info.pixelFormat = pixelFormat;
393 info.surfaceTypes |= (values[WGL_DRAW_TO_WINDOW_ARB] ? PixelFormatInfo::SURFACE_WINDOW : 0);
394 info.surfaceTypes |= (values[WGL_DRAW_TO_BITMAP_ARB] ? PixelFormatInfo::SURFACE_PIXMAP : 0);
395 info.acceleration = translateAcceleration(values[WGL_ACCELERATION_ARB]);
396 info.needPalette = values[WGL_NEED_PALETTE_ARB] != 0;
397 info.needSystemPalette = values[WGL_NEED_SYSTEM_PALETTE_ARB] != 0;
398 info.numOverlays = values[WGL_NUMBER_OVERLAYS_ARB] != 0;
399 info.numUnderlays = values[WGL_NUMBER_UNDERLAYS_ARB] != 0;
400 info.supportOpenGL = values[WGL_SUPPORT_OPENGL_ARB] != 0;
401 info.doubleBuffer = values[WGL_DOUBLE_BUFFER_ARB] != 0;
402 info.stereo = values[WGL_STEREO_ARB] != 0;
403 info.pixelType = translatePixelType(values[WGL_PIXEL_TYPE_ARB]);
404 info.redBits = values[WGL_RED_BITS_ARB];
405 info.greenBits = values[WGL_GREEN_BITS_ARB];
406 info.blueBits = values[WGL_BLUE_BITS_ARB];
407 info.alphaBits = values[WGL_ALPHA_BITS_ARB];
408 info.accumBits = values[WGL_ACCUM_BITS_ARB];
409 info.depthBits = values[WGL_DEPTH_BITS_ARB];
410 info.stencilBits = values[WGL_STENCIL_BITS_ARB];
411 info.numAuxBuffers = values[WGL_AUX_BUFFERS_ARB];
412 info.sampleBuffers = values[WGL_SAMPLE_BUFFERS_ARB];
413 info.samples = values[WGL_SAMPLES_ARB];
414 info.sRGB = (getLibrary()->isWglExtensionSupported("WGL_EXT_colorspace")) ? (values[WGL_COLORSPACE_EXT] == WGL_COLORSPACE_SRGB_EXT) : false;
421 Context::Context (const Core* core,
423 const Context* sharedContext,
424 glu::ContextType ctxType,
426 glu::ResetNotificationStrategy resetNotificationStrategy)
428 , m_deviceCtx (deviceCtx)
431 const Functions& wgl = core->getLibrary()->getFunctions();
432 std::vector<int> attribList;
434 // Context version and profile
437 HGLRC sharedCtx = DE_NULL;
438 int minor = ctxType.getMinorVersion();
439 int major = ctxType.getMajorVersion();
441 switch (ctxType.getProfile())
443 case glu::PROFILE_CORE:
444 profileBit = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
445 if (major == 3 && minor < 3)
449 case glu::PROFILE_ES:
450 profileBit = WGL_CONTEXT_ES_PROFILE_BIT_EXT;
453 case glu::PROFILE_COMPATIBILITY:
454 profileBit = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
458 TCU_THROW(NotSupportedError, "Unsupported context type for WGL");
461 attribList.push_back(WGL_CONTEXT_MAJOR_VERSION_ARB);
462 attribList.push_back(major);
463 attribList.push_back(WGL_CONTEXT_MINOR_VERSION_ARB);
464 attribList.push_back(minor);
465 attribList.push_back(WGL_CONTEXT_PROFILE_MASK_ARB);
466 attribList.push_back(profileBit);
473 if ((ctxType.getFlags() & glu::CONTEXT_FORWARD_COMPATIBLE) != 0)
475 if (glu::isContextTypeES(ctxType))
476 TCU_THROW(InternalError, "Only OpenGL core contexts can be forward-compatible");
478 flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
481 if ((ctxType.getFlags() & glu::CONTEXT_DEBUG) != 0)
482 flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
484 if ((ctxType.getFlags() & glu::CONTEXT_ROBUST) != 0)
485 flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
487 if ((ctxType.getFlags() & glu::CONTEXT_NO_ERROR) != 0)
489 if (core->getLibrary()->isWglExtensionSupported("WGL_ARB_create_context_no_error"))
491 attribList.push_back(WGL_CONTEXT_OPENGL_NO_ERROR_ARB);
492 attribList.push_back(1);
495 TCU_THROW(NotSupportedError, "WGL_ARB_create_context_no_error is required for creating no-error contexts");
500 attribList.push_back(WGL_CONTEXT_FLAGS_ARB);
501 attribList.push_back(flags);
505 if (resetNotificationStrategy != glu::RESET_NOTIFICATION_STRATEGY_NOT_SPECIFIED)
507 attribList.push_back(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB);
509 if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_NO_RESET_NOTIFICATION)
510 attribList.push_back(WGL_NO_RESET_NOTIFICATION_ARB);
511 else if (resetNotificationStrategy == glu::RESET_NOTIFICATION_STRATEGY_LOSE_CONTEXT_ON_RESET)
512 attribList.push_back(WGL_LOSE_CONTEXT_ON_RESET_ARB);
514 TCU_THROW(InternalError, "Unknown reset notification strategy");
519 PIXELFORMATDESCRIPTOR pixelFormatDesc;
520 deMemset(&pixelFormatDesc, 0, sizeof(pixelFormatDesc));
522 if (!DescribePixelFormat(deviceCtx, pixelFormat, sizeof(pixelFormatDesc), &pixelFormatDesc))
523 throw ResourceError("DescribePixelFormat() failed");
525 if (!SetPixelFormat(deviceCtx, pixelFormat, &pixelFormatDesc))
526 throw ResourceError("Failed to set pixel format");
529 HGLRC sharedCtx = DE_NULL;
530 if (DE_NULL != sharedContext)
531 sharedCtx = sharedContext->m_context;
533 // Terminate attribList
534 attribList.push_back(0);
537 m_context = wgl.createContextAttribsARB(deviceCtx, sharedCtx, &attribList[0]);
540 TCU_THROW(ResourceError, "Failed to create WGL context");
542 if (!wgl.makeCurrent(deviceCtx, m_context))
544 wgl.deleteContext(m_context);
545 TCU_THROW(ResourceError, "wglMakeCurrent() failed");
548 if (core->getLibrary()->isWglExtensionSupported("WGL_EXT_swap_control"))
549 core->getLibrary()->getFunctions().swapIntervalEXT(0);
552 Context::~Context (void)
554 const Functions& wgl = m_core->getLibrary()->getFunctions();
556 wgl.makeCurrent(m_deviceCtx, NULL);
557 wgl.deleteContext(m_context);
560 FunctionPtr Context::getGLFunction (const char* name) const
562 FunctionPtr ptr = DE_NULL;
564 // Try first with wglGeProcAddress()
565 ptr = (FunctionPtr)m_core->getLibrary()->getFunctions().getProcAddress(name);
567 // Fall-back to dynlib
569 ptr = (FunctionPtr)m_core->getLibrary()->getGLLibrary().getFunction(name);
574 void Context::makeCurrent (void)
576 const Functions& wgl = m_core->getLibrary()->getFunctions();
577 if (!wgl.makeCurrent(m_deviceCtx, m_context))
578 TCU_THROW(ResourceError, "wglMakeCurrent() failed");
581 void Context::swapBuffers (void) const
583 const Functions& wgl = m_core->getLibrary()->getFunctions();
584 if (!wgl.swapLayerBuffers(m_deviceCtx, WGL_SWAP_MAIN_PLANE))
585 TCU_THROW(ResourceError, "wglSwapBuffers() failed");
588 bool isSupportedByTests (const PixelFormatInfo& info)
590 if (!info.supportOpenGL)
593 if (info.acceleration != wgl::PixelFormatInfo::ACCELERATION_FULL)
596 if (info.pixelType != wgl::PixelFormatInfo::PIXELTYPE_RGBA)
599 if ((info.surfaceTypes & wgl::PixelFormatInfo::SURFACE_WINDOW) == 0)
602 if (info.needPalette || info.needSystemPalette)
605 if (info.numOverlays != 0 || info.numUnderlays != 0)
614 int choosePixelFormat (const Core& wgl, HDC deviceCtx, const glu::RenderConfig& config)
616 std::vector<int> pixelFormats = wgl.getPixelFormats(deviceCtx);
618 for (std::vector<int>::const_iterator fmtIter = pixelFormats.begin(); fmtIter != pixelFormats.end(); ++fmtIter)
620 const PixelFormatInfo info = wgl.getPixelFormatInfo(deviceCtx, *fmtIter);
622 // Skip formats that are fundamentally not compatible with current tests
623 if (!isSupportedByTests(info))
626 if (config.redBits != glu::RenderConfig::DONT_CARE &&
627 config.redBits != info.redBits)
630 if (config.greenBits != glu::RenderConfig::DONT_CARE &&
631 config.greenBits != info.greenBits)
634 if (config.blueBits != glu::RenderConfig::DONT_CARE &&
635 config.blueBits != info.blueBits)
638 if (config.alphaBits != glu::RenderConfig::DONT_CARE &&
639 config.alphaBits != info.alphaBits)
642 if (config.depthBits != glu::RenderConfig::DONT_CARE &&
643 config.depthBits != info.depthBits)
646 if (config.stencilBits != glu::RenderConfig::DONT_CARE &&
647 config.stencilBits != info.stencilBits)
650 if (config.numSamples != glu::RenderConfig::DONT_CARE &&
651 config.numSamples != info.samples)
654 // Passed all tests - select this.
655 return info.pixelFormat;