glx_context.c (22638B)
1 //======================================================================== 2 // GLFW 3.3 GLX - 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 // It is fine to use C99 in this file because it will not be built with VS 28 //======================================================================== 29 30 #include "internal.h" 31 32 #include <string.h> 33 #include <stdlib.h> 34 #include <assert.h> 35 36 #ifndef GLXBadProfileARB 37 #define GLXBadProfileARB 13 38 #endif 39 40 41 // Returns the specified attribute of the specified GLXFBConfig 42 // 43 static int getGLXFBConfigAttrib(GLXFBConfig fbconfig, int attrib) 44 { 45 int value; 46 glXGetFBConfigAttrib(_glfw.x11.display, fbconfig, attrib, &value); 47 return value; 48 } 49 50 // Return the GLXFBConfig most closely matching the specified hints 51 // 52 static GLFWbool chooseGLXFBConfig(const _GLFWfbconfig* desired, 53 GLXFBConfig* result) 54 { 55 GLXFBConfig* nativeConfigs; 56 _GLFWfbconfig* usableConfigs; 57 const _GLFWfbconfig* closest; 58 int i, nativeCount, usableCount; 59 const char* vendor; 60 GLFWbool trustWindowBit = GLFW_TRUE; 61 62 // HACK: This is a (hopefully temporary) workaround for Chromium 63 // (VirtualBox GL) not setting the window bit on any GLXFBConfigs 64 vendor = glXGetClientString(_glfw.x11.display, GLX_VENDOR); 65 if (vendor && strcmp(vendor, "Chromium") == 0) 66 trustWindowBit = GLFW_FALSE; 67 68 nativeConfigs = 69 glXGetFBConfigs(_glfw.x11.display, _glfw.x11.screen, &nativeCount); 70 if (!nativeConfigs || !nativeCount) 71 { 72 _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: No GLXFBConfigs returned"); 73 return GLFW_FALSE; 74 } 75 76 usableConfigs = calloc(nativeCount, sizeof(_GLFWfbconfig)); 77 usableCount = 0; 78 79 for (i = 0; i < nativeCount; i++) 80 { 81 const GLXFBConfig n = nativeConfigs[i]; 82 _GLFWfbconfig* u = usableConfigs + usableCount; 83 84 // Only consider RGBA GLXFBConfigs 85 if (!(getGLXFBConfigAttrib(n, GLX_RENDER_TYPE) & GLX_RGBA_BIT)) 86 continue; 87 88 // Only consider window GLXFBConfigs 89 if (!(getGLXFBConfigAttrib(n, GLX_DRAWABLE_TYPE) & GLX_WINDOW_BIT)) 90 { 91 if (trustWindowBit) 92 continue; 93 } 94 95 if (getGLXFBConfigAttrib(n, GLX_DOUBLEBUFFER) != desired->doublebuffer) 96 continue; 97 98 if (desired->transparent) 99 { 100 XVisualInfo* vi = glXGetVisualFromFBConfig(_glfw.x11.display, n); 101 if (vi) 102 { 103 u->transparent = _glfwIsVisualTransparentX11(vi->visual); 104 XFree(vi); 105 } 106 } 107 108 u->redBits = getGLXFBConfigAttrib(n, GLX_RED_SIZE); 109 u->greenBits = getGLXFBConfigAttrib(n, GLX_GREEN_SIZE); 110 u->blueBits = getGLXFBConfigAttrib(n, GLX_BLUE_SIZE); 111 112 u->alphaBits = getGLXFBConfigAttrib(n, GLX_ALPHA_SIZE); 113 u->depthBits = getGLXFBConfigAttrib(n, GLX_DEPTH_SIZE); 114 u->stencilBits = getGLXFBConfigAttrib(n, GLX_STENCIL_SIZE); 115 116 u->accumRedBits = getGLXFBConfigAttrib(n, GLX_ACCUM_RED_SIZE); 117 u->accumGreenBits = getGLXFBConfigAttrib(n, GLX_ACCUM_GREEN_SIZE); 118 u->accumBlueBits = getGLXFBConfigAttrib(n, GLX_ACCUM_BLUE_SIZE); 119 u->accumAlphaBits = getGLXFBConfigAttrib(n, GLX_ACCUM_ALPHA_SIZE); 120 121 u->auxBuffers = getGLXFBConfigAttrib(n, GLX_AUX_BUFFERS); 122 123 if (getGLXFBConfigAttrib(n, GLX_STEREO)) 124 u->stereo = GLFW_TRUE; 125 126 if (_glfw.glx.ARB_multisample) 127 u->samples = getGLXFBConfigAttrib(n, GLX_SAMPLES); 128 129 if (_glfw.glx.ARB_framebuffer_sRGB || _glfw.glx.EXT_framebuffer_sRGB) 130 u->sRGB = getGLXFBConfigAttrib(n, GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB); 131 132 u->handle = (uintptr_t) n; 133 usableCount++; 134 } 135 136 closest = _glfwChooseFBConfig(desired, usableConfigs, usableCount); 137 if (closest) 138 *result = (GLXFBConfig) closest->handle; 139 140 XFree(nativeConfigs); 141 free(usableConfigs); 142 143 return closest != NULL; 144 } 145 146 // Create the OpenGL context using legacy API 147 // 148 static GLXContext createLegacyContextGLX(_GLFWwindow* window, 149 GLXFBConfig fbconfig, 150 GLXContext share) 151 { 152 return glXCreateNewContext(_glfw.x11.display, 153 fbconfig, 154 GLX_RGBA_TYPE, 155 share, 156 True); 157 } 158 159 static void makeContextCurrentGLX(_GLFWwindow* window) 160 { 161 if (window) 162 { 163 if (!glXMakeCurrent(_glfw.x11.display, 164 window->context.glx.window, 165 window->context.glx.handle)) 166 { 167 _glfwInputError(GLFW_PLATFORM_ERROR, 168 "GLX: Failed to make context current"); 169 return; 170 } 171 } 172 else 173 { 174 if (!glXMakeCurrent(_glfw.x11.display, None, NULL)) 175 { 176 _glfwInputError(GLFW_PLATFORM_ERROR, 177 "GLX: Failed to clear current context"); 178 return; 179 } 180 } 181 182 _glfwPlatformSetTls(&_glfw.contextSlot, window); 183 } 184 185 static void swapBuffersGLX(_GLFWwindow* window) 186 { 187 glXSwapBuffers(_glfw.x11.display, window->context.glx.window); 188 } 189 190 static void swapIntervalGLX(int interval) 191 { 192 _GLFWwindow* window = _glfwPlatformGetTls(&_glfw.contextSlot); 193 194 if (_glfw.glx.EXT_swap_control) 195 { 196 _glfw.glx.SwapIntervalEXT(_glfw.x11.display, 197 window->context.glx.window, 198 interval); 199 } 200 else if (_glfw.glx.MESA_swap_control) 201 _glfw.glx.SwapIntervalMESA(interval); 202 else if (_glfw.glx.SGI_swap_control) 203 { 204 if (interval > 0) 205 _glfw.glx.SwapIntervalSGI(interval); 206 } 207 } 208 209 static int extensionSupportedGLX(const char* extension) 210 { 211 const char* extensions = 212 glXQueryExtensionsString(_glfw.x11.display, _glfw.x11.screen); 213 if (extensions) 214 { 215 if (_glfwStringInExtensionString(extension, extensions)) 216 return GLFW_TRUE; 217 } 218 219 return GLFW_FALSE; 220 } 221 222 static GLFWglproc getProcAddressGLX(const char* procname) 223 { 224 if (_glfw.glx.GetProcAddress) 225 return _glfw.glx.GetProcAddress((const GLubyte*) procname); 226 else if (_glfw.glx.GetProcAddressARB) 227 return _glfw.glx.GetProcAddressARB((const GLubyte*) procname); 228 else 229 return _glfw_dlsym(_glfw.glx.handle, procname); 230 } 231 232 static void destroyContextGLX(_GLFWwindow* window) 233 { 234 if (window->context.glx.window) 235 { 236 glXDestroyWindow(_glfw.x11.display, window->context.glx.window); 237 window->context.glx.window = None; 238 } 239 240 if (window->context.glx.handle) 241 { 242 glXDestroyContext(_glfw.x11.display, window->context.glx.handle); 243 window->context.glx.handle = NULL; 244 } 245 } 246 247 248 ////////////////////////////////////////////////////////////////////////// 249 ////// GLFW internal API ////// 250 ////////////////////////////////////////////////////////////////////////// 251 252 // Initialize GLX 253 // 254 GLFWbool _glfwInitGLX(void) 255 { 256 int i; 257 const char* sonames[] = 258 { 259 #if defined(_GLFW_GLX_LIBRARY) 260 _GLFW_GLX_LIBRARY, 261 #elif defined(__CYGWIN__) 262 "libGL-1.so", 263 #elif defined(__OpenBSD__) || defined(__NetBSD__) 264 "libGL.so", 265 #else 266 "libGL.so.1", 267 "libGL.so", 268 #endif 269 NULL 270 }; 271 272 if (_glfw.glx.handle) 273 return GLFW_TRUE; 274 275 for (i = 0; sonames[i]; i++) 276 { 277 _glfw.glx.handle = _glfw_dlopen(sonames[i]); 278 if (_glfw.glx.handle) 279 break; 280 } 281 282 if (!_glfw.glx.handle) 283 { 284 _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: Failed to load GLX"); 285 return GLFW_FALSE; 286 } 287 288 _glfw.glx.GetFBConfigs = 289 _glfw_dlsym(_glfw.glx.handle, "glXGetFBConfigs"); 290 _glfw.glx.GetFBConfigAttrib = 291 _glfw_dlsym(_glfw.glx.handle, "glXGetFBConfigAttrib"); 292 _glfw.glx.GetClientString = 293 _glfw_dlsym(_glfw.glx.handle, "glXGetClientString"); 294 _glfw.glx.QueryExtension = 295 _glfw_dlsym(_glfw.glx.handle, "glXQueryExtension"); 296 _glfw.glx.QueryVersion = 297 _glfw_dlsym(_glfw.glx.handle, "glXQueryVersion"); 298 _glfw.glx.DestroyContext = 299 _glfw_dlsym(_glfw.glx.handle, "glXDestroyContext"); 300 _glfw.glx.MakeCurrent = 301 _glfw_dlsym(_glfw.glx.handle, "glXMakeCurrent"); 302 _glfw.glx.SwapBuffers = 303 _glfw_dlsym(_glfw.glx.handle, "glXSwapBuffers"); 304 _glfw.glx.QueryExtensionsString = 305 _glfw_dlsym(_glfw.glx.handle, "glXQueryExtensionsString"); 306 _glfw.glx.CreateNewContext = 307 _glfw_dlsym(_glfw.glx.handle, "glXCreateNewContext"); 308 _glfw.glx.CreateWindow = 309 _glfw_dlsym(_glfw.glx.handle, "glXCreateWindow"); 310 _glfw.glx.DestroyWindow = 311 _glfw_dlsym(_glfw.glx.handle, "glXDestroyWindow"); 312 _glfw.glx.GetVisualFromFBConfig = 313 _glfw_dlsym(_glfw.glx.handle, "glXGetVisualFromFBConfig"); 314 315 if (!_glfw.glx.GetFBConfigs || 316 !_glfw.glx.GetFBConfigAttrib || 317 !_glfw.glx.GetClientString || 318 !_glfw.glx.QueryExtension || 319 !_glfw.glx.QueryVersion || 320 !_glfw.glx.DestroyContext || 321 !_glfw.glx.MakeCurrent || 322 !_glfw.glx.SwapBuffers || 323 !_glfw.glx.QueryExtensionsString || 324 !_glfw.glx.CreateNewContext || 325 !_glfw.glx.CreateWindow || 326 !_glfw.glx.DestroyWindow || 327 !_glfw.glx.GetVisualFromFBConfig) 328 { 329 _glfwInputError(GLFW_PLATFORM_ERROR, 330 "GLX: Failed to load required entry points"); 331 return GLFW_FALSE; 332 } 333 334 // NOTE: Unlike GLX 1.3 entry points these are not required to be present 335 _glfw.glx.GetProcAddress = (PFNGLXGETPROCADDRESSPROC) 336 _glfw_dlsym(_glfw.glx.handle, "glXGetProcAddress"); 337 _glfw.glx.GetProcAddressARB = (PFNGLXGETPROCADDRESSPROC) 338 _glfw_dlsym(_glfw.glx.handle, "glXGetProcAddressARB"); 339 340 if (!glXQueryExtension(_glfw.x11.display, 341 &_glfw.glx.errorBase, 342 &_glfw.glx.eventBase)) 343 { 344 _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX extension not found"); 345 return GLFW_FALSE; 346 } 347 348 if (!glXQueryVersion(_glfw.x11.display, &_glfw.glx.major, &_glfw.glx.minor)) 349 { 350 _glfwInputError(GLFW_API_UNAVAILABLE, 351 "GLX: Failed to query GLX version"); 352 return GLFW_FALSE; 353 } 354 355 if (_glfw.glx.major == 1 && _glfw.glx.minor < 3) 356 { 357 _glfwInputError(GLFW_API_UNAVAILABLE, 358 "GLX: GLX version 1.3 is required"); 359 return GLFW_FALSE; 360 } 361 362 if (extensionSupportedGLX("GLX_EXT_swap_control")) 363 { 364 _glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) 365 getProcAddressGLX("glXSwapIntervalEXT"); 366 367 if (_glfw.glx.SwapIntervalEXT) 368 _glfw.glx.EXT_swap_control = GLFW_TRUE; 369 } 370 371 if (extensionSupportedGLX("GLX_SGI_swap_control")) 372 { 373 _glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) 374 getProcAddressGLX("glXSwapIntervalSGI"); 375 376 if (_glfw.glx.SwapIntervalSGI) 377 _glfw.glx.SGI_swap_control = GLFW_TRUE; 378 } 379 380 if (extensionSupportedGLX("GLX_MESA_swap_control")) 381 { 382 _glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC) 383 getProcAddressGLX("glXSwapIntervalMESA"); 384 385 if (_glfw.glx.SwapIntervalMESA) 386 _glfw.glx.MESA_swap_control = GLFW_TRUE; 387 } 388 389 if (extensionSupportedGLX("GLX_ARB_multisample")) 390 _glfw.glx.ARB_multisample = GLFW_TRUE; 391 392 if (extensionSupportedGLX("GLX_ARB_framebuffer_sRGB")) 393 _glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE; 394 395 if (extensionSupportedGLX("GLX_EXT_framebuffer_sRGB")) 396 _glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE; 397 398 if (extensionSupportedGLX("GLX_ARB_create_context")) 399 { 400 _glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC) 401 getProcAddressGLX("glXCreateContextAttribsARB"); 402 403 if (_glfw.glx.CreateContextAttribsARB) 404 _glfw.glx.ARB_create_context = GLFW_TRUE; 405 } 406 407 if (extensionSupportedGLX("GLX_ARB_create_context_robustness")) 408 _glfw.glx.ARB_create_context_robustness = GLFW_TRUE; 409 410 if (extensionSupportedGLX("GLX_ARB_create_context_profile")) 411 _glfw.glx.ARB_create_context_profile = GLFW_TRUE; 412 413 if (extensionSupportedGLX("GLX_EXT_create_context_es2_profile")) 414 _glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE; 415 416 if (extensionSupportedGLX("GLX_ARB_create_context_no_error")) 417 _glfw.glx.ARB_create_context_no_error = GLFW_TRUE; 418 419 if (extensionSupportedGLX("GLX_ARB_context_flush_control")) 420 _glfw.glx.ARB_context_flush_control = GLFW_TRUE; 421 422 return GLFW_TRUE; 423 } 424 425 // Terminate GLX 426 // 427 void _glfwTerminateGLX(void) 428 { 429 // NOTE: This function must not call any X11 functions, as it is called 430 // after XCloseDisplay (see _glfwPlatformTerminate for details) 431 432 if (_glfw.glx.handle) 433 { 434 _glfw_dlclose(_glfw.glx.handle); 435 _glfw.glx.handle = NULL; 436 } 437 } 438 439 #define setAttrib(a, v) \ 440 { \ 441 assert(((size_t) index + 1) < sizeof(attribs) / sizeof(attribs[0])); \ 442 attribs[index++] = a; \ 443 attribs[index++] = v; \ 444 } 445 446 // Create the OpenGL or OpenGL ES context 447 // 448 GLFWbool _glfwCreateContextGLX(_GLFWwindow* window, 449 const _GLFWctxconfig* ctxconfig, 450 const _GLFWfbconfig* fbconfig) 451 { 452 int attribs[40]; 453 GLXFBConfig native = NULL; 454 GLXContext share = NULL; 455 456 if (ctxconfig->share) 457 share = ctxconfig->share->context.glx.handle; 458 459 if (!chooseGLXFBConfig(fbconfig, &native)) 460 { 461 _glfwInputError(GLFW_FORMAT_UNAVAILABLE, 462 "GLX: Failed to find a suitable GLXFBConfig"); 463 return GLFW_FALSE; 464 } 465 466 if (ctxconfig->client == GLFW_OPENGL_ES_API) 467 { 468 if (!_glfw.glx.ARB_create_context || 469 !_glfw.glx.ARB_create_context_profile || 470 !_glfw.glx.EXT_create_context_es2_profile) 471 { 472 _glfwInputError(GLFW_API_UNAVAILABLE, 473 "GLX: OpenGL ES requested but GLX_EXT_create_context_es2_profile is unavailable"); 474 return GLFW_FALSE; 475 } 476 } 477 478 if (ctxconfig->forward) 479 { 480 if (!_glfw.glx.ARB_create_context) 481 { 482 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 483 "GLX: Forward compatibility requested but GLX_ARB_create_context_profile is unavailable"); 484 return GLFW_FALSE; 485 } 486 } 487 488 if (ctxconfig->profile) 489 { 490 if (!_glfw.glx.ARB_create_context || 491 !_glfw.glx.ARB_create_context_profile) 492 { 493 _glfwInputError(GLFW_VERSION_UNAVAILABLE, 494 "GLX: An OpenGL profile requested but GLX_ARB_create_context_profile is unavailable"); 495 return GLFW_FALSE; 496 } 497 } 498 499 _glfwGrabErrorHandlerX11(); 500 501 if (_glfw.glx.ARB_create_context) 502 { 503 int index = 0, mask = 0, flags = 0; 504 505 if (ctxconfig->client == GLFW_OPENGL_API) 506 { 507 if (ctxconfig->forward) 508 flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; 509 510 if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE) 511 mask |= GLX_CONTEXT_CORE_PROFILE_BIT_ARB; 512 else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE) 513 mask |= GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; 514 } 515 else 516 mask |= GLX_CONTEXT_ES2_PROFILE_BIT_EXT; 517 518 if (ctxconfig->debug) 519 flags |= GLX_CONTEXT_DEBUG_BIT_ARB; 520 521 if (ctxconfig->robustness) 522 { 523 if (_glfw.glx.ARB_create_context_robustness) 524 { 525 if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION) 526 { 527 setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, 528 GLX_NO_RESET_NOTIFICATION_ARB); 529 } 530 else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET) 531 { 532 setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, 533 GLX_LOSE_CONTEXT_ON_RESET_ARB); 534 } 535 536 flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB; 537 } 538 } 539 540 if (ctxconfig->release) 541 { 542 if (_glfw.glx.ARB_context_flush_control) 543 { 544 if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE) 545 { 546 setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB, 547 GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB); 548 } 549 else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH) 550 { 551 setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB, 552 GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB); 553 } 554 } 555 } 556 557 if (ctxconfig->noerror) 558 { 559 if (_glfw.glx.ARB_create_context_no_error) 560 setAttrib(GLX_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE); 561 } 562 563 // NOTE: Only request an explicitly versioned context when necessary, as 564 // explicitly requesting version 1.0 does not always return the 565 // highest version supported by the driver 566 if (ctxconfig->major != 1 || ctxconfig->minor != 0) 567 { 568 setAttrib(GLX_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major); 569 setAttrib(GLX_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor); 570 } 571 572 if (mask) 573 setAttrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask); 574 575 if (flags) 576 setAttrib(GLX_CONTEXT_FLAGS_ARB, flags); 577 578 setAttrib(None, None); 579 580 window->context.glx.handle = 581 _glfw.glx.CreateContextAttribsARB(_glfw.x11.display, 582 native, 583 share, 584 True, 585 attribs); 586 587 // HACK: This is a fallback for broken versions of the Mesa 588 // implementation of GLX_ARB_create_context_profile that fail 589 // default 1.0 context creation with a GLXBadProfileARB error in 590 // violation of the extension spec 591 if (!window->context.glx.handle) 592 { 593 if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB && 594 ctxconfig->client == GLFW_OPENGL_API && 595 ctxconfig->profile == GLFW_OPENGL_ANY_PROFILE && 596 ctxconfig->forward == GLFW_FALSE) 597 { 598 window->context.glx.handle = 599 createLegacyContextGLX(window, native, share); 600 } 601 } 602 } 603 else 604 { 605 window->context.glx.handle = 606 createLegacyContextGLX(window, native, share); 607 } 608 609 _glfwReleaseErrorHandlerX11(); 610 611 if (!window->context.glx.handle) 612 { 613 _glfwInputErrorX11(GLFW_VERSION_UNAVAILABLE, "GLX: Failed to create context"); 614 return GLFW_FALSE; 615 } 616 617 window->context.glx.window = 618 glXCreateWindow(_glfw.x11.display, native, window->x11.handle, NULL); 619 if (!window->context.glx.window) 620 { 621 _glfwInputError(GLFW_PLATFORM_ERROR, "GLX: Failed to create window"); 622 return GLFW_FALSE; 623 } 624 625 window->context.makeCurrent = makeContextCurrentGLX; 626 window->context.swapBuffers = swapBuffersGLX; 627 window->context.swapInterval = swapIntervalGLX; 628 window->context.extensionSupported = extensionSupportedGLX; 629 window->context.getProcAddress = getProcAddressGLX; 630 window->context.destroy = destroyContextGLX; 631 632 return GLFW_TRUE; 633 } 634 635 #undef setAttrib 636 637 // Returns the Visual and depth of the chosen GLXFBConfig 638 // 639 GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig, 640 const _GLFWctxconfig* ctxconfig, 641 const _GLFWfbconfig* fbconfig, 642 Visual** visual, int* depth) 643 { 644 GLXFBConfig native; 645 XVisualInfo* result; 646 647 if (!chooseGLXFBConfig(fbconfig, &native)) 648 { 649 _glfwInputError(GLFW_FORMAT_UNAVAILABLE, 650 "GLX: Failed to find a suitable GLXFBConfig"); 651 return GLFW_FALSE; 652 } 653 654 result = glXGetVisualFromFBConfig(_glfw.x11.display, native); 655 if (!result) 656 { 657 _glfwInputError(GLFW_PLATFORM_ERROR, 658 "GLX: Failed to retrieve Visual for GLXFBConfig"); 659 return GLFW_FALSE; 660 } 661 662 *visual = result->visual; 663 *depth = result->depth; 664 665 XFree(result); 666 return GLFW_TRUE; 667 } 668 669 670 ////////////////////////////////////////////////////////////////////////// 671 ////// GLFW native API ////// 672 ////////////////////////////////////////////////////////////////////////// 673 674 GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle) 675 { 676 _GLFWwindow* window = (_GLFWwindow*) handle; 677 _GLFW_REQUIRE_INIT_OR_RETURN(NULL); 678 679 if (window->context.source != GLFW_NATIVE_CONTEXT_API) 680 { 681 _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL); 682 return NULL; 683 } 684 685 return window->context.glx.handle; 686 } 687 688 GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle) 689 { 690 _GLFWwindow* window = (_GLFWwindow*) handle; 691 _GLFW_REQUIRE_INIT_OR_RETURN(None); 692 693 if (window->context.source != GLFW_NATIVE_CONTEXT_API) 694 { 695 _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL); 696 return None; 697 } 698 699 return window->context.glx.window; 700 } 701