1 | //======================================================================== |
2 | // GLFW 3.4 GLX - www.glfw.org |
3 | //------------------------------------------------------------------------ |
4 | // Copyright (c) 2002-2006 Marcus Geelnard |
5 | // Copyright (c) 2006-2019 Camilla Löwy <[email protected]> |
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 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 = _glfw_calloc(nativeCount, sizeof(_GLFWfbconfig)); |
77 | usableCount = 0; |
78 | |
79 | for (int 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 | _glfw_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 _glfwPlatformGetModuleSymbol(_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 | const char* sonames[] = |
257 | { |
258 | #if defined(_GLFW_GLX_LIBRARY) |
259 | _GLFW_GLX_LIBRARY, |
260 | #elif defined(__CYGWIN__) |
261 | "libGL-1.so" , |
262 | #else |
263 | "libGL.so.1" , |
264 | "libGL.so" , |
265 | #endif |
266 | NULL |
267 | }; |
268 | |
269 | if (_glfw.glx.handle) |
270 | return GLFW_TRUE; |
271 | |
272 | for (int i = 0; sonames[i]; i++) |
273 | { |
274 | _glfw.glx.handle = _glfwPlatformLoadModule(sonames[i]); |
275 | if (_glfw.glx.handle) |
276 | break; |
277 | } |
278 | |
279 | if (!_glfw.glx.handle) |
280 | { |
281 | _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: Failed to load GLX" ); |
282 | return GLFW_FALSE; |
283 | } |
284 | |
285 | _glfw.glx.GetFBConfigs = (PFNGLXGETFBCONFIGSPROC) |
286 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXGetFBConfigs" ); |
287 | _glfw.glx.GetFBConfigAttrib = (PFNGLXGETFBCONFIGATTRIBPROC) |
288 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXGetFBConfigAttrib" ); |
289 | _glfw.glx.GetClientString = (PFNGLXGETCLIENTSTRINGPROC) |
290 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXGetClientString" ); |
291 | _glfw.glx.QueryExtension = (PFNGLXQUERYEXTENSIONPROC) |
292 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXQueryExtension" ); |
293 | _glfw.glx.QueryVersion = (PFNGLXQUERYVERSIONPROC) |
294 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXQueryVersion" ); |
295 | _glfw.glx.DestroyContext = (PFNGLXDESTROYCONTEXTPROC) |
296 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXDestroyContext" ); |
297 | _glfw.glx.MakeCurrent = (PFNGLXMAKECURRENTPROC) |
298 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXMakeCurrent" ); |
299 | _glfw.glx.SwapBuffers = (PFNGLXSWAPBUFFERSPROC) |
300 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXSwapBuffers" ); |
301 | _glfw.glx.QueryExtensionsString = (PFNGLXQUERYEXTENSIONSSTRINGPROC) |
302 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXQueryExtensionsString" ); |
303 | _glfw.glx.CreateNewContext = (PFNGLXCREATENEWCONTEXTPROC) |
304 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXCreateNewContext" ); |
305 | _glfw.glx.CreateWindow = (PFNGLXCREATEWINDOWPROC) |
306 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXCreateWindow" ); |
307 | _glfw.glx.DestroyWindow = (PFNGLXDESTROYWINDOWPROC) |
308 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXDestroyWindow" ); |
309 | _glfw.glx.GetProcAddress = (PFNGLXGETPROCADDRESSPROC) |
310 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXGetProcAddress" ); |
311 | _glfw.glx.GetProcAddressARB = (PFNGLXGETPROCADDRESSPROC) |
312 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXGetProcAddressARB" ); |
313 | _glfw.glx.GetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGPROC) |
314 | _glfwPlatformGetModuleSymbol(_glfw.glx.handle, "glXGetVisualFromFBConfig" ); |
315 | |
316 | if (!_glfw.glx.GetFBConfigs || |
317 | !_glfw.glx.GetFBConfigAttrib || |
318 | !_glfw.glx.GetClientString || |
319 | !_glfw.glx.QueryExtension || |
320 | !_glfw.glx.QueryVersion || |
321 | !_glfw.glx.DestroyContext || |
322 | !_glfw.glx.MakeCurrent || |
323 | !_glfw.glx.SwapBuffers || |
324 | !_glfw.glx.QueryExtensionsString || |
325 | !_glfw.glx.CreateNewContext || |
326 | !_glfw.glx.CreateWindow || |
327 | !_glfw.glx.DestroyWindow || |
328 | !_glfw.glx.GetProcAddress || |
329 | !_glfw.glx.GetProcAddressARB || |
330 | !_glfw.glx.GetVisualFromFBConfig) |
331 | { |
332 | _glfwInputError(GLFW_PLATFORM_ERROR, |
333 | "GLX: Failed to load required entry points" ); |
334 | return GLFW_FALSE; |
335 | } |
336 | |
337 | if (!glXQueryExtension(_glfw.x11.display, |
338 | &_glfw.glx.errorBase, |
339 | &_glfw.glx.eventBase)) |
340 | { |
341 | _glfwInputError(GLFW_API_UNAVAILABLE, "GLX: GLX extension not found" ); |
342 | return GLFW_FALSE; |
343 | } |
344 | |
345 | if (!glXQueryVersion(_glfw.x11.display, &_glfw.glx.major, &_glfw.glx.minor)) |
346 | { |
347 | _glfwInputError(GLFW_API_UNAVAILABLE, |
348 | "GLX: Failed to query GLX version" ); |
349 | return GLFW_FALSE; |
350 | } |
351 | |
352 | if (_glfw.glx.major == 1 && _glfw.glx.minor < 3) |
353 | { |
354 | _glfwInputError(GLFW_API_UNAVAILABLE, |
355 | "GLX: GLX version 1.3 is required" ); |
356 | return GLFW_FALSE; |
357 | } |
358 | |
359 | if (extensionSupportedGLX("GLX_EXT_swap_control" )) |
360 | { |
361 | _glfw.glx.SwapIntervalEXT = (PFNGLXSWAPINTERVALEXTPROC) |
362 | getProcAddressGLX("glXSwapIntervalEXT" ); |
363 | |
364 | if (_glfw.glx.SwapIntervalEXT) |
365 | _glfw.glx.EXT_swap_control = GLFW_TRUE; |
366 | } |
367 | |
368 | if (extensionSupportedGLX("GLX_SGI_swap_control" )) |
369 | { |
370 | _glfw.glx.SwapIntervalSGI = (PFNGLXSWAPINTERVALSGIPROC) |
371 | getProcAddressGLX("glXSwapIntervalSGI" ); |
372 | |
373 | if (_glfw.glx.SwapIntervalSGI) |
374 | _glfw.glx.SGI_swap_control = GLFW_TRUE; |
375 | } |
376 | |
377 | if (extensionSupportedGLX("GLX_MESA_swap_control" )) |
378 | { |
379 | _glfw.glx.SwapIntervalMESA = (PFNGLXSWAPINTERVALMESAPROC) |
380 | getProcAddressGLX("glXSwapIntervalMESA" ); |
381 | |
382 | if (_glfw.glx.SwapIntervalMESA) |
383 | _glfw.glx.MESA_swap_control = GLFW_TRUE; |
384 | } |
385 | |
386 | if (extensionSupportedGLX("GLX_ARB_multisample" )) |
387 | _glfw.glx.ARB_multisample = GLFW_TRUE; |
388 | |
389 | if (extensionSupportedGLX("GLX_ARB_framebuffer_sRGB" )) |
390 | _glfw.glx.ARB_framebuffer_sRGB = GLFW_TRUE; |
391 | |
392 | if (extensionSupportedGLX("GLX_EXT_framebuffer_sRGB" )) |
393 | _glfw.glx.EXT_framebuffer_sRGB = GLFW_TRUE; |
394 | |
395 | if (extensionSupportedGLX("GLX_ARB_create_context" )) |
396 | { |
397 | _glfw.glx.CreateContextAttribsARB = (PFNGLXCREATECONTEXTATTRIBSARBPROC) |
398 | getProcAddressGLX("glXCreateContextAttribsARB" ); |
399 | |
400 | if (_glfw.glx.CreateContextAttribsARB) |
401 | _glfw.glx.ARB_create_context = GLFW_TRUE; |
402 | } |
403 | |
404 | if (extensionSupportedGLX("GLX_ARB_create_context_robustness" )) |
405 | _glfw.glx.ARB_create_context_robustness = GLFW_TRUE; |
406 | |
407 | if (extensionSupportedGLX("GLX_ARB_create_context_profile" )) |
408 | _glfw.glx.ARB_create_context_profile = GLFW_TRUE; |
409 | |
410 | if (extensionSupportedGLX("GLX_EXT_create_context_es2_profile" )) |
411 | _glfw.glx.EXT_create_context_es2_profile = GLFW_TRUE; |
412 | |
413 | if (extensionSupportedGLX("GLX_ARB_create_context_no_error" )) |
414 | _glfw.glx.ARB_create_context_no_error = GLFW_TRUE; |
415 | |
416 | if (extensionSupportedGLX("GLX_ARB_context_flush_control" )) |
417 | _glfw.glx.ARB_context_flush_control = GLFW_TRUE; |
418 | |
419 | return GLFW_TRUE; |
420 | } |
421 | |
422 | // Terminate GLX |
423 | // |
424 | void _glfwTerminateGLX(void) |
425 | { |
426 | // NOTE: This function must not call any X11 functions, as it is called |
427 | // after XCloseDisplay (see _glfwTerminateX11 for details) |
428 | |
429 | if (_glfw.glx.handle) |
430 | { |
431 | _glfwPlatformFreeModule(_glfw.glx.handle); |
432 | _glfw.glx.handle = NULL; |
433 | } |
434 | } |
435 | |
436 | #define setAttrib(a, v) \ |
437 | { \ |
438 | assert(((size_t) index + 1) < sizeof(attribs) / sizeof(attribs[0])); \ |
439 | attribs[index++] = a; \ |
440 | attribs[index++] = v; \ |
441 | } |
442 | |
443 | // Create the OpenGL or OpenGL ES context |
444 | // |
445 | GLFWbool _glfwCreateContextGLX(_GLFWwindow* window, |
446 | const _GLFWctxconfig* ctxconfig, |
447 | const _GLFWfbconfig* fbconfig) |
448 | { |
449 | int attribs[40]; |
450 | GLXFBConfig native = NULL; |
451 | GLXContext share = NULL; |
452 | |
453 | if (ctxconfig->share) |
454 | share = ctxconfig->share->context.glx.handle; |
455 | |
456 | if (!chooseGLXFBConfig(fbconfig, &native)) |
457 | { |
458 | _glfwInputError(GLFW_FORMAT_UNAVAILABLE, |
459 | "GLX: Failed to find a suitable GLXFBConfig" ); |
460 | return GLFW_FALSE; |
461 | } |
462 | |
463 | if (ctxconfig->client == GLFW_OPENGL_ES_API) |
464 | { |
465 | if (!_glfw.glx.ARB_create_context || |
466 | !_glfw.glx.ARB_create_context_profile || |
467 | !_glfw.glx.EXT_create_context_es2_profile) |
468 | { |
469 | _glfwInputError(GLFW_API_UNAVAILABLE, |
470 | "GLX: OpenGL ES requested but GLX_EXT_create_context_es2_profile is unavailable" ); |
471 | return GLFW_FALSE; |
472 | } |
473 | } |
474 | |
475 | if (ctxconfig->forward) |
476 | { |
477 | if (!_glfw.glx.ARB_create_context) |
478 | { |
479 | _glfwInputError(GLFW_VERSION_UNAVAILABLE, |
480 | "GLX: Forward compatibility requested but GLX_ARB_create_context_profile is unavailable" ); |
481 | return GLFW_FALSE; |
482 | } |
483 | } |
484 | |
485 | if (ctxconfig->profile) |
486 | { |
487 | if (!_glfw.glx.ARB_create_context || |
488 | !_glfw.glx.ARB_create_context_profile) |
489 | { |
490 | _glfwInputError(GLFW_VERSION_UNAVAILABLE, |
491 | "GLX: An OpenGL profile requested but GLX_ARB_create_context_profile is unavailable" ); |
492 | return GLFW_FALSE; |
493 | } |
494 | } |
495 | |
496 | _glfwGrabErrorHandlerX11(); |
497 | |
498 | if (_glfw.glx.ARB_create_context) |
499 | { |
500 | int index = 0, mask = 0, flags = 0; |
501 | |
502 | if (ctxconfig->client == GLFW_OPENGL_API) |
503 | { |
504 | if (ctxconfig->forward) |
505 | flags |= GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB; |
506 | |
507 | if (ctxconfig->profile == GLFW_OPENGL_CORE_PROFILE) |
508 | mask |= GLX_CONTEXT_CORE_PROFILE_BIT_ARB; |
509 | else if (ctxconfig->profile == GLFW_OPENGL_COMPAT_PROFILE) |
510 | mask |= GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB; |
511 | } |
512 | else |
513 | mask |= GLX_CONTEXT_ES2_PROFILE_BIT_EXT; |
514 | |
515 | if (ctxconfig->debug) |
516 | flags |= GLX_CONTEXT_DEBUG_BIT_ARB; |
517 | |
518 | if (ctxconfig->robustness) |
519 | { |
520 | if (_glfw.glx.ARB_create_context_robustness) |
521 | { |
522 | if (ctxconfig->robustness == GLFW_NO_RESET_NOTIFICATION) |
523 | { |
524 | setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, |
525 | GLX_NO_RESET_NOTIFICATION_ARB); |
526 | } |
527 | else if (ctxconfig->robustness == GLFW_LOSE_CONTEXT_ON_RESET) |
528 | { |
529 | setAttrib(GLX_CONTEXT_RESET_NOTIFICATION_STRATEGY_ARB, |
530 | GLX_LOSE_CONTEXT_ON_RESET_ARB); |
531 | } |
532 | |
533 | flags |= GLX_CONTEXT_ROBUST_ACCESS_BIT_ARB; |
534 | } |
535 | } |
536 | |
537 | if (ctxconfig->release) |
538 | { |
539 | if (_glfw.glx.ARB_context_flush_control) |
540 | { |
541 | if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_NONE) |
542 | { |
543 | setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB, |
544 | GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB); |
545 | } |
546 | else if (ctxconfig->release == GLFW_RELEASE_BEHAVIOR_FLUSH) |
547 | { |
548 | setAttrib(GLX_CONTEXT_RELEASE_BEHAVIOR_ARB, |
549 | GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB); |
550 | } |
551 | } |
552 | } |
553 | |
554 | if (ctxconfig->noerror) |
555 | { |
556 | if (_glfw.glx.ARB_create_context_no_error) |
557 | setAttrib(GLX_CONTEXT_OPENGL_NO_ERROR_ARB, GLFW_TRUE); |
558 | } |
559 | |
560 | // NOTE: Only request an explicitly versioned context when necessary, as |
561 | // explicitly requesting version 1.0 does not always return the |
562 | // highest version supported by the driver |
563 | if (ctxconfig->major != 1 || ctxconfig->minor != 0) |
564 | { |
565 | setAttrib(GLX_CONTEXT_MAJOR_VERSION_ARB, ctxconfig->major); |
566 | setAttrib(GLX_CONTEXT_MINOR_VERSION_ARB, ctxconfig->minor); |
567 | } |
568 | |
569 | if (mask) |
570 | setAttrib(GLX_CONTEXT_PROFILE_MASK_ARB, mask); |
571 | |
572 | if (flags) |
573 | setAttrib(GLX_CONTEXT_FLAGS_ARB, flags); |
574 | |
575 | setAttrib(None, None); |
576 | |
577 | window->context.glx.handle = |
578 | _glfw.glx.CreateContextAttribsARB(_glfw.x11.display, |
579 | native, |
580 | share, |
581 | True, |
582 | attribs); |
583 | |
584 | // HACK: This is a fallback for broken versions of the Mesa |
585 | // implementation of GLX_ARB_create_context_profile that fail |
586 | // default 1.0 context creation with a GLXBadProfileARB error in |
587 | // violation of the extension spec |
588 | if (!window->context.glx.handle) |
589 | { |
590 | if (_glfw.x11.errorCode == _glfw.glx.errorBase + GLXBadProfileARB && |
591 | ctxconfig->client == GLFW_OPENGL_API && |
592 | ctxconfig->profile == GLFW_OPENGL_ANY_PROFILE && |
593 | ctxconfig->forward == GLFW_FALSE) |
594 | { |
595 | window->context.glx.handle = |
596 | createLegacyContextGLX(window, native, share); |
597 | } |
598 | } |
599 | } |
600 | else |
601 | { |
602 | window->context.glx.handle = |
603 | createLegacyContextGLX(window, native, share); |
604 | } |
605 | |
606 | _glfwReleaseErrorHandlerX11(); |
607 | |
608 | if (!window->context.glx.handle) |
609 | { |
610 | _glfwInputErrorX11(GLFW_VERSION_UNAVAILABLE, "GLX: Failed to create context" ); |
611 | return GLFW_FALSE; |
612 | } |
613 | |
614 | window->context.glx.window = |
615 | glXCreateWindow(_glfw.x11.display, native, window->x11.handle, NULL); |
616 | if (!window->context.glx.window) |
617 | { |
618 | _glfwInputError(GLFW_PLATFORM_ERROR, "GLX: Failed to create window" ); |
619 | return GLFW_FALSE; |
620 | } |
621 | |
622 | window->context.makeCurrent = makeContextCurrentGLX; |
623 | window->context.swapBuffers = swapBuffersGLX; |
624 | window->context.swapInterval = swapIntervalGLX; |
625 | window->context.extensionSupported = extensionSupportedGLX; |
626 | window->context.getProcAddress = getProcAddressGLX; |
627 | window->context.destroy = destroyContextGLX; |
628 | |
629 | return GLFW_TRUE; |
630 | } |
631 | |
632 | #undef setAttrib |
633 | |
634 | // Returns the Visual and depth of the chosen GLXFBConfig |
635 | // |
636 | GLFWbool _glfwChooseVisualGLX(const _GLFWwndconfig* wndconfig, |
637 | const _GLFWctxconfig* ctxconfig, |
638 | const _GLFWfbconfig* fbconfig, |
639 | Visual** visual, int* depth) |
640 | { |
641 | GLXFBConfig native; |
642 | XVisualInfo* result; |
643 | |
644 | if (!chooseGLXFBConfig(fbconfig, &native)) |
645 | { |
646 | _glfwInputError(GLFW_FORMAT_UNAVAILABLE, |
647 | "GLX: Failed to find a suitable GLXFBConfig" ); |
648 | return GLFW_FALSE; |
649 | } |
650 | |
651 | result = glXGetVisualFromFBConfig(_glfw.x11.display, native); |
652 | if (!result) |
653 | { |
654 | _glfwInputError(GLFW_PLATFORM_ERROR, |
655 | "GLX: Failed to retrieve Visual for GLXFBConfig" ); |
656 | return GLFW_FALSE; |
657 | } |
658 | |
659 | *visual = result->visual; |
660 | *depth = result->depth; |
661 | |
662 | XFree(result); |
663 | return GLFW_TRUE; |
664 | } |
665 | |
666 | |
667 | ////////////////////////////////////////////////////////////////////////// |
668 | ////// GLFW native API ////// |
669 | ////////////////////////////////////////////////////////////////////////// |
670 | |
671 | GLFWAPI GLXContext glfwGetGLXContext(GLFWwindow* handle) |
672 | { |
673 | _GLFWwindow* window = (_GLFWwindow*) handle; |
674 | _GLFW_REQUIRE_INIT_OR_RETURN(NULL); |
675 | |
676 | if (_glfw.platform.platformID != GLFW_PLATFORM_X11) |
677 | { |
678 | _glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "GLX: Platform not initialized" ); |
679 | return NULL; |
680 | } |
681 | |
682 | if (window->context.source != GLFW_NATIVE_CONTEXT_API) |
683 | { |
684 | _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL); |
685 | return NULL; |
686 | } |
687 | |
688 | return window->context.glx.handle; |
689 | } |
690 | |
691 | GLFWAPI GLXWindow glfwGetGLXWindow(GLFWwindow* handle) |
692 | { |
693 | _GLFWwindow* window = (_GLFWwindow*) handle; |
694 | _GLFW_REQUIRE_INIT_OR_RETURN(None); |
695 | |
696 | if (_glfw.platform.platformID != GLFW_PLATFORM_X11) |
697 | { |
698 | _glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "GLX: Platform not initialized" ); |
699 | return None; |
700 | } |
701 | |
702 | if (window->context.source != GLFW_NATIVE_CONTEXT_API) |
703 | { |
704 | _glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL); |
705 | return None; |
706 | } |
707 | |
708 | return window->context.glx.window; |
709 | } |
710 | |
711 | |