wgl_context.c (26959B)
1 //======================================================================== 2 // GLFW 3.3 WGL - www.glfw.org 3 //------------------------------------------------------------------------ 4 // Copyright (c) 2002-2006 Marcus Geelnard 5 // Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.org> 6 // 7 // This software is provided 'as-is', without any express or implied 8 // warranty. In no event will the authors be held liable for any damages 9 // arising from the use of this software. 10 // 11 // Permission is granted to anyone to use this software for any purpose, 12 // including commercial applications, and to alter it and redistribute it 13 // freely, subject to the following restrictions: 14 // 15 // 1. The origin of this software must not be misrepresented; you must not 16 // claim that you wrote the original software. If you use this software 17 // in a product, an acknowledgment in the product documentation would 18 // be appreciated but is not required. 19 // 20 // 2. Altered source versions must be plainly marked as such, and must not 21 // be misrepresented as being the original software. 22 // 23 // 3. This notice may not be removed or altered from any source 24 // distribution. 25 // 26 //======================================================================== 27 // Please use C89 style variable declarations in this file because VS 2010 28 //======================================================================== 29 30 #include "internal.h" 31 32 #include <stdlib.h> 33 #include <malloc.h> 34 #include <assert.h> 35 36 // Return the value corresponding to the specified attribute 37 // 38 static int findPixelFormatAttribValue(const int* attribs, 39 int attribCount, 40 const int* values, 41 int attrib) 42 { 43 int i; 44 45 for (i = 0; i < attribCount; i++) 46 { 47 if (attribs[i] == attrib) 48 return values[i]; 49 } 50 51 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 52 "WGL: Unknown pixel format attribute requested"); 53 return 0; 54 } 55 56 #define addAttrib(a) \ 57 { \ 58 assert((size_t) attribCount < sizeof(attribs) / sizeof(attribs[0])); \ 59 attribs[attribCount++] = a; \ 60 } 61 #define findAttribValue(a) \ 62 findPixelFormatAttribValue(attribs, attribCount, values, a) 63 64 // Return a list of available and usable framebuffer configs 65 // 66 static int choosePixelFormat(_GLFWwindow* window, 67 const _GLFWctxconfig* ctxconfig, 68 const _GLFWfbconfig* fbconfig) 69 { 70 _GLFWfbconfig* usableConfigs; 71 const _GLFWfbconfig* closest; 72 int i, pixelFormat, nativeCount, usableCount = 0, attribCount = 0; 73 int attribs[40]; 74 int values[sizeof(attribs) / sizeof(attribs[0])]; 75 76 if (_glfw.wgl.ARB_pixel_format) 77 { 78 const int attrib = WGL_NUMBER_PIXEL_FORMATS_ARB; 79 80 if (!wglGetPixelFormatAttribivARB(window->context.wgl.dc, 81 1, 0, 1, &attrib, &nativeCount)) 82 { 83 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 84 "WGL: Failed to retrieve pixel format attribute"); 85 return 0; 86 } 87 88 addAttrib(WGL_SUPPORT_OPENGL_ARB); 89 addAttrib(WGL_DRAW_TO_WINDOW_ARB); 90 addAttrib(WGL_PIXEL_TYPE_ARB); 91 addAttrib(WGL_ACCELERATION_ARB); 92 addAttrib(WGL_RED_BITS_ARB); 93 addAttrib(WGL_RED_SHIFT_ARB); 94 addAttrib(WGL_GREEN_BITS_ARB); 95 addAttrib(WGL_GREEN_SHIFT_ARB); 96 addAttrib(WGL_BLUE_BITS_ARB); 97 addAttrib(WGL_BLUE_SHIFT_ARB); 98 addAttrib(WGL_ALPHA_BITS_ARB); 99 addAttrib(WGL_ALPHA_SHIFT_ARB); 100 addAttrib(WGL_DEPTH_BITS_ARB); 101 addAttrib(WGL_STENCIL_BITS_ARB); 102 addAttrib(WGL_ACCUM_BITS_ARB); 103 addAttrib(WGL_ACCUM_RED_BITS_ARB); 104 addAttrib(WGL_ACCUM_GREEN_BITS_ARB); 105 addAttrib(WGL_ACCUM_BLUE_BITS_ARB); 106 addAttrib(WGL_ACCUM_ALPHA_BITS_ARB); 107 addAttrib(WGL_AUX_BUFFERS_ARB); 108 addAttrib(WGL_STEREO_ARB); 109 addAttrib(WGL_DOUBLE_BUFFER_ARB); 110 111 if (_glfw.wgl.ARB_multisample) 112 addAttrib(WGL_SAMPLES_ARB); 113 114 if (ctxconfig->client == GLFW_OPENGL_API) 115 { 116 if (_glfw.wgl.ARB_framebuffer_sRGB || _glfw.wgl.EXT_framebuffer_sRGB) 117 addAttrib(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB); 118 } 119 else 120 { 121 if (_glfw.wgl.EXT_colorspace) 122 addAttrib(WGL_COLORSPACE_EXT); 123 } 124 } 125 else 126 { 127 nativeCount = DescribePixelFormat(window->context.wgl.dc, 128 1, 129 sizeof(PIXELFORMATDESCRIPTOR), 130 NULL); 131 } 132 133 usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig)); 134 135 for (i = 0; i < nativeCount; i++) 136 { 137 _GLFWfbconfig* u = usableConfigs + usableCount; 138 pixelFormat = i + 1; 139 140 if (_glfw.wgl.ARB_pixel_format) 141 { 142 // Get pixel format attributes through "modern" extension 143 144 if (!wglGetPixelFormatAttribivARB(window->context.wgl.dc, 145 pixelFormat, 0, 146 attribCount, 147 attribs, values)) 148 { 149 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 150 "WGL: Failed to retrieve pixel format attributes"); 151 152 free(usableConfigs); 153 return 0; 154 } 155 156 if (!findAttribValue(WGL_SUPPORT_OPENGL_ARB) || 157 !findAttribValue(WGL_DRAW_TO_WINDOW_ARB)) 158 { 159 continue; 160 } 161 162 if (findAttribValue(WGL_PIXEL_TYPE_ARB) != WGL_TYPE_RGBA_ARB) 163 continue; 164 165 if (findAttribValue(WGL_ACCELERATION_ARB) == WGL_NO_ACCELERATION_ARB) 166 continue; 167 168 if (findAttribValue(WGL_DOUBLE_BUFFER_ARB) != fbconfig->doublebuffer) 169 continue; 170 171 u->redBits = findAttribValue(WGL_RED_BITS_ARB); 172 u->greenBits = findAttribValue(WGL_GREEN_BITS_ARB); 173 u->blueBits = findAttribValue(WGL_BLUE_BITS_ARB); 174 u->alphaBits = findAttribValue(WGL_ALPHA_BITS_ARB); 175 176 u->depthBits = findAttribValue(WGL_DEPTH_BITS_ARB); 177 u->stencilBits = findAttribValue(WGL_STENCIL_BITS_ARB); 178 179 u->accumRedBits = findAttribValue(WGL_ACCUM_RED_BITS_ARB); 180 u->accumGreenBits = findAttribValue(WGL_ACCUM_GREEN_BITS_ARB); 181 u->accumBlueBits = findAttribValue(WGL_ACCUM_BLUE_BITS_ARB); 182 u->accumAlphaBits = findAttribValue(WGL_ACCUM_ALPHA_BITS_ARB); 183 184 u->auxBuffers = findAttribValue(WGL_AUX_BUFFERS_ARB); 185 186 if (findAttribValue(WGL_STEREO_ARB)) 187 u->stereo = GLFW_TRUE; 188 189 if (_glfw.wgl.ARB_multisample) 190 u->samples = findAttribValue(WGL_SAMPLES_ARB); 191 192 if (ctxconfig->client == GLFW_OPENGL_API) 193 { 194 if (_glfw.wgl.ARB_framebuffer_sRGB || 195 _glfw.wgl.EXT_framebuffer_sRGB) 196 { 197 if (findAttribValue(WGL_FRAMEBUFFER_SRGB_CAPABLE_ARB)) 198 u->sRGB = GLFW_TRUE; 199 } 200 } 201 else 202 { 203 if (_glfw.wgl.EXT_colorspace) 204 { 205 if (findAttribValue(WGL_COLORSPACE_EXT) == WGL_COLORSPACE_SRGB_EXT) 206 u->sRGB = GLFW_TRUE; 207 } 208 } 209 } 210 else 211 { 212 // Get pixel format attributes through legacy PFDs 213 214 PIXELFORMATDESCRIPTOR pfd; 215 216 if (!DescribePixelFormat(window->context.wgl.dc, 217 pixelFormat, 218 sizeof(PIXELFORMATDESCRIPTOR), 219 &pfd)) 220 { 221 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 222 "WGL: Failed to describe pixel format"); 223 224 free(usableConfigs); 225 return 0; 226 } 227 228 if (!(pfd.dwFlags & PFD_DRAW_TO_WINDOW) || 229 !(pfd.dwFlags & PFD_SUPPORT_OPENGL)) 230 { 231 continue; 232 } 233 234 if (!(pfd.dwFlags & PFD_GENERIC_ACCELERATED) && 235 (pfd.dwFlags & PFD_GENERIC_FORMAT)) 236 { 237 continue; 238 } 239 240 if (pfd.iPixelType != PFD_TYPE_RGBA) 241 continue; 242 243 if (!!(pfd.dwFlags & PFD_DOUBLEBUFFER) != fbconfig->doublebuffer) 244 continue; 245 246 u->redBits = pfd.cRedBits; 247 u->greenBits = pfd.cGreenBits; 248 u->blueBits = pfd.cBlueBits; 249 u->alphaBits = pfd.cAlphaBits; 250 251 u->depthBits = pfd.cDepthBits; 252 u->stencilBits = pfd.cStencilBits; 253 254 u->accumRedBits = pfd.cAccumRedBits; 255 u->accumGreenBits = pfd.cAccumGreenBits; 256 u->accumBlueBits = pfd.cAccumBlueBits; 257 u->accumAlphaBits = pfd.cAccumAlphaBits; 258 259 u->auxBuffers = pfd.cAuxBuffers; 260 261 if (pfd.dwFlags & PFD_STEREO) 262 u->stereo = GLFW_TRUE; 263 } 264 265 u->handle = pixelFormat; 266 usableCount++; 267 } 268 269 if (!usableCount) 270 { 271 _glfwInputError(GLFW_API_UNAVAILABLE, 272 "WGL: The driver does not appear to support OpenGL"); 273 274 free(usableConfigs); 275 return 0; 276 } 277 278 closest = _glfwChooseFBConfig(fbconfig, usableConfigs, usableCount); 279 if (!closest) 280 { 281 _glfwInputError(GLFW_FORMAT_UNAVAILABLE, 282 "WGL: Failed to find a suitable pixel format"); 283 284 free(usableConfigs); 285 return 0; 286 } 287 288 pixelFormat = (int) closest->handle; 289 free(usableConfigs); 290 291 return pixelFormat; 292 } 293 294 #undef addAttrib 295 #undef findAttribValue 296 297 static void makeContextCurrentWGL(_GLFWwindow* window) 298 { 299 if (window) 300 { 301 if (wglMakeCurrent(window->context.wgl.dc, window->context.wgl.handle)) 302 _glfwPlatformSetTls(&_glfw.contextSlot, window); 303 else 304 { 305 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 306 "WGL: Failed to make context current"); 307 _glfwPlatformSetTls(&_glfw.contextSlot, NULL); 308 } 309 } 310 else 311 { 312 if (!wglMakeCurrent(NULL, NULL)) 313 { 314 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 315 "WGL: Failed to clear current context"); 316 } 317 318 _glfwPlatformSetTls(&_glfw.contextSlot, NULL); 319 } 320 } 321 322 static void swapBuffersWGL(_GLFWwindow* window) 323 { 324 if (!window->monitor) 325 { 326 if (IsWindowsVistaOrGreater()) 327 { 328 // DWM Composition is always enabled on Win8+ 329 BOOL enabled = IsWindows8OrGreater(); 330 331 // HACK: Use DwmFlush when desktop composition is enabled 332 if (enabled || 333 (SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled)) 334 { 335 int count = abs(window->context.wgl.interval); 336 while (count--) 337 DwmFlush(); 338 } 339 } 340 } 341 342 SwapBuffers(window->context.wgl.dc); 343 } 344 345 static void swapIntervalWGL(int interval) 346 { 347 _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot); 348 349 window->context.wgl.interval = interval; 350 351 if (!window->monitor) 352 { 353 if (IsWindowsVistaOrGreater()) 354 { 355 // DWM Composition is always enabled on Win8+ 356 BOOL enabled = IsWindows8OrGreater(); 357 358 // HACK: Disable WGL swap interval when desktop composition is enabled to 359 // avoid interfering with DWM vsync 360 if (enabled || 361 (SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled)) 362 interval = 0; 363 } 364 } 365 366 if (_glfw.wgl.EXT_swap_control) 367 wglSwapIntervalEXT(interval); 368 } 369 370 static int extensionSupportedWGL(const char* extension) 371 { 372 const char* extensions = NULL; 373 374 if (_glfw.wgl.GetExtensionsStringARB) 375 extensions = wglGetExtensionsStringARB(wglGetCurrentDC()); 376 else if (_glfw.wgl.GetExtensionsStringEXT) 377 extensions = wglGetExtensionsStringEXT(); 378 379 if (!extensions) 380 return GLFW_FALSE; 381 382 return _glfwStringInExtensionString(extension, extensions); 383 } 384 385 static GLFWglproc getProcAddressWGL(const char* procname) 386 { 387 const GLFWglproc proc = (GLFWglproc) wglGetProcAddress(procname); 388 if (proc) 389 return proc; 390 391 return (GLFWglproc) GetProcAddress(_glfw.wgl.instance, procname); 392 } 393 394 static void destroyContextWGL(_GLFWwindow* window) 395 { 396 if (window->context.wgl.handle) 397 { 398 wglDeleteContext(window->context.wgl.handle); 399 window->context.wgl.handle = NULL; 400 } 401 } 402 403 404 ////////////////////////////////////////////////////////////////////////// 405 ////// GLFW internal API ////// 406 ////////////////////////////////////////////////////////////////////////// 407 408 // Initialize WGL 409 // 410 GLFWbool _glfwInitWGL(void) 411 { 412 PIXELFORMATDESCRIPTOR pfd; 413 HGLRC prc, rc; 414 HDC pdc, dc; 415 416 if (_glfw.wgl.instance) 417 return GLFW_TRUE; 418 419 _glfw.wgl.instance = LoadLibraryA("opengl32.dll"); 420 if (!_glfw.wgl.instance) 421 { 422 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 423 "WGL: Failed to load opengl32.dll"); 424 return GLFW_FALSE; 425 } 426 427 _glfw.wgl.CreateContext = (PFN_wglCreateContext) 428 GetProcAddress(_glfw.wgl.instance, "wglCreateContext"); 429 _glfw.wgl.DeleteContext = (PFN_wglDeleteContext) 430 GetProcAddress(_glfw.wgl.instance, "wglDeleteContext"); 431 _glfw.wgl.GetProcAddress = (PFN_wglGetProcAddress) 432 GetProcAddress(_glfw.wgl.instance, "wglGetProcAddress"); 433 _glfw.wgl.GetCurrentDC = (PFN_wglGetCurrentDC) 434 GetProcAddress(_glfw.wgl.instance, "wglGetCurrentDC"); 435 _glfw.wgl.GetCurrentContext = (PFN_wglGetCurrentContext) 436 GetProcAddress(_glfw.wgl.instance, "wglGetCurrentContext"); 437 _glfw.wgl.MakeCurrent = (PFN_wglMakeCurrent) 438 GetProcAddress(_glfw.wgl.instance, "wglMakeCurrent"); 439 _glfw.wgl.ShareLists = (PFN_wglShareLists) 440 GetProcAddress(_glfw.wgl.instance, "wglShareLists"); 441 442 // NOTE: A dummy context has to be created for opengl32.dll to load the 443 // OpenGL ICD, from which we can then query WGL extensions 444 // NOTE: This code will accept the Microsoft GDI ICD; accelerated context 445 // creation failure occurs during manual pixel format enumeration 446 447 dc = GetDC(_glfw.win32.helperWindowHandle); 448 449 ZeroMemory(&pfd, sizeof(pfd)); 450 pfd.nSize = sizeof(pfd); 451 pfd.nVersion = 1; 452 pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER; 453 pfd.iPixelType = PFD_TYPE_RGBA; 454 pfd.cColorBits = 24; 455 456 if (!SetPixelFormat(dc, ChoosePixelFormat(dc, &pfd), &pfd)) 457 { 458 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 459 "WGL: Failed to set pixel format for dummy context"); 460 return GLFW_FALSE; 461 } 462 463 rc = wglCreateContext(dc); 464 if (!rc) 465 { 466 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 467 "WGL: Failed to create dummy context"); 468 return GLFW_FALSE; 469 } 470 471 pdc = wglGetCurrentDC(); 472 prc = wglGetCurrentContext(); 473 474 if (!wglMakeCurrent(dc, rc)) 475 { 476 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 477 "WGL: Failed to make dummy context current"); 478 wglMakeCurrent(pdc, prc); 479 wglDeleteContext(rc); 480 return GLFW_FALSE; 481 } 482 483 // NOTE: Functions must be loaded first as they're needed to retrieve the 484 // extension string that tells us whether the functions are supported 485 _glfw.wgl.GetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC) 486 wglGetProcAddress("wglGetExtensionsStringEXT"); 487 _glfw.wgl.GetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC) 488 wglGetProcAddress("wglGetExtensionsStringARB"); 489 _glfw.wgl.CreateContextAttribsARB = (PFNWGLCREATECONTEXTATTRIBSARBPROC) 490 wglGetProcAddress("wglCreateContextAttribsARB"); 491 _glfw.wgl.SwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) 492 wglGetProcAddress("wglSwapIntervalEXT"); 493 _glfw.wgl.GetPixelFormatAttribivARB = (PFNWGLGETPIXELFORMATATTRIBIVARBPROC) 494 wglGetProcAddress("wglGetPixelFormatAttribivARB"); 495 496 // NOTE: WGL_ARB_extensions_string and WGL_EXT_extensions_string are not 497 // checked below as we are already using them 498 _glfw.wgl.ARB_multisample = 499 extensionSupportedWGL("WGL_ARB_multisample"); 500 _glfw.wgl.ARB_framebuffer_sRGB = 501 extensionSupportedWGL("WGL_ARB_framebuffer_sRGB"); 502 _glfw.wgl.EXT_framebuffer_sRGB = 503 extensionSupportedWGL("WGL_EXT_framebuffer_sRGB"); 504 _glfw.wgl.ARB_create_context = 505 extensionSupportedWGL("WGL_ARB_create_context"); 506 _glfw.wgl.ARB_create_context_profile = 507 extensionSupportedWGL("WGL_ARB_create_context_profile"); 508 _glfw.wgl.EXT_create_context_es2_profile = 509 extensionSupportedWGL("WGL_EXT_create_context_es2_profile"); 510 _glfw.wgl.ARB_create_context_robustness = 511 extensionSupportedWGL("WGL_ARB_create_context_robustness"); 512 _glfw.wgl.ARB_create_context_no_error = 513 extensionSupportedWGL("WGL_ARB_create_context_no_error"); 514 _glfw.wgl.EXT_swap_control = 515 extensionSupportedWGL("WGL_EXT_swap_control"); 516 _glfw.wgl.EXT_colorspace = 517 extensionSupportedWGL("WGL_EXT_colorspace"); 518 _glfw.wgl.ARB_pixel_format = 519 extensionSupportedWGL("WGL_ARB_pixel_format"); 520 _glfw.wgl.ARB_context_flush_control = 521 extensionSupportedWGL("WGL_ARB_context_flush_control"); 522 523 wglMakeCurrent(pdc, prc); 524 wglDeleteContext(rc); 525 return GLFW_TRUE; 526 } 527 528 // Terminate WGL 529 // 530 void _glfwTerminateWGL(void) 531 { 532 if (_glfw.wgl.instance) 533 FreeLibrary(_glfw.wgl.instance); 534 } 535 536 #define setAttrib(a, v) \ 537 { \ 538 assert(((size_t) index + 1) < sizeof(attribs) / sizeof(attribs[0])); \ 539 attribs[index++] = a; \ 540 attribs[index++] = v; \ 541 } 542 543 // Create the OpenGL or OpenGL ES context 544 // 545 GLFWbool _glfwCreateContextWGL(_GLFWwindow* window, 546 const _GLFWctxconfig* ctxconfig, 547 const _GLFWfbconfig* fbconfig) 548 { 549 int attribs[40]; 550 int pixelFormat; 551 PIXELFORMATDESCRIPTOR pfd; 552 HGLRC share = NULL; 553 554 if (ctxconfig->share) 555 share = ctxconfig->share->context.wgl.handle; 556 557 window->context.wgl.dc = GetDC(window->win32.handle); 558 if (!window->context.wgl.dc) 559 { 560 _glfwInputError(GLFW_PLATFORM_ERROR, 561 "WGL: Failed to retrieve DC for window"); 562 return GLFW_FALSE; 563 } 564 565 pixelFormat = choosePixelFormat(window, ctxconfig, fbconfig); 566 if (!pixelFormat) 567 return GLFW_FALSE; 568 569 if (!DescribePixelFormat(window->context.wgl.dc, 570 pixelFormat, sizeof(pfd), &pfd)) 571 { 572 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 573 "WGL: Failed to retrieve PFD for selected pixel format"); 574 return GLFW_FALSE; 575 } 576 577 if (!SetPixelFormat(window->context.wgl.dc, pixelFormat, &pfd)) 578 { 579 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 580 "WGL: Failed to set selected pixel format"); 581 return GLFW_FALSE; 582 } 583 584 if (ctxconfig->client == GLFW_OPENGL_API) 585 { 586 if (ctxconfig->forward) 587 { 588 if (!_glfw.wgl.ARB_create_context) 589 { 590 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 591 "WGL: A forward compatible OpenGL context requested but WGL_ARB_create_context is unavailable"); 592 return GLFW_FALSE; 593 } 594 } 595 596 if (ctxconfig->profile) 597 { 598 if (!_glfw.wgl.ARB_create_context_profile) 599 { 600 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 601 "WGL: OpenGL profile requested but WGL_ARB_create_context_profile is unavailable"); 602 return GLFW_FALSE; 603 } 604 } 605 } 606 else 607 { 608 if (!_glfw.wgl.ARB_create_context || 609 !_glfw.wgl.ARB_create_context_profile || 610 !_glfw.wgl.EXT_create_context_es2_profile) 611 { 612 _glfwInputError(GLFW_API_UNAVAILABLE, 613 "WGL: OpenGL ES requested but WGL_ARB_create_context_es2_profile is unavailable"); 614 return GLFW_FALSE; 615 } 616 } 617 618 if (_glfw.wgl.ARB_create_context) 619 { 620 int index = 0, mask = 0, flags = 0; 621 622 if (ctxconfig->client == GLFW_OPENGL_API) 623 { 624 if (ctxconfig->forward) 625 flags |= WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; 626 627 if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE) 628 mask |= WGL_CONTEXT_CORE_PROFILE_BIT_ARB; 629 else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE) 630 mask |= WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; 631 } 632 else 633 mask |= WGL_CONTEXT_ES2_PROFILE_BIT_EXT; 634 635 if (ctxconfig->debug) 636 flags |= WGL_CONTEXT_DEBUG_BIT_ARB; 637 638 if (ctxconfig->robustness) 639 { 640 if (_glfw.wgl.ARB_create_context_robustness) 641 { 642 if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION) 643 { 644 setAttrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, 645 WGL_NO_RESET_NOTIFICATION_ARB); 646 } 647 else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET) 648 { 649 setAttrib(WGL_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, 650 WGL_LOSE_CONTEXT_ON_RESET_ARB); 651 } 652 653 flags |= WGL_CONTEXT_ROBUST_ACCESS_BIT_ARB; 654 } 655 } 656 657 if (ctxconfig->release) 658 { 659 if (_glfw.wgl.ARB_context_flush_control) 660 { 661 if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE) 662 { 663 setAttrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB, 664 WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB); 665 } 666 else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH) 667 { 668 setAttrib(WGL_CONTEXT_RELEASE_BEHAVIOR_ARB, 669 WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB); 670 } 671 } 672 } 673 674 if (ctxconfig->noerror) 675 { 676 if (_glfw.wgl.ARB_create_context_no_error) 677 setAttrib(WGL_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE); 678 } 679 680 // NOTE: Only request an explicitly versioned context when necessary, as 681 // explicitly requesting version 1.0 does not always return the 682 // highest version supported by the driver 683 if (ctxconfig->major != 1 || ctxconfig->minor != 0) 684 { 685 setAttrib(WGL_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major); 686 setAttrib(WGL_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor); 687 } 688 689 if (flags) 690 setAttrib(WGL_CONTEXT_FLAGS_ARB, flags); 691 692 if (mask) 693 setAttrib(WGL_CONTEXT_PROFILE_MASK_ARB, mask); 694 695 setAttrib(0, 0); 696 697 window->context.wgl.handle = 698 wglCreateContextAttribsARB(window->context.wgl.dc, share, attribs); 699 if (!window->context.wgl.handle) 700 { 701 const DWORD error = GetLastError(); 702 703 if (error == (0xc0070000 | ERROR_INVALID_VERSION_ARB)) 704 { 705 if (ctxconfig->client == GLFW_OPENGL_API) 706 { 707 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 708 "WGL: Driver does not support OpenGL version %i.%i", 709 ctxconfig->major, 710 ctxconfig->minor); 711 } 712 else 713 { 714 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 715 "WGL: Driver does not support OpenGL ES version %i.%i", 716 ctxconfig->major, 717 ctxconfig->minor); 718 } 719 } 720 else if (error == (0xc0070000 | ERROR_INVALID_PROFILE_ARB)) 721 { 722 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 723 "WGL: Driver does not support the requested OpenGL profile"); 724 } 725 else if (error == (0xc0070000 | ERROR_INCOMPATIBLE_DEVICE_CONTEXTS_ARB)) 726 { 727 _glfwInputError(GLFW_INVALID_VALUE, 728 "WGL: The share context is not compatible with the requested context"); 729 } 730 else 731 { 732 if (ctxconfig->client == GLFW_OPENGL_API) 733 { 734 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 735 "WGL: Failed to create OpenGL context"); 736 } 737 else 738 { 739 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 740 "WGL: Failed to create OpenGL ES context"); 741 } 742 } 743 744 return GLFW_FALSE; 745 } 746 } 747 else 748 { 749 window->context.wgl.handle = wglCreateContext(window->context.wgl.dc); 750 if (!window->context.wgl.handle) 751 { 752 _glfwInputErrorWin32(GLFW_VERSION_UNAVAILABLE, 753 "WGL: Failed to create OpenGL context"); 754 return GLFW_FALSE; 755 } 756 757 if (share) 758 { 759 if (!wglShareLists(share, window->context.wgl.handle)) 760 { 761 _glfwInputErrorWin32(GLFW_PLATFORM_ERROR, 762 "WGL: Failed to enable sharing with specified OpenGL context"); 763 return GLFW_FALSE; 764 } 765 } 766 } 767 768 window->context.makeCurrent = makeContextCurrentWGL; 769 window->context.swapBuffers = swapBuffersWGL; 770 window->context.swapInterval = swapIntervalWGL; 771 window->context.extensionSupported = extensionSupportedWGL; 772 window->context.getProcAddress = getProcAddressWGL; 773 window->context.destroy = destroyContextWGL; 774 775 return GLFW_TRUE; 776 } 777 778 #undef setAttrib 779 780 781 ////////////////////////////////////////////////////////////////////////// 782 ////// GLFW native API ////// 783 ////////////////////////////////////////////////////////////////////////// 784 785 GLFWAPI HGLRC glfwGetWGLContext(GLFWwindow* handle) 786 { 787 _GLFWwindow* window = (_GLFWwindow*) handle; 788 _GLFW_REQUIRE_INIT_OR_RETURN(NULL); 789 790 if (window->context.source != GLFW_NATIVE_CONTEXT_API) 791 { 792 _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL); 793 return NULL; 794 } 795 796 return window->context.wgl.handle; 797 } 798