1/*-------------------------------------------------------------------------
2 * drawElements Quality Program Tester Core
3 * ----------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
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
10 *
11 *      http://www.apache.org/licenses/LICENSE-2.0
12 *
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.
18 *
19 *//*!
20 * \file
21 * \brief WGL Utilities.
22 *//*--------------------------------------------------------------------*/
23
24#include "tcuWGL.hpp"
25#include "tcuWin32Window.hpp"
26#include "deDynamicLibrary.hpp"
27#include "deMemory.h"
28#include "deStringUtil.hpp"
29#include "tcuFormatUtil.hpp"
30#include "gluRenderConfig.hpp"
31
32#include <WinGDI.h>
33
34// WGL_ARB_pixel_format
35#define WGL_NUMBER_PIXEL_FORMATS_ARB				0x2000
36#define WGL_DRAW_TO_WINDOW_ARB						0x2001
37#define WGL_DRAW_TO_BITMAP_ARB						0x2002
38#define WGL_ACCELERATION_ARB						0x2003
39#define WGL_NEED_PALETTE_ARB						0x2004
40#define WGL_NEED_SYSTEM_PALETTE_ARB					0x2005
41#define WGL_SWAP_LAYER_BUFFERS_ARB					0x2006
42#define WGL_SWAP_METHOD_ARB							0x2007
43#define WGL_NUMBER_OVERLAYS_ARB						0x2008
44#define WGL_NUMBER_UNDERLAYS_ARB					0x2009
45#define WGL_TRANSPARENT_ARB							0x200A
46#define WGL_TRANSPARENT_RED_VALUE_ARB				0x2037
47#define WGL_TRANSPARENT_GREEN_VALUE_ARB				0x2038
48#define WGL_TRANSPARENT_BLUE_VALUE_ARB				0x2039
49#define WGL_TRANSPARENT_ALPHA_VALUE_ARB				0x203A
50#define WGL_TRANSPARENT_INDEX_VALUE_ARB				0x203B
51#define WGL_SHARE_DEPTH_ARB							0x200C
52#define WGL_SHARE_STENCIL_ARB						0x200D
53#define WGL_SHARE_ACCUM_ARB							0x200E
54#define WGL_SUPPORT_GDI_ARB							0x200F
55#define WGL_SUPPORT_OPENGL_ARB						0x2010
56#define WGL_DOUBLE_BUFFER_ARB						0x2011
57#define WGL_STEREO_ARB								0x2012
58#define WGL_PIXEL_TYPE_ARB							0x2013
59#define WGL_COLOR_BITS_ARB							0x2014
60#define WGL_RED_BITS_ARB							0x2015
61#define WGL_RED_SHIFT_ARB							0x2016
62#define WGL_GREEN_BITS_ARB							0x2017
63#define WGL_GREEN_SHIFT_ARB							0x2018
64#define WGL_BLUE_BITS_ARB							0x2019
65#define WGL_BLUE_SHIFT_ARB							0x201A
66#define WGL_ALPHA_BITS_ARB							0x201B
67#define WGL_ALPHA_SHIFT_ARB							0x201C
68#define WGL_ACCUM_BITS_ARB							0x201D
69#define WGL_ACCUM_RED_BITS_ARB						0x201E
70#define WGL_ACCUM_GREEN_BITS_ARB					0x201F
71#define WGL_ACCUM_BLUE_BITS_ARB						0x2020
72#define WGL_ACCUM_ALPHA_BITS_ARB					0x2021
73#define WGL_DEPTH_BITS_ARB							0x2022
74#define WGL_STENCIL_BITS_ARB						0x2023
75#define WGL_AUX_BUFFERS_ARB							0x2024
76
77#define WGL_NO_ACCELERATION_ARB						0x2025
78#define WGL_GENERIC_ACCELERATION_ARB				0x2026
79#define WGL_FULL_ACCELERATION_ARB					0x2027
80
81#define WGL_TYPE_RGBA_ARB							0x202B
82#define WGL_TYPE_COLORINDEX_ARB						0x202C
83
84// WGL_ARB_color_buffer_float
85#define WGL_TYPE_RGBA_FLOAT_ARB						0x21A0
86
87// WGL_EXT_pixel_type_packed_float
88#define WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT			0x20A8
89
90// WGL_ARB_multisample
91#define WGL_SAMPLE_BUFFERS_ARB						0x2041
92#define WGL_SAMPLES_ARB								0x2042
93
94// WGL_ARB_create_context
95#define WGL_CONTEXT_MAJOR_VERSION_ARB				0x2091
96#define WGL_CONTEXT_MINOR_VERSION_ARB				0x2092
97#define WGL_CONTEXT_LAYER_PLANE_ARB					0x2093
98#define WGL_CONTEXT_FLAGS_ARB						0x2094
99#define WGL_CONTEXT_PROFILE_MASK_ARB				0x9126
100#define WGL_CONTEXT_DEBUG_BIT_ARB					0x0001
101#define WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB		0x0002
102#define WGL_CONTEXT_CORE_PROFILE_BIT_ARB			0x00000001
103#define WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB	0x00000002
104#define WGL_CONTEXT_ES_PROFILE_BIT_EXT				0x00000004
105
106// WGL_ARB_create_context_robustness
107#define WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB			0x0004
108#define WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB	0x8256
109#define WGL_NO_RESET_NOTIFICATION_ARB				0x8261
110#define WGL_LOSE_CONTEXT_ON_RESET_ARB				0x8252
111
112DE_BEGIN_EXTERN_C
113
114// WGL core
115typedef HGLRC	(WINAPI* wglCreateContextFunc)				(HDC hdc);
116typedef BOOL	(WINAPI* wglDeleteContextFunc)				(HGLRC hglrc);
117typedef BOOL	(WINAPI* wglMakeCurrentFunc)				(HDC hdc, HGLRC hglrc);
118typedef PROC	(WINAPI* wglGetProcAddressFunc)				(LPCSTR lpszProc);
119typedef BOOL	(WINAPI* wglSwapLayerBuffersFunc)			(HDC dhc, UINT fuPlanes);
120
121// WGL_ARB_pixel_format
122typedef BOOL	(WINAPI* wglGetPixelFormatAttribivARBFunc)	(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues);
123typedef BOOL	(WINAPI* wglGetPixelFormatAttribfvARBFunc)	(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues);
124typedef BOOL	(WINAPI* wglChoosePixelFormatARBFunc)		(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats);
125
126// WGL_ARB_create_context
127typedef HGLRC	(WINAPI* wglCreateContextAttribsARBFunc)	(HDC hdc, HGLRC hshareContext, const int* attribList);
128
129DE_END_EXTERN_C
130
131namespace tcu
132{
133namespace wgl
134{
135
136// Functions
137
138struct Functions
139{
140	// Core
141	wglCreateContextFunc				createContext;
142	wglDeleteContextFunc				deleteContext;
143	wglMakeCurrentFunc					makeCurrent;
144	wglGetProcAddressFunc				getProcAddress;
145	wglSwapLayerBuffersFunc				swapLayerBuffers;
146
147	// WGL_ARB_pixel_format
148	wglGetPixelFormatAttribivARBFunc	getPixelFormatAttribivARB;
149	wglGetPixelFormatAttribfvARBFunc	getPixelFormatAttribfvARB;
150	wglChoosePixelFormatARBFunc			choosePixelFormatARB;
151
152	// WGL_ARB_create_context
153	wglCreateContextAttribsARBFunc		createContextAttribsARB;
154
155	Functions (void)
156		: createContext				(DE_NULL)
157		, deleteContext				(DE_NULL)
158		, makeCurrent				(DE_NULL)
159		, getProcAddress			(DE_NULL)
160		, swapLayerBuffers			(DE_NULL)
161		, getPixelFormatAttribivARB	(DE_NULL)
162		, getPixelFormatAttribfvARB	(DE_NULL)
163		, choosePixelFormatARB		(DE_NULL)
164		, createContextAttribsARB	(DE_NULL)
165	{
166	}
167};
168
169// Library
170
171class Library
172{
173public:
174								Library			(HINSTANCE instance);
175								~Library		(void);
176
177	const Functions&			getFunctions	(void) const	{ return m_functions;	}
178	const de::DynamicLibrary&	getGLLibrary	(void) const	{ return m_library;		}
179
180private:
181	de::DynamicLibrary			m_library;
182	Functions					m_functions;
183};
184
185Library::Library (HINSTANCE instance)
186	: m_library("opengl32.dll")
187{
188	// Temporary 1x1 window for creating context
189	win32::Window tmpWindow(instance, 1, 1);
190
191	// Load WGL core.
192	m_functions.createContext		= (wglCreateContextFunc)		m_library.getFunction("wglCreateContext");
193	m_functions.deleteContext		= (wglDeleteContextFunc)		m_library.getFunction("wglDeleteContext");
194	m_functions.getProcAddress		= (wglGetProcAddressFunc)		m_library.getFunction("wglGetProcAddress");
195	m_functions.makeCurrent			= (wglMakeCurrentFunc)			m_library.getFunction("wglMakeCurrent");
196	m_functions.swapLayerBuffers	= (wglSwapLayerBuffersFunc)		m_library.getFunction("wglSwapLayerBuffers");
197
198	if (!m_functions.createContext		||
199		!m_functions.deleteContext		||
200		!m_functions.getProcAddress		||
201		!m_functions.makeCurrent		||
202		!m_functions.swapLayerBuffers)
203		throw ResourceError("Failed to load core WGL functions");
204
205	{
206		PIXELFORMATDESCRIPTOR pixelFormatDesc;
207		deMemset(&pixelFormatDesc, 0, sizeof(pixelFormatDesc));
208
209		pixelFormatDesc.nSize			= sizeof(pixelFormatDesc);
210		pixelFormatDesc.nVersion		= 1;
211		pixelFormatDesc.dwFlags			= PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
212		pixelFormatDesc.iPixelType		= PFD_TYPE_RGBA;
213		pixelFormatDesc.iLayerType		= PFD_MAIN_PLANE;
214
215		int pixelFormat = ChoosePixelFormat(tmpWindow.getDeviceContext(), &pixelFormatDesc);
216		if (!SetPixelFormat(tmpWindow.getDeviceContext(), pixelFormat, &pixelFormatDesc))
217			throw ResourceError("Failed to set pixel format for temporary context creation");
218	}
219
220	// Create temporary context for loading extension functions.
221	HGLRC tmpCtx = m_functions.createContext(tmpWindow.getDeviceContext());
222	if (!tmpCtx || !m_functions.makeCurrent(tmpWindow.getDeviceContext(), tmpCtx))
223	{
224		if (tmpCtx)
225			m_functions.deleteContext(tmpCtx);
226		throw ResourceError("Failed to create temporary WGL context");
227	}
228
229	// WGL_ARB_pixel_format
230	m_functions.getPixelFormatAttribivARB	= (wglGetPixelFormatAttribivARBFunc)m_functions.getProcAddress("wglGetPixelFormatAttribivARB");
231	m_functions.getPixelFormatAttribfvARB	= (wglGetPixelFormatAttribfvARBFunc)m_functions.getProcAddress("wglGetPixelFormatAttribfvARB");
232	m_functions.choosePixelFormatARB		= (wglChoosePixelFormatARBFunc)m_functions.getProcAddress("wglChoosePixelFormatARB");
233
234	// WGL_ARB_create_context
235	m_functions.createContextAttribsARB		= (wglCreateContextAttribsARBFunc)m_functions.getProcAddress("wglCreateContextAttribsARB");
236
237	m_functions.makeCurrent(tmpWindow.getDeviceContext(), NULL);
238	m_functions.deleteContext(tmpCtx);
239
240	if (!m_functions.getPixelFormatAttribivARB	||
241		!m_functions.getPixelFormatAttribfvARB	||
242		!m_functions.choosePixelFormatARB		||
243		!m_functions.createContextAttribsARB)
244		throw ResourceError("Failed to load WGL extension functions");
245}
246
247Library::~Library (void)
248{
249}
250
251// Core
252
253Core::Core (HINSTANCE instance)
254	: m_library(new Library(instance))
255{
256}
257
258Core::~Core (void)
259{
260	delete m_library;
261}
262
263std::vector<int> Core::getPixelFormats (HDC deviceCtx) const
264{
265	const Functions& wgl = m_library->getFunctions();
266
267	int attribs[] = { WGL_NUMBER_PIXEL_FORMATS_ARB };
268	int values[DE_LENGTH_OF_ARRAY(attribs)];
269
270	if (!wgl.getPixelFormatAttribivARB(deviceCtx, 0, 0, DE_LENGTH_OF_ARRAY(attribs), &attribs[0], &values[0]))
271		throw ResourceError("Failed to query number of WGL pixel formats");
272
273	// \todo [2013-04-14 pyry] Do we need to filter values at all?
274	std::vector<int> pixelFormats(values[0]);
275	for (int i = 0; i < values[0]; i++)
276		pixelFormats[i] = i+1;
277
278	return pixelFormats;
279}
280
281static PixelFormatInfo::Acceleration translateAcceleration (int accel)
282{
283	switch (accel)
284	{
285		case WGL_NO_ACCELERATION_ARB:		return PixelFormatInfo::ACCELERATION_NONE;
286		case WGL_GENERIC_ACCELERATION_ARB:	return PixelFormatInfo::ACCELERATION_GENERIC;
287		case WGL_FULL_ACCELERATION_ARB:		return PixelFormatInfo::ACCELERATION_FULL;
288		default:							return PixelFormatInfo::ACCELERATION_UNKNOWN;
289	}
290}
291
292static PixelFormatInfo::PixelType translatePixelType (int type)
293{
294	switch (type)
295	{
296		case WGL_TYPE_RGBA_ARB:					return PixelFormatInfo::PIXELTYPE_RGBA;
297		case WGL_TYPE_RGBA_FLOAT_ARB:			return PixelFormatInfo::PIXELTYPE_RGBA_FLOAT;
298		case WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT:	return PixelFormatInfo::PIXELTYPE_RGBA_UNSIGNED_FLOAT;
299		case WGL_TYPE_COLORINDEX_ARB:			return PixelFormatInfo::PIXELTYPE_COLOR_INDEX;
300		default:								return PixelFormatInfo::PIXELTYPE_UNKNOWN;
301	}
302}
303
304PixelFormatInfo Core::getPixelFormatInfo (HDC deviceCtx, int pixelFormat) const
305{
306	const Functions& wgl = m_library->getFunctions();
307
308	int attribs	[14];
309	int values	[DE_LENGTH_OF_ARRAY(attribs)];
310	attribs[0]	= WGL_DRAW_TO_WINDOW_ARB;
311	attribs[1]	= WGL_DRAW_TO_BITMAP_ARB;
312	attribs[2]	= WGL_ACCELERATION_ARB;
313	attribs[3]	= WGL_SUPPORT_OPENGL_ARB;
314	attribs[4]	= WGL_DOUBLE_BUFFER_ARB;
315	attribs[5]	= WGL_PIXEL_TYPE_ARB;
316	attribs[6]	= WGL_RED_BITS_ARB;
317	attribs[7]	= WGL_GREEN_BITS_ARB;
318	attribs[8]	= WGL_BLUE_BITS_ARB;
319	attribs[9]	= WGL_ALPHA_BITS_ARB;
320	attribs[10]	= WGL_DEPTH_BITS_ARB;
321	attribs[11]	= WGL_STENCIL_BITS_ARB;
322	attribs[12]	= WGL_SAMPLE_BUFFERS_ARB;
323	attribs[13]	= WGL_SAMPLES_ARB;
324
325	deMemset(&values[0], 0, sizeof(values));
326	if (!wgl.getPixelFormatAttribivARB(deviceCtx, pixelFormat, 0, DE_LENGTH_OF_ARRAY(attribs), &attribs[0], &values[0]))
327		throw ResourceError("Pixel format query failed");
328
329	// Translate values.
330	PixelFormatInfo info;
331
332	info.pixelFormat	= pixelFormat;
333	info.surfaceTypes	|= (values[0] ? PixelFormatInfo::SURFACE_WINDOW : 0);
334	info.surfaceTypes	|= (values[1] ? PixelFormatInfo::SURFACE_PIXMAP : 0);
335	info.acceleration	= translateAcceleration(values[2]);
336	info.supportOpenGL	= values[3] != 0;
337	info.doubleBuffer	= values[4] != 0;
338	info.pixelType		= translatePixelType(values[5]);
339	info.redBits		= values[6];
340	info.greenBits		= values[7];
341	info.blueBits		= values[8];
342	info.alphaBits		= values[9];
343	info.depthBits		= values[10];
344	info.stencilBits	= values[11];
345	info.sampleBuffers	= values[12];
346	info.samples		= values[13];
347
348	return info;
349}
350
351// Context
352
353Context::Context (const Core* core, HDC deviceCtx, glu::ContextType ctxType, int pixelFormat)
354	: m_core		(core)
355	, m_deviceCtx	(deviceCtx)
356	, m_context		(0)
357{
358	const Functions& wgl = core->getLibrary()->getFunctions();
359
360	// Map context type & flags.
361	int	profileBit	= 0;
362	int	flags		= 0;
363
364	switch (ctxType.getProfile())
365	{
366		case glu::PROFILE_CORE:
367			profileBit = WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
368			break;
369
370		case glu::PROFILE_ES:
371			profileBit = WGL_CONTEXT_ES_PROFILE_BIT_EXT;
372			break;
373
374		case glu::PROFILE_COMPATIBILITY:
375			profileBit = WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
376			break;
377
378		default:
379			throw NotSupportedError("Unsupported context type for WGL");
380	}
381
382	if ((ctxType.getFlags() & glu::CONTEXT_FORWARD_COMPATIBLE) != 0)
383		flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
384
385	if ((ctxType.getFlags() & glu::CONTEXT_DEBUG) != 0)
386		flags |= WGL_CONTEXT_DEBUG_BIT_ARB;
387
388	if ((ctxType.getFlags() & glu::CONTEXT_ROBUST) != 0)
389		flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB;
390
391	const int attribList[] =
392	{
393		WGL_CONTEXT_MAJOR_VERSION_ARB,	ctxType.getMajorVersion(),
394		WGL_CONTEXT_MINOR_VERSION_ARB,	ctxType.getMinorVersion(),
395		WGL_CONTEXT_PROFILE_MASK_ARB,	profileBit,
396		WGL_CONTEXT_FLAGS_ARB,			flags,
397		0
398	};
399
400	// Set pixel format
401	{
402		PIXELFORMATDESCRIPTOR pixelFormatDesc;
403		deMemset(&pixelFormatDesc, 0, sizeof(pixelFormatDesc));
404
405		if (!DescribePixelFormat(deviceCtx, pixelFormat, sizeof(pixelFormatDesc), &pixelFormatDesc))
406			throw ResourceError("DescribePixelFormat() failed");
407
408		if (!SetPixelFormat(deviceCtx, pixelFormat, &pixelFormatDesc))
409			throw ResourceError("Failed to set pixel format");
410	}
411
412	// Create context
413	m_context = wgl.createContextAttribsARB(deviceCtx, NULL, attribList);
414
415	if (!m_context)
416		throw ResourceError("Failed to create WGL context");
417
418	if (!wgl.makeCurrent(deviceCtx, m_context))
419	{
420		wgl.deleteContext(m_context);
421		throw ResourceError("wglMakeCurrent() failed");
422	}
423}
424
425Context::~Context (void)
426{
427	const Functions& wgl = m_core->getLibrary()->getFunctions();
428
429	wgl.makeCurrent(m_deviceCtx, NULL);
430	wgl.deleteContext(m_context);
431}
432
433FunctionPtr Context::getGLFunction (const char* name) const
434{
435	FunctionPtr ptr = DE_NULL;
436
437	// Try first with wglGeProcAddress()
438	ptr = (FunctionPtr)m_core->getLibrary()->getFunctions().getProcAddress(name);
439
440	// Fall-back to dynlib
441	if (!ptr)
442		ptr = (FunctionPtr)m_core->getLibrary()->getGLLibrary().getFunction(name);
443
444	return ptr;
445}
446
447void Context::swapBuffers (void) const
448{
449	const Functions& wgl = m_core->getLibrary()->getFunctions();
450	if (!wgl.swapLayerBuffers(m_deviceCtx, WGL_SWAP_MAIN_PLANE))
451		throw ResourceError("wglSwapBuffers() failed");
452}
453
454int choosePixelFormat (const Core& wgl, HDC deviceCtx, const glu::RenderConfig& config)
455{
456	std::vector<int> pixelFormats = wgl.getPixelFormats(deviceCtx);
457
458	for (std::vector<int>::const_iterator fmtIter = pixelFormats.begin(); fmtIter != pixelFormats.end(); ++fmtIter)
459	{
460		PixelFormatInfo info = wgl.getPixelFormatInfo(deviceCtx, *fmtIter);
461
462		// Base rules: Must be OpenGL-compatible, RGBA, double-buffered, and window-renderable
463		if (!info.supportOpenGL											||
464			!(info.pixelType == wgl::PixelFormatInfo::PIXELTYPE_RGBA)	||
465			!info.doubleBuffer											||
466			!(info.surfaceTypes & wgl::PixelFormatInfo::SURFACE_WINDOW))
467			continue;
468
469		if (config.redBits != glu::RenderConfig::DONT_CARE &&
470			config.redBits != info.redBits)
471			continue;
472
473		if (config.greenBits != glu::RenderConfig::DONT_CARE &&
474			config.greenBits != info.greenBits)
475			continue;
476
477		if (config.blueBits != glu::RenderConfig::DONT_CARE &&
478			config.blueBits != info.blueBits)
479			continue;
480
481		if (config.alphaBits != glu::RenderConfig::DONT_CARE &&
482			config.alphaBits != info.alphaBits)
483			continue;
484
485		if (config.depthBits != glu::RenderConfig::DONT_CARE &&
486			config.depthBits != info.depthBits)
487			continue;
488
489		if (config.stencilBits != glu::RenderConfig::DONT_CARE &&
490			config.stencilBits != info.stencilBits)
491			continue;
492
493		if (config.numSamples != glu::RenderConfig::DONT_CARE &&
494			config.numSamples != info.samples)
495			continue;
496
497		// Passed all tests - select this.
498		return info.pixelFormat;
499	}
500
501	return -1;
502}
503
504} // wgl
505} // tcu
506