1 /************************************************************************** 2 * 3 * Copyright 2008 VMware, Inc. 4 * All Rights Reserved. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the 8 * "Software"), to deal in the Software without restriction, including 9 * without limitation the rights to use, copy, modify, merge, publish, 10 * distribute, sub license, and/or sell copies of the Software, and to 11 * permit persons to whom the Software is furnished to do so, subject to 12 * the following conditions: 13 * 14 * The above copyright notice and this permission notice (including the 15 * next paragraph) shall be included in all copies or substantial portions 16 * of the Software. 17 * 18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 19 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 20 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. 21 * IN NO EVENT SHALL VMWARE AND/OR ITS SUPPLIERS BE LIABLE FOR 22 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 23 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 24 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 25 * 26 **************************************************************************/ 27 28 /** 29 * @file 30 * 31 * WGL_ARB_pixel_format extension implementation. 32 * 33 * @sa http://www.opengl.org/registry/specs/ARB/wgl_pixel_format.txt 34 */ 35 36 37 #include <windows.h> 38 39 #define WGL_WGLEXT_PROTOTYPES 40 41 #include <GL/gl.h> 42 #include <GL/wglext.h> 43 44 #include "pipe/p_compiler.h" 45 #include "util/u_format.h" 46 #include "util/u_memory.h" 47 #include "stw_device.h" 48 #include "stw_pixelformat.h" 49 50 51 static boolean 52 stw_query_attrib( 53 int iPixelFormat, 54 int iLayerPlane, 55 int attrib, 56 int *pvalue ) 57 { 58 uint count; 59 const struct stw_pixelformat_info *pfi; 60 61 count = stw_pixelformat_get_extended_count(); 62 63 if (attrib == WGL_NUMBER_PIXEL_FORMATS_ARB) { 64 *pvalue = (int) count; 65 return TRUE; 66 } 67 68 pfi = stw_pixelformat_get_info( iPixelFormat ); 69 if (!pfi) { 70 return FALSE; 71 } 72 73 switch (attrib) { 74 case WGL_DRAW_TO_WINDOW_ARB: 75 *pvalue = pfi->pfd.dwFlags & PFD_DRAW_TO_WINDOW ? TRUE : FALSE; 76 return TRUE; 77 78 case WGL_DRAW_TO_BITMAP_ARB: 79 *pvalue = pfi->pfd.dwFlags & PFD_DRAW_TO_BITMAP ? TRUE : FALSE; 80 return TRUE; 81 82 case WGL_NEED_PALETTE_ARB: 83 *pvalue = pfi->pfd.dwFlags & PFD_NEED_PALETTE ? TRUE : FALSE; 84 return TRUE; 85 86 case WGL_NEED_SYSTEM_PALETTE_ARB: 87 *pvalue = pfi->pfd.dwFlags & PFD_NEED_SYSTEM_PALETTE ? TRUE : FALSE; 88 return TRUE; 89 90 case WGL_SWAP_METHOD_ARB: 91 if (pfi->pfd.dwFlags & PFD_SWAP_COPY) 92 *pvalue = WGL_SWAP_COPY_ARB; 93 else if (pfi->pfd.dwFlags & PFD_SWAP_EXCHANGE) 94 *pvalue = WGL_SWAP_EXCHANGE_EXT; 95 else 96 *pvalue = WGL_SWAP_UNDEFINED_ARB; 97 return TRUE; 98 99 case WGL_SWAP_LAYER_BUFFERS_ARB: 100 *pvalue = FALSE; 101 return TRUE; 102 103 case WGL_NUMBER_OVERLAYS_ARB: 104 *pvalue = 0; 105 return TRUE; 106 107 case WGL_NUMBER_UNDERLAYS_ARB: 108 *pvalue = 0; 109 return TRUE; 110 111 case WGL_BIND_TO_TEXTURE_RGB_ARB: 112 /* WGL_ARB_render_texture */ 113 *pvalue = pfi->bindToTextureRGB; 114 return TRUE; 115 116 case WGL_BIND_TO_TEXTURE_RGBA_ARB: 117 /* WGL_ARB_render_texture */ 118 *pvalue = pfi->bindToTextureRGBA; 119 return TRUE; 120 } 121 122 if (iLayerPlane != 0) 123 return FALSE; 124 125 switch (attrib) { 126 case WGL_ACCELERATION_ARB: 127 *pvalue = WGL_FULL_ACCELERATION_ARB; 128 break; 129 130 case WGL_TRANSPARENT_ARB: 131 *pvalue = FALSE; 132 break; 133 134 case WGL_TRANSPARENT_RED_VALUE_ARB: 135 case WGL_TRANSPARENT_GREEN_VALUE_ARB: 136 case WGL_TRANSPARENT_BLUE_VALUE_ARB: 137 case WGL_TRANSPARENT_ALPHA_VALUE_ARB: 138 case WGL_TRANSPARENT_INDEX_VALUE_ARB: 139 break; 140 141 case WGL_SHARE_DEPTH_ARB: 142 case WGL_SHARE_STENCIL_ARB: 143 case WGL_SHARE_ACCUM_ARB: 144 *pvalue = TRUE; 145 break; 146 147 case WGL_SUPPORT_GDI_ARB: 148 *pvalue = pfi->pfd.dwFlags & PFD_SUPPORT_GDI ? TRUE : FALSE; 149 break; 150 151 case WGL_SUPPORT_OPENGL_ARB: 152 *pvalue = pfi->pfd.dwFlags & PFD_SUPPORT_OPENGL ? TRUE : FALSE; 153 break; 154 155 case WGL_DOUBLE_BUFFER_ARB: 156 *pvalue = pfi->pfd.dwFlags & PFD_DOUBLEBUFFER ? TRUE : FALSE; 157 break; 158 159 case WGL_STEREO_ARB: 160 *pvalue = pfi->pfd.dwFlags & PFD_STEREO ? TRUE : FALSE; 161 break; 162 163 case WGL_PIXEL_TYPE_ARB: 164 switch (pfi->pfd.iPixelType) { 165 case PFD_TYPE_RGBA: 166 if (util_format_is_float(pfi->stvis.color_format)) { 167 *pvalue = WGL_TYPE_RGBA_FLOAT_ARB; 168 } 169 else { 170 *pvalue = WGL_TYPE_RGBA_ARB; 171 } 172 break; 173 case PFD_TYPE_COLORINDEX: 174 *pvalue = WGL_TYPE_COLORINDEX_ARB; 175 break; 176 default: 177 return FALSE; 178 } 179 break; 180 181 case WGL_COLOR_BITS_ARB: 182 *pvalue = pfi->pfd.cColorBits; 183 break; 184 185 case WGL_RED_BITS_ARB: 186 *pvalue = pfi->pfd.cRedBits; 187 break; 188 189 case WGL_RED_SHIFT_ARB: 190 *pvalue = pfi->pfd.cRedShift; 191 break; 192 193 case WGL_GREEN_BITS_ARB: 194 *pvalue = pfi->pfd.cGreenBits; 195 break; 196 197 case WGL_GREEN_SHIFT_ARB: 198 *pvalue = pfi->pfd.cGreenShift; 199 break; 200 201 case WGL_BLUE_BITS_ARB: 202 *pvalue = pfi->pfd.cBlueBits; 203 break; 204 205 case WGL_BLUE_SHIFT_ARB: 206 *pvalue = pfi->pfd.cBlueShift; 207 break; 208 209 case WGL_ALPHA_BITS_ARB: 210 *pvalue = pfi->pfd.cAlphaBits; 211 break; 212 213 case WGL_ALPHA_SHIFT_ARB: 214 *pvalue = pfi->pfd.cAlphaShift; 215 break; 216 217 case WGL_ACCUM_BITS_ARB: 218 *pvalue = pfi->pfd.cAccumBits; 219 break; 220 221 case WGL_ACCUM_RED_BITS_ARB: 222 *pvalue = pfi->pfd.cAccumRedBits; 223 break; 224 225 case WGL_ACCUM_GREEN_BITS_ARB: 226 *pvalue = pfi->pfd.cAccumGreenBits; 227 break; 228 229 case WGL_ACCUM_BLUE_BITS_ARB: 230 *pvalue = pfi->pfd.cAccumBlueBits; 231 break; 232 233 case WGL_ACCUM_ALPHA_BITS_ARB: 234 *pvalue = pfi->pfd.cAccumAlphaBits; 235 break; 236 237 case WGL_DEPTH_BITS_ARB: 238 *pvalue = pfi->pfd.cDepthBits; 239 break; 240 241 case WGL_STENCIL_BITS_ARB: 242 *pvalue = pfi->pfd.cStencilBits; 243 break; 244 245 case WGL_AUX_BUFFERS_ARB: 246 *pvalue = pfi->pfd.cAuxBuffers; 247 break; 248 249 case WGL_SAMPLE_BUFFERS_ARB: 250 *pvalue = (pfi->stvis.samples > 1); 251 break; 252 253 case WGL_SAMPLES_ARB: 254 *pvalue = pfi->stvis.samples; 255 break; 256 257 258 /* WGL_ARB_pbuffer */ 259 260 case WGL_MAX_PBUFFER_WIDTH_ARB: 261 case WGL_MAX_PBUFFER_HEIGHT_ARB: 262 *pvalue = stw_dev->max_2d_length; 263 break; 264 265 case WGL_MAX_PBUFFER_PIXELS_ARB: 266 *pvalue = stw_dev->max_2d_length * stw_dev->max_2d_length; 267 break; 268 269 case WGL_DRAW_TO_PBUFFER_ARB: 270 *pvalue = 1; 271 break; 272 273 274 default: 275 return FALSE; 276 } 277 278 return TRUE; 279 } 280 281 struct attrib_match_info 282 { 283 int attribute; 284 int weight; 285 BOOL exact; 286 }; 287 288 static const struct attrib_match_info attrib_match[] = { 289 290 /* WGL_ARB_pixel_format */ 291 { WGL_DRAW_TO_WINDOW_ARB, 0, TRUE }, 292 { WGL_DRAW_TO_BITMAP_ARB, 0, TRUE }, 293 { WGL_ACCELERATION_ARB, 0, TRUE }, 294 { WGL_NEED_PALETTE_ARB, 0, TRUE }, 295 { WGL_NEED_SYSTEM_PALETTE_ARB, 0, TRUE }, 296 { WGL_SWAP_LAYER_BUFFERS_ARB, 0, TRUE }, 297 { WGL_SWAP_METHOD_ARB, 0, TRUE }, 298 { WGL_NUMBER_OVERLAYS_ARB, 4, FALSE }, 299 { WGL_NUMBER_UNDERLAYS_ARB, 4, FALSE }, 300 /*{ WGL_SHARE_DEPTH_ARB, 0, TRUE },*/ /* no overlays -- ignore */ 301 /*{ WGL_SHARE_STENCIL_ARB, 0, TRUE },*/ /* no overlays -- ignore */ 302 /*{ WGL_SHARE_ACCUM_ARB, 0, TRUE },*/ /* no overlays -- ignore */ 303 { WGL_SUPPORT_GDI_ARB, 0, TRUE }, 304 { WGL_SUPPORT_OPENGL_ARB, 0, TRUE }, 305 { WGL_DOUBLE_BUFFER_ARB, 0, TRUE }, 306 { WGL_STEREO_ARB, 0, TRUE }, 307 { WGL_PIXEL_TYPE_ARB, 0, TRUE }, 308 { WGL_COLOR_BITS_ARB, 1, FALSE }, 309 { WGL_RED_BITS_ARB, 1, FALSE }, 310 { WGL_GREEN_BITS_ARB, 1, FALSE }, 311 { WGL_BLUE_BITS_ARB, 1, FALSE }, 312 { WGL_ALPHA_BITS_ARB, 1, FALSE }, 313 { WGL_ACCUM_BITS_ARB, 1, FALSE }, 314 { WGL_ACCUM_RED_BITS_ARB, 1, FALSE }, 315 { WGL_ACCUM_GREEN_BITS_ARB, 1, FALSE }, 316 { WGL_ACCUM_BLUE_BITS_ARB, 1, FALSE }, 317 { WGL_ACCUM_ALPHA_BITS_ARB, 1, FALSE }, 318 { WGL_DEPTH_BITS_ARB, 1, FALSE }, 319 { WGL_STENCIL_BITS_ARB, 1, FALSE }, 320 { WGL_AUX_BUFFERS_ARB, 2, FALSE }, 321 322 /* WGL_ARB_multisample */ 323 { WGL_SAMPLE_BUFFERS_ARB, 2, FALSE }, 324 { WGL_SAMPLES_ARB, 2, FALSE }, 325 326 /* WGL_ARB_render_texture */ 327 { WGL_BIND_TO_TEXTURE_RGB_ARB, 0, FALSE }, 328 { WGL_BIND_TO_TEXTURE_RGBA_ARB, 0, FALSE }, 329 }; 330 331 struct stw_pixelformat_score 332 { 333 int points; 334 uint index; 335 }; 336 337 static BOOL 338 score_pixelformats( 339 struct stw_pixelformat_score *scores, 340 uint count, 341 int attribute, 342 int expected_value ) 343 { 344 uint i; 345 const struct attrib_match_info *ami = NULL; 346 uint index; 347 348 /* Find out if a given attribute should be considered for score calculation. 349 */ 350 for (i = 0; i < sizeof( attrib_match ) / sizeof( attrib_match[0] ); i++) { 351 if (attrib_match[i].attribute == attribute) { 352 ami = &attrib_match[i]; 353 break; 354 } 355 } 356 if (ami == NULL) 357 return TRUE; 358 359 /* Iterate all pixelformats, query the requested attribute and calculate 360 * score points. 361 */ 362 for (index = 0; index < count; index++) { 363 int actual_value; 364 365 if (!stw_query_attrib( index + 1, 0, attribute, &actual_value )) 366 return FALSE; 367 368 if (ami->exact) { 369 /* For an exact match criteria, if the actual and expected values differ, 370 * the score is set to 0 points, effectively removing the pixelformat 371 * from a list of matching pixelformats. 372 */ 373 if (actual_value != expected_value) 374 scores[index].points = 0; 375 } 376 else { 377 /* For a minimum match criteria, if the actual value is smaller than the expected 378 * value, the pixelformat is rejected (score set to 0). However, if the actual 379 * value is bigger, the pixelformat is given a penalty to favour pixelformats that 380 * more closely match the expected values. 381 */ 382 if (actual_value < expected_value) 383 scores[index].points = 0; 384 else if (actual_value > expected_value) 385 scores[index].points -= (actual_value - expected_value) * ami->weight; 386 } 387 } 388 389 return TRUE; 390 } 391 392 WINGDIAPI BOOL APIENTRY 393 wglChoosePixelFormatARB( 394 HDC hdc, 395 const int *piAttribIList, 396 const FLOAT *pfAttribFList, 397 UINT nMaxFormats, 398 int *piFormats, 399 UINT *nNumFormats ) 400 { 401 uint count; 402 struct stw_pixelformat_score *scores; 403 uint i; 404 405 *nNumFormats = 0; 406 407 /* Allocate and initialize pixelformat score table -- better matches 408 * have higher scores. Start with a high score and take out penalty 409 * points for a mismatch when the match does not have to be exact. 410 * Set a score to 0 if there is a mismatch for an exact match criteria. 411 */ 412 count = stw_pixelformat_get_extended_count(); 413 scores = (struct stw_pixelformat_score *) MALLOC( count * sizeof( struct stw_pixelformat_score ) ); 414 if (scores == NULL) 415 return FALSE; 416 for (i = 0; i < count; i++) { 417 scores[i].points = 0x7fffffff; 418 scores[i].index = i; 419 } 420 421 /* Given the attribute list calculate a score for each pixelformat. 422 */ 423 if (piAttribIList != NULL) { 424 while (*piAttribIList != 0) { 425 if (!score_pixelformats( scores, count, piAttribIList[0], piAttribIList[1] )) { 426 FREE( scores ); 427 return FALSE; 428 } 429 piAttribIList += 2; 430 } 431 } 432 if (pfAttribFList != NULL) { 433 while (*pfAttribFList != 0) { 434 if (!score_pixelformats( scores, count, (int) pfAttribFList[0], (int) pfAttribFList[1] )) { 435 FREE( scores ); 436 return FALSE; 437 } 438 pfAttribFList += 2; 439 } 440 } 441 442 /* Bubble-sort the resulting scores. Pixelformats with higher scores go first. 443 * TODO: Find out if there are any patent issues with it. 444 */ 445 if (count > 1) { 446 uint n = count; 447 boolean swapped; 448 449 do { 450 swapped = FALSE; 451 for (i = 1; i < n; i++) { 452 if (scores[i - 1].points < scores[i].points) { 453 struct stw_pixelformat_score score = scores[i - 1]; 454 455 scores[i - 1] = scores[i]; 456 scores[i] = score; 457 swapped = TRUE; 458 } 459 } 460 n--; 461 } 462 while (swapped); 463 } 464 465 /* Return a list of pixelformats that are the best match. 466 * Reject pixelformats with non-positive scores. 467 */ 468 for (i = 0; i < count; i++) { 469 if (scores[i].points > 0) { 470 piFormats[*nNumFormats] = scores[i].index + 1; 471 (*nNumFormats)++; 472 if (*nNumFormats >= nMaxFormats) { 473 break; 474 } 475 } 476 } 477 478 FREE( scores ); 479 return TRUE; 480 } 481 482 WINGDIAPI BOOL APIENTRY 483 wglGetPixelFormatAttribfvARB( 484 HDC hdc, 485 int iPixelFormat, 486 int iLayerPlane, 487 UINT nAttributes, 488 const int *piAttributes, 489 FLOAT *pfValues ) 490 { 491 UINT i; 492 493 (void) hdc; 494 495 for (i = 0; i < nAttributes; i++) { 496 int value; 497 498 if (!stw_query_attrib( iPixelFormat, iLayerPlane, piAttributes[i], &value )) 499 return FALSE; 500 pfValues[i] = (FLOAT) value; 501 } 502 503 return TRUE; 504 } 505 506 WINGDIAPI BOOL APIENTRY 507 wglGetPixelFormatAttribivARB( 508 HDC hdc, 509 int iPixelFormat, 510 int iLayerPlane, 511 UINT nAttributes, 512 const int *piAttributes, 513 int *piValues ) 514 { 515 UINT i; 516 517 (void) hdc; 518 519 for (i = 0; i < nAttributes; i++) { 520 if (!stw_query_attrib( iPixelFormat, iLayerPlane, piAttributes[i], &piValues[i] )) 521 return FALSE; 522 } 523 524 return TRUE; 525 } 526
