1 #include "LDVExtensionsSetup.h"
2 #include <TCFoundation/mystring.h>
3 #include <TCFoundation/TCUserDefaults.h>
4 #include <TRE/TREShapeGroup.h>
5 #include <TRE/TREGLExtensions.h>
6 #include <LDLib/LDUserDefaultsKeys.h>
7
8 #if defined(_MSC_VER) && _MSC_VER >= 1400 && defined(_DEBUG)
9 #define new DEBUG_CLIENTBLOCK
10 #endif // _DEBUG
11
12 #if defined(_MSC_VER) && _MSC_VER >= 1400 && defined(_DEBUG)
13 #define new DEBUG_CLIENTBLOCK
14 #endif
15
16 // WGL_EXT_pixel_format
17 PFNWGLGETPIXELFORMATATTRIBIVEXTPROC
18 LDVExtensionsSetup::sm_wglGetPixelFormatAttribivARB = NULL;
19 PFNWGLGETPIXELFORMATATTRIBFVEXTPROC
20 LDVExtensionsSetup::sm_wglGetPixelFormatAttribfvARB = NULL;
21 PFNWGLCHOOSEPIXELFORMATEXTPROC
22 LDVExtensionsSetup::sm_wglChoosePixelFormatARB = NULL;
23 // WGL_ARB_extensions_string
24 PFNWGLGETEXTENSIONSSTRINGARBPROC
25 LDVExtensionsSetup::sm_wglGetExtensionsStringARB = NULL;
26 // WGL_ARB_pbuffer
27 PFNWGLCREATEPBUFFERARBPROC LDVExtensionsSetup::sm_wglCreatePbufferARB = NULL;
28 PFNWGLGETPBUFFERDCARBPROC LDVExtensionsSetup::sm_wglGetPbufferDCARB = NULL;
29 PFNWGLRELEASEPBUFFERDCARBPROC LDVExtensionsSetup::sm_wglReleasePbufferDCARB = NULL;
30 PFNWGLDESTROYPBUFFERARBPROC LDVExtensionsSetup::sm_wglDestroyPbufferARB = NULL;
31 PFNWGLQUERYPBUFFERARBPROC LDVExtensionsSetup::sm_wglQueryPbufferARB = NULL;
32 // WGL_NV_allocate_memory
33 PFNWGLALLOCATEMEMORYNVPROC LDVExtensionsSetup::sm_wglAllocateMemoryNV = NULL;
34 PFNWGLFREEMEMORYNVPROC LDVExtensionsSetup::sm_wglFreeMemoryNV = NULL;
35
36 StringSet LDVExtensionsSetup::sm_wglExtensions;
37 char *LDVExtensionsSetup::sm_wglExtensionsString = NULL;
38 bool LDVExtensionsSetup::sm_performedInitialSetup = false;
39 bool LDVExtensionsSetup::sm_stencilPresent = false;
40 bool LDVExtensionsSetup::sm_alphaPresent = false;
41 TCIntArray *LDVExtensionsSetup::sm_fsaaModes = NULL;
42 TCIntArrayArray *LDVExtensionsSetup::sm_pfIntValues = NULL;
43 LDVExtensionsSetup *LDVExtensionsSetup::sm_extensionsSetup = NULL;
44
45 LDVExtensionsSetup::LDVExtensionsSetupCleanup
46 LDVExtensionsSetup::sm_extensionsSetupCleanup;
47
48
49 static char *pfIntAttribNames[] =
50 {
51 "WGL_MAX_PBUFFER_WIDTH_ARB",
52 "WGL_DRAW_TO_WINDOW_ARB",
53 "WGL_DRAW_TO_BITMAP_ARB",
54 "WGL_ACCELERATION_ARB",
55 "WGL_NEED_PALETTE_ARB",
56 "WGL_NEED_SYSTEM_PALETTE_ARB",
57 "WGL_SWAP_LAYER_BUFFERS_ARB",
58 "WGL_SWAP_METHOD_ARB",
59 "WGL_NUMBER_OVERLAYS_ARB",
60 "WGL_NUMBER_UNDERLAYS_ARB",
61 "WGL_TRANSPARENT_ARB",
62 "WGL_TRANSPARENT_RED_VALUE_ARB",
63 "WGL_TRANSPARENT_GREEN_VALUE_ARB",
64 "WGL_TRANSPARENT_BLUE_VALUE_ARB",
65 "WGL_TRANSPARENT_ALPHA_VALUE_ARB",
66 "WGL_TRANSPARENT_INDEX_VALUE_ARB",
67 "WGL_SHARE_DEPTH_ARB",
68 "WGL_SHARE_STENCIL_ARB",
69 "WGL_SHARE_ACCUM_ARB",
70 "WGL_SUPPORT_GDI_ARB",
71 "WGL_SUPPORT_OPENGL_ARB",
72 "WGL_DOUBLE_BUFFER_ARB",
73 "WGL_STEREO_ARB",
74 "WGL_PIXEL_TYPE_ARB",
75 "WGL_COLOR_BITS_ARB",
76 "WGL_RED_BITS_ARB",
77 "WGL_RED_SHIFT_ARB",
78 "WGL_GREEN_BITS_ARB",
79 "WGL_GREEN_SHIFT_ARB",
80 "WGL_BLUE_BITS_ARB",
81 "WGL_BLUE_SHIFT_ARB",
82 "WGL_ALPHA_BITS_ARB",
83 "WGL_ALPHA_SHIFT_ARB",
84 "WGL_ACCUM_BITS_ARB",
85 "WGL_ACCUM_RED_BITS_ARB",
86 "WGL_ACCUM_GREEN_BITS_ARB",
87 "WGL_ACCUM_BLUE_BITS_ARB",
88 "WGL_ACCUM_ALPHA_BITS_ARB",
89 "WGL_DEPTH_BITS_ARB",
90 "WGL_STENCIL_BITS_ARB",
91 "WGL_AUX_BUFFERS_ARB",
92 "WGL_DRAW_TO_PBUFFER_ARB",
93 "WGL_SAMPLE_BUFFERS_EXT",
94 "WGL_SAMPLES_EXT",
95 };
96 static int pfIntAttribs[] =
97 {
98 WGL_MAX_PBUFFER_WIDTH_ARB,
99 WGL_DRAW_TO_WINDOW_ARB,
100 WGL_DRAW_TO_BITMAP_ARB,
101 WGL_ACCELERATION_ARB,
102 WGL_NEED_PALETTE_ARB,
103 WGL_NEED_SYSTEM_PALETTE_ARB,
104 WGL_SWAP_LAYER_BUFFERS_ARB,
105 WGL_SWAP_METHOD_ARB,
106 WGL_NUMBER_OVERLAYS_ARB,
107 WGL_NUMBER_UNDERLAYS_ARB,
108 WGL_TRANSPARENT_ARB,
109 WGL_TRANSPARENT_RED_VALUE_ARB,
110 WGL_TRANSPARENT_GREEN_VALUE_ARB,
111 WGL_TRANSPARENT_BLUE_VALUE_ARB,
112 WGL_TRANSPARENT_ALPHA_VALUE_ARB,
113 WGL_TRANSPARENT_INDEX_VALUE_ARB,
114 WGL_SHARE_DEPTH_ARB,
115 WGL_SHARE_STENCIL_ARB,
116 WGL_SHARE_ACCUM_ARB,
117 WGL_SUPPORT_GDI_ARB,
118 WGL_SUPPORT_OPENGL_ARB,
119 WGL_DOUBLE_BUFFER_ARB,
120 WGL_STEREO_ARB,
121 WGL_PIXEL_TYPE_ARB,
122 WGL_COLOR_BITS_ARB,
123 WGL_RED_BITS_ARB,
124 WGL_RED_SHIFT_ARB,
125 WGL_GREEN_BITS_ARB,
126 WGL_GREEN_SHIFT_ARB,
127 WGL_BLUE_BITS_ARB,
128 WGL_BLUE_SHIFT_ARB,
129 WGL_ALPHA_BITS_ARB,
130 WGL_ALPHA_SHIFT_ARB,
131 WGL_ACCUM_BITS_ARB,
132 WGL_ACCUM_RED_BITS_ARB,
133 WGL_ACCUM_GREEN_BITS_ARB,
134 WGL_ACCUM_BLUE_BITS_ARB,
135 WGL_ACCUM_ALPHA_BITS_ARB,
136 WGL_DEPTH_BITS_ARB,
137 WGL_STENCIL_BITS_ARB,
138 WGL_AUX_BUFFERS_ARB,
139 WGL_DRAW_TO_PBUFFER_ARB,
140 WGL_SAMPLE_BUFFERS_EXT,
141 WGL_SAMPLES_EXT,
142 };
143 static int pfIntAttribCount = COUNT_OF(pfIntAttribs);
144
~LDVExtensionsSetupCleanup(void)145 LDVExtensionsSetup::LDVExtensionsSetupCleanup::~LDVExtensionsSetupCleanup(void)
146 {
147 LDVExtensionsSetup::sm_wglExtensions.clear();
148 delete LDVExtensionsSetup::sm_wglExtensionsString;
149 LDVExtensionsSetup::sm_wglExtensionsString = NULL;
150 if (LDVExtensionsSetup::sm_fsaaModes)
151 {
152 LDVExtensionsSetup::sm_fsaaModes->release();
153 }
154 if (LDVExtensionsSetup::sm_extensionsSetup)
155 {
156 LDVExtensionsSetup::sm_extensionsSetup->closeWindow();
157 LDVExtensionsSetup::sm_extensionsSetup->release();
158 LDVExtensionsSetup::sm_extensionsSetup = NULL;
159 }
160 if (LDVExtensionsSetup::sm_pfIntValues)
161 {
162 LDVExtensionsSetup::sm_pfIntValues->release();
163 LDVExtensionsSetup::sm_pfIntValues = NULL;
164 }
165 }
166
167
LDVExtensionsSetup(HINSTANCE hInstance)168 LDVExtensionsSetup::LDVExtensionsSetup(HINSTANCE hInstance):
169 CUIOGLWindow(_UC(""), hInstance, 100, 100, 100, 100)
170 {
171 }
172
~LDVExtensionsSetup(void)173 LDVExtensionsSetup::~LDVExtensionsSetup(void)
174 {
175 }
176
initWindow(void)177 BOOL LDVExtensionsSetup::initWindow(void)
178 {
179 if (CUIOGLWindow::initWindow())
180 {
181 GLint intValue;
182
183 TREGLExtensions::setup();
184 if (!sm_wglExtensionsString)
185 {
186 sm_wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
187 wglGetProcAddress("wglGetExtensionsStringARB");
188
189 if (!sm_wglGetExtensionsStringARB)
190 {
191 sm_wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)
192 wglGetProcAddress("wglGetExtensionsStringEXT");
193 }
194 if (sm_wglGetExtensionsStringARB)
195 {
196 sm_wglExtensionsString = copyString(
197 sm_wglGetExtensionsStringARB(hdc));
198 TREGLExtensions::initExtensions(sm_wglExtensions,
199 sm_wglExtensionsString);
200 }
201 }
202 // Note that when we load the function pointers, don't want to pay
203 // attention to any ignore flags in the registry, so all the checks for
204 // extensions have the force flag set to true. Otherwise, if the
205 // program starts with the ignore flag set, and it later gets cleared,
206 // the function pointers won't be loaded.
207 if (checkForWGLExtension("WGL_ARB_pixel_format", true))
208 {
209 sm_wglGetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVEXTPROC)
210 wglGetProcAddress("wglGetPixelFormatAttribivARB");
211 sm_wglGetPixelFormatAttribfvARB = (PFNWGLGETPIXELFORMATATTRIBFVEXTPROC)
212 wglGetProcAddress("wglGetPixelFormatAttribfvARB");
213 sm_wglChoosePixelFormatARB = (PFNWGLCHOOSEPIXELFORMATEXTPROC)
214 wglGetProcAddress("wglChoosePixelFormatARB");
215 }
216 if (havePixelBufferExtension(true))
217 {
218 sm_wglCreatePbufferARB = (PFNWGLCREATEPBUFFERARBPROC)
219 wglGetProcAddress("wglCreatePbufferARB");
220 sm_wglGetPbufferDCARB = (PFNWGLGETPBUFFERDCARBPROC)
221 wglGetProcAddress("wglGetPbufferDCARB");
222 sm_wglReleasePbufferDCARB = (PFNWGLRELEASEPBUFFERDCARBPROC)
223 wglGetProcAddress("wglReleasePbufferDCARB");
224 sm_wglDestroyPbufferARB = (PFNWGLDESTROYPBUFFERARBPROC)
225 wglGetProcAddress("wglDestroyPbufferARB");
226 sm_wglQueryPbufferARB = (PFNWGLQUERYPBUFFERARBPROC)
227 wglGetProcAddress("wglQueryPbufferARB");
228 }
229 //if (TREGLExtensions::haveVARExtension(true))
230 //{
231 // sm_wglAllocateMemoryNV = (PFNWGLALLOCATEMEMORYNVPROC)
232 // wglGetProcAddress("wglAllocateMemoryNV");
233 // sm_wglFreeMemoryNV = (PFNWGLFREEMEMORYNVPROC)
234 // wglGetProcAddress("wglFreeMemoryNV");
235 //}
236 glGetIntegerv(GL_STENCIL_BITS, &intValue);
237 if (intValue)
238 {
239 sm_stencilPresent = true;
240 }
241 glGetIntegerv(GL_ALPHA_BITS, &intValue);
242 if (intValue)
243 {
244 sm_alphaPresent = true;
245 }
246 recordPixelFormats();
247 scanFSAAModes();
248
249 using namespace TREGLExtensionsNS;
250 // WGL_EXT_pixel_format
251 wglGetPixelFormatAttribivARB = sm_wglGetPixelFormatAttribivARB;
252 wglGetPixelFormatAttribfvARB = sm_wglGetPixelFormatAttribfvARB;
253 wglChoosePixelFormatARB = NULL;
254 // WGL_ARB_extensions_string
255 wglGetExtensionsStringARB = sm_wglGetExtensionsStringARB;
256 // WGL_ARB_pbuffer
257 wglCreatePbufferARB = sm_wglCreatePbufferARB;
258 wglGetPbufferDCARB = sm_wglGetPbufferDCARB;
259 wglReleasePbufferDCARB = sm_wglReleasePbufferDCARB;
260 wglDestroyPbufferARB = sm_wglDestroyPbufferARB;
261 wglQueryPbufferARB = sm_wglQueryPbufferARB;
262 // WGL_NV_allocate_memory
263 wglAllocateMemoryNV = sm_wglAllocateMemoryNV;
264 wglFreeMemoryNV = sm_wglFreeMemoryNV;
265 return TRUE;
266 }
267 return FALSE;
268 }
269
recordPixelFormats(void)270 void LDVExtensionsSetup::recordPixelFormats(void)
271 {
272 if (havePixelFormatExtension() && !sm_pfIntValues)
273 {
274 GLint intValues[] = {
275 WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
276 WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
277 WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
278 WGL_COLOR_BITS_ARB, 16,
279 WGL_DEPTH_BITS_ARB, 16,
280 0, 0
281 };
282 GLfloat floatValues[] = { 0.0f, 0.0f };
283 GLint indexes[1024];
284 GLuint count;
285
286 sm_pfIntValues = new TCIntArrayArray;
287 // Get a list of all acceptable pixel formats.
288 if (sm_wglChoosePixelFormatARB(hdc, intValues,
289 floatValues, COUNT_OF(indexes), indexes, &count)
290 && count)
291 {
292 GLuint i;
293 GLint *values = new GLint[pfIntAttribCount];
294
295 // Record info about all pixel formats.
296 for (i = 0; i < count; i++)
297 {
298 TCIntArray *valueArray = new TCIntArray;
299 int j;
300
301 memset(values, -1, pfIntAttribCount * sizeof(GLint));
302 sm_wglGetPixelFormatAttribivARB(hdc, indexes[i], 0,
303 pfIntAttribCount, pfIntAttribs, values);
304 for (j = 0; j < pfIntAttribCount; j++)
305 {
306 valueArray->addValue(values[j]);
307 }
308 valueArray->addValue(indexes[i]);
309 sm_pfIntValues->addObject(valueArray);
310 valueArray->release();
311 }
312 delete values;
313 }
314 }
315 }
316
scanFSAAModes(void)317 void LDVExtensionsSetup::scanFSAAModes(void)
318 {
319 if (sm_fsaaModes)
320 {
321 sm_fsaaModes->removeAll();
322 }
323 else
324 {
325 sm_fsaaModes = new TCIntArray;
326 }
327 if (haveMultisampleExtension())
328 {
329 GLint intValues[] = {
330 WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
331 WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
332 WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
333 WGL_COLOR_BITS_ARB, 16,
334 WGL_DEPTH_BITS_ARB, 16,
335 0, 0
336 };
337 GLfloat floatValues[] = { 0.0f, 0.0f };
338 GLint indexes[1024];
339 GLuint count;
340
341 // Get a list of all acceptable pixel formats.
342 if (sm_wglChoosePixelFormatARB(hdc, intValues,
343 floatValues, COUNT_OF(indexes), indexes, &count)
344 && count)
345 {
346 GLuint i;
347 GLint attributes[2] = { WGL_SAMPLE_BUFFERS_EXT, WGL_SAMPLES_EXT };
348 GLint values[2];
349
350 // Scan the list for multisample pixel formats.
351 for (i = 0; i < count; i++)
352 {
353 sm_wglGetPixelFormatAttribivARB(hdc, indexes[i], 0, 2, attributes,
354 values);
355 if (values[0] && values[1] > 1)
356 {
357 int value = values[1];
358
359 if (sm_fsaaModes->indexOfValue(value) == -1)
360 {
361 sm_fsaaModes->addValue(value);
362 }
363 }
364 }
365 }
366 sm_fsaaModes->sort();
367 }
368 }
369
haveMultisampleExtension(bool force)370 bool LDVExtensionsSetup::haveMultisampleExtension(bool force)
371 {
372 bool ignore = TCUserDefaults::longForKey(IGNORE_MULTISAMPLE_KEY, 0, false)
373 != 0;
374
375 return (!ignore || force) && checkForWGLExtension("WGL_ARB_multisample");
376 }
377
havePixelBufferExtension(bool force)378 bool LDVExtensionsSetup::havePixelBufferExtension(bool force)
379 {
380 bool ignore = TCUserDefaults::longForKey(IGNORE_PBUFFER_KEY, 0, false) != 0;
381
382 return (!ignore || force) && checkForWGLExtension("WGL_ARB_pbuffer", force);
383 }
384
385 //bool LDVExtensionsSetup::haveVARExtension(bool force)
386 //{
387 // return TREGLExtensions::haveVARExtension(force) &&
388 // checkForWGLExtension("WGL_NV_allocate_memory", force);
389 //}
390
havePixelFormatExtension(bool force)391 bool LDVExtensionsSetup::havePixelFormatExtension(bool force)
392 {
393 bool ignore = TCUserDefaults::longForKey(IGNORE_PIXEL_FORMAT_KEY, 0, false)
394 != 0;
395
396 return (!ignore || force) && checkForWGLExtension("WGL_ARB_pixel_format");
397 }
398
checkForWGLExtension(char * extension,bool force)399 bool LDVExtensionsSetup::checkForWGLExtension(char* extension, bool force)
400 {
401 return TREGLExtensions::checkForExtension(sm_wglExtensions, extension, force);
402 }
403
closeWindow(void)404 void LDVExtensionsSetup::closeWindow(void)
405 {
406 if (hWindow)
407 {
408 ShowWindow(hWindow, SW_HIDE);
409 }
410 CUIOGLWindow::closeWindow();
411 }
412
setup(HINSTANCE hInstance)413 void LDVExtensionsSetup::setup(HINSTANCE hInstance)
414 {
415 if (!sm_performedInitialSetup)
416 {
417 sm_extensionsSetup = new LDVExtensionsSetup(hInstance);
418 sm_extensionsSetup->initWindow();
419 sm_performedInitialSetup = true;
420 }
421 }
422
matchPixelFormat(int * intValues)423 int LDVExtensionsSetup::matchPixelFormat(int *intValues)
424 {
425 int count = sm_pfIntValues->getCount();
426 int i;
427
428 for (i = 0; i < count; i++)
429 {
430 int index = pixelFormatMatches(i, intValues);
431
432 if (index != -1)
433 {
434 return index;
435 }
436 }
437 return -1;
438 }
439
pixelFormatMatches(int index,int * intValues)440 int LDVExtensionsSetup::pixelFormatMatches(int index, int *intValues)
441 {
442 if (sm_pfIntValues)
443 {
444 int i, j;
445 TCIntArray *pfValues = (*sm_pfIntValues)[index];
446
447 for (i = 0; intValues[i]; i += 2)
448 {
449 int attrib = intValues[i];
450 int value = intValues[i + 1];
451
452 if (value)
453 {
454 for (j = 0; j < pfIntAttribCount; j++)
455 {
456 if (pfIntAttribs[j] == attrib)
457 {
458 if ((*pfValues)[j] < value)
459 {
460 return -1;
461 }
462 break;
463 }
464 }
465 }
466 }
467 return (*pfValues)[pfIntAttribCount];
468 }
469 else
470 {
471 return -1;
472 }
473 }
474
choosePixelFormat(HDC hdc,GLint customValues[])475 int LDVExtensionsSetup::choosePixelFormat(HDC hdc, GLint customValues[])
476 {
477 GLint commonValues[] = {
478 WGL_SUPPORT_OPENGL_ARB, GL_TRUE,
479 WGL_ACCELERATION_ARB, WGL_FULL_ACCELERATION_ARB,
480 WGL_PIXEL_TYPE_ARB, WGL_TYPE_RGBA_ARB,
481 WGL_COLOR_BITS_ARB, 16,
482 WGL_DEPTH_BITS_ARB, 16,
483 0, 0
484 };
485 GLint *intValues;
486 GLfloat floatValues[] = { 0.0f, 0.0f };
487 GLint indexes[100];
488 GLuint count;
489 int customSize;
490 int retValue = -1;
491 int i;
492
493 for (count = 0; customValues[count]; count++)
494 {
495 // Do nothing; we just want to know how many values there are.
496 }
497 customSize = count * sizeof(GLint);
498 intValues = new GLint[customSize + sizeof(commonValues)];
499 memcpy(intValues, customValues, customSize);
500 memcpy(intValues + count, commonValues, sizeof(commonValues));
501 for (i = 0; intValues[i]; i += 2)
502 {
503 debugPrintf("%d %d\n", intValues[i], intValues[i + 1]);
504 }
505 debugPrintf("%d %d\n", intValues[i], intValues[i + 1]);
506 for (i = 0; floatValues[i]; i += 2)
507 {
508 debugPrintf("%g %g\n", floatValues[i], floatValues[i + 1]);
509 }
510 debugPrintf("%g %g\n", floatValues[i], floatValues[i + 1]);
511 if (sm_wglChoosePixelFormatARB(hdc, intValues,
512 floatValues, 100, indexes, &count))
513 {
514 if (count)
515 {
516 printPixelFormats(indexes, count);
517 printPixelFormat(hdc, indexes[0]);
518 retValue = indexes[0];
519 }
520 else
521 {
522 // There seems to be a bug in my ATI drivers that causes
523 // sm_wglChoosePixelFormatARB to stop working, so use my own matching
524 // code if the standard matching code fails.
525 retValue = matchPixelFormat(intValues);
526 debugPrintf("matchPixelFormat returned: %d\n", retValue);
527 printPixelFormat(hdc, indexes[0]);
528 }
529 }
530 delete intValues;
531 return retValue;
532 }
533
printPixelFormats(int * indexes,GLuint count)534 void LDVExtensionsSetup::printPixelFormats(int *indexes, GLuint count)
535 {
536 debugPrintf("Got %d pixel formats.\n", count);
537 for (unsigned int i = 0; i < count; i++)
538 {
539 debugPrintf("%5d", indexes[i]);
540 }
541 debugPrintf("\n");
542 }
543
printPixelFormat(HDC hdc,int index)544 void LDVExtensionsSetup::printPixelFormat(HDC hdc, int index)
545 {
546 int i;
547 int values[1024];
548
549 memset(values, -1, sizeof(values));
550 sm_wglGetPixelFormatAttribivARB(hdc, index, 0, pfIntAttribCount, pfIntAttribs,
551 values);
552 for (i = 0; i < pfIntAttribCount; i++)
553 {
554 debugPrintf("%31s: 0x%08X %d\n", pfIntAttribNames[i], values[i],
555 values[i]);
556 }
557 }
558