2 * X11DRV OpenGL functions
4 * Copyright 2000 Lionel Ulmer
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
28 #include "wine/library.h"
29 #include "wine/debug.h"
31 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
32 WINE_DECLARE_DEBUG_CHANNEL(opengl);
34 #if defined(HAVE_GL_GL_H) && defined(HAVE_GL_GLX_H)
46 #ifdef HAVE_GL_GLEXT_H
47 # include <GL/glext.h>
54 /* Redefines the constants */
55 #define CALLBACK __stdcall
56 #define WINAPI __stdcall
57 #define APIENTRY WINAPI
60 static void dump_PIXELFORMATDESCRIPTOR(const PIXELFORMATDESCRIPTOR *ppfd) {
61 TRACE(" - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
62 TRACE(" - dwFlags : ");
63 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) TRACE(#tv " ")
64 TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
65 TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
66 TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
67 TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
68 TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
69 TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
70 TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
71 TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
72 TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
73 TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
74 TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
75 TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
76 TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
77 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
78 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
79 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
83 TRACE(" - iPixelType : ");
84 switch (ppfd->iPixelType) {
85 case PFD_TYPE_RGBA: TRACE("PFD_TYPE_RGBA"); break;
86 case PFD_TYPE_COLORINDEX: TRACE("PFD_TYPE_COLORINDEX"); break;
90 TRACE(" - Color : %d\n", ppfd->cColorBits);
91 TRACE(" - Red : %d\n", ppfd->cRedBits);
92 TRACE(" - Green : %d\n", ppfd->cGreenBits);
93 TRACE(" - Blue : %d\n", ppfd->cBlueBits);
94 TRACE(" - Alpha : %d\n", ppfd->cAlphaBits);
95 TRACE(" - Accum : %d\n", ppfd->cAccumBits);
96 TRACE(" - Depth : %d\n", ppfd->cDepthBits);
97 TRACE(" - Stencil : %d\n", ppfd->cStencilBits);
98 TRACE(" - Aux : %d\n", ppfd->cAuxBuffers);
100 TRACE(" - iLayerType : ");
101 switch (ppfd->iLayerType) {
102 case PFD_MAIN_PLANE: TRACE("PFD_MAIN_PLANE"); break;
103 case PFD_OVERLAY_PLANE: TRACE("PFD_OVERLAY_PLANE"); break;
104 case (BYTE)PFD_UNDERLAY_PLANE: TRACE("PFD_UNDERLAY_PLANE"); break;
109 /* No need to load any other libraries as according to the ABI, libGL should be self-sufficient and
110 include all dependencies
113 #define SONAME_LIBGL "libGL.so"
116 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
117 MAKE_FUNCPTR(glGetError)
118 MAKE_FUNCPTR(glXChooseVisual)
119 MAKE_FUNCPTR(glXGetConfig)
120 MAKE_FUNCPTR(glXSwapBuffers)
121 MAKE_FUNCPTR(glXQueryExtension)
123 MAKE_FUNCPTR(glXGetFBConfigs)
124 MAKE_FUNCPTR(glXChooseFBConfig)
125 MAKE_FUNCPTR(glXGetFBConfigAttrib)
126 MAKE_FUNCPTR(glXCreateGLXPixmap)
127 MAKE_FUNCPTR(glXDestroyGLXPixmap)
128 /* MAKE_FUNCPTR(glXQueryDrawable) */
131 static BOOL has_opengl(void)
133 static int init_done;
134 static void *opengl_handle;
136 int error_base, event_base;
138 if (init_done) return (opengl_handle != NULL);
141 opengl_handle = wine_dlopen(SONAME_LIBGL, RTLD_NOW|RTLD_GLOBAL, NULL, 0);
142 if (opengl_handle == NULL) return FALSE;
144 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(RTLD_DEFAULT, #f, NULL, 0)) == NULL) goto sym_not_found;
145 LOAD_FUNCPTR(glGetError)
146 LOAD_FUNCPTR(glXChooseVisual)
147 LOAD_FUNCPTR(glXGetConfig)
148 LOAD_FUNCPTR(glXSwapBuffers)
149 LOAD_FUNCPTR(glXQueryExtension)
151 LOAD_FUNCPTR(glXGetFBConfigs)
152 LOAD_FUNCPTR(glXChooseFBConfig)
153 LOAD_FUNCPTR(glXGetFBConfigAttrib)
154 LOAD_FUNCPTR(glXCreateGLXPixmap)
155 LOAD_FUNCPTR(glXDestroyGLXPixmap)
159 if (pglXQueryExtension(gdi_display, &event_base, &error_base) == True) {
160 TRACE("GLX is up and running error_base = %d\n", error_base);
162 wine_dlclose(opengl_handle, NULL, 0);
163 opengl_handle = NULL;
166 return (opengl_handle != NULL);
169 wine_dlclose(opengl_handle, NULL, 0);
170 opengl_handle = NULL;
174 #define TEST_AND_ADD1(t,a) if (t) att_list[att_pos++] = (a)
175 #define TEST_AND_ADD2(t,a,b) if (t) { att_list[att_pos++] = (a); att_list[att_pos++] = (b); }
176 #define NULL_TEST_AND_ADD2(tv,a,b) att_list[att_pos++] = (a); att_list[att_pos++] = ((tv) == 0 ? 0 : (b))
177 #define ADD2(a,b) att_list[att_pos++] = (a); att_list[att_pos++] = (b)
180 * X11DRV_ChoosePixelFormat
182 * Equivalent of glXChooseVisual
184 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
185 const PIXELFORMATDESCRIPTOR *ppfd) {
189 GLXFBConfig* cfgs = NULL;
193 ERR("No libGL on this box - disabling OpenGL support !\n");
197 if (TRACE_ON(opengl)) {
198 TRACE("(%p,%p)\n", physDev, ppfd);
200 dump_PIXELFORMATDESCRIPTOR((const PIXELFORMATDESCRIPTOR *) ppfd);
203 /* Now, build the request to GLX */
205 if (ppfd->iPixelType == PFD_TYPE_COLORINDEX) {
206 ADD2(GLX_BUFFER_SIZE, ppfd->cColorBits);
208 if (ppfd->iPixelType == PFD_TYPE_RGBA) {
209 ADD2(GLX_RENDER_TYPE, GLX_RGBA_BIT);
210 if (ppfd->dwFlags & PFD_DEPTH_DONTCARE) {
211 ADD2(GLX_DEPTH_SIZE, GLX_DONT_CARE);
213 if (32 == ppfd->cDepthBits) {
215 * for 32 bpp depth buffers force to use 24.
216 * needed as some drivers don't support 32bpp
218 TEST_AND_ADD2(ppfd->cDepthBits, GLX_DEPTH_SIZE, 24);
220 TEST_AND_ADD2(ppfd->cDepthBits, GLX_DEPTH_SIZE, ppfd->cDepthBits);
223 if (32 == ppfd->cColorBits) {
224 ADD2(GLX_RED_SIZE, 8);
225 ADD2(GLX_GREEN_SIZE, 8);
226 ADD2(GLX_BLUE_SIZE, 8);
227 ADD2(GLX_ALPHA_SIZE, 8);
229 ADD2(GLX_BUFFER_SIZE, ppfd->cColorBits);
230 /* Some broken apps try to ask for more than 8 bits of alpha */
231 TEST_AND_ADD2(ppfd->cAlphaBits, GLX_ALPHA_SIZE, min(ppfd->cAlphaBits,8));
234 TEST_AND_ADD2(ppfd->cStencilBits, GLX_STENCIL_SIZE, ppfd->cStencilBits);
235 TEST_AND_ADD2(ppfd->cAuxBuffers, GLX_AUX_BUFFERS, ppfd->cAuxBuffers);
237 /* These flags are not supported yet...
238 ADD2(GLX_ACCUM_SIZE, ppfd->cAccumBits);
241 /** facultative flags now */
242 att_pos_fac = att_pos;
243 if (ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) {
244 ADD2(GLX_DOUBLEBUFFER, GLX_DONT_CARE);
246 ADD2(GLX_DOUBLEBUFFER, (ppfd->dwFlags & PFD_DOUBLEBUFFER) ? TRUE : FALSE);
248 if (ppfd->dwFlags & PFD_STEREO_DONTCARE) {
249 ADD2(GLX_STEREO, GLX_DONT_CARE);
251 ADD2(GLX_STEREO, (ppfd->dwFlags & PFD_STEREO) ? TRUE : FALSE);
254 /** Attributes List End */
255 att_list[att_pos] = None;
263 GLXFBConfig* cfgs_fmt = NULL;
268 cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), att_list, &nCfgs);
270 * if we have facultative flags and we failed, try without
273 * see http://msdn.microsoft.com/library/default.asp?url=/library/en-us/opengl/ntopnglr_2qb8.asp
275 if ((NULL == cfgs || 0 == nCfgs) && att_pos > att_pos_fac) {
276 att_list[att_pos_fac] = None;
277 cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), att_list, &nCfgs);
280 if (NULL == cfgs || 0 == nCfgs) {
281 ERR("glXChooseFBConfig returns NULL (glError: %d)\n", pglGetError());
286 gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs[0], GLX_FBCONFIG_ID, &fmt_id);
288 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
293 cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
294 if (NULL == cfgs_fmt) {
295 ERR("Failed to get All FB Configs\n");
300 for (it_fmt = 0; it_fmt < nCfgs_fmt; ++it_fmt) {
301 gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs_fmt[it_fmt], GLX_FBCONFIG_ID, &tmp_fmt_id);
303 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
308 if (fmt_id == tmp_fmt_id) {
313 if (it_fmt == nCfgs_fmt) {
314 ERR("Failed to get valid fmt for FBCONFIG_ID(%d)\n", fmt_id);
321 if (NULL != cfgs) XFree(cfgs);
327 * X11DRV_DescribePixelFormat
329 * Get the pixel-format descriptor associated to the given id
331 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
334 PIXELFORMATDESCRIPTOR *ppfd) {
335 /*XVisualInfo *vis;*/
339 GLXFBConfig* cfgs = NULL;
345 ERR("No libGL on this box - disabling OpenGL support !\n");
349 TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
352 cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs);
355 if (NULL == cfgs || 0 == nCfgs) {
356 ERR("unexpected iPixelFormat(%d), returns NULL\n", iPixelFormat);
357 return 0; /* unespected error */
361 /* The application is only querying the number of visuals */
363 if (NULL != cfgs) XFree(cfgs);
368 if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
369 ERR("Wrong structure size !\n");
370 /* Should set error */
374 if (nCfgs < iPixelFormat || 1 > iPixelFormat) {
375 WARN("unexpected iPixelFormat(%d): not >=1 and <=nFormats(%d), returning NULL\n", iPixelFormat, nCfgs);
380 cur = cfgs[iPixelFormat - 1];
382 memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
383 ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
386 /* These flags are always the same... */
387 ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
388 /* Now the flags extracted from the Visual */
392 pglXGetFBConfigAttrib(gdi_display, cur, GLX_CONFIG_CAVEAT, &value);
393 if(value == GLX_SLOW_CONFIG)
394 ppfd->dwFlags |= PFD_GENERIC_ACCELERATED;
396 pglXGetFBConfigAttrib(gdi_display, cur, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
397 pglXGetFBConfigAttrib(gdi_display, cur, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
400 pglXGetFBConfigAttrib(gdi_display, cur, GLX_RENDER_TYPE, &value);
401 if (value & GLX_RGBA_BIT)
402 ppfd->iPixelType = PFD_TYPE_RGBA;
404 ppfd->iPixelType = PFD_TYPE_COLORINDEX;
407 pglXGetFBConfigAttrib(gdi_display, cur, GLX_BUFFER_SIZE, &value);
408 ppfd->cColorBits = value;
410 /* Red, green, blue and alpha bits / shifts */
411 if (ppfd->iPixelType == PFD_TYPE_RGBA) {
412 pglXGetFBConfigAttrib(gdi_display, cur, GLX_RED_SIZE, &rb);
413 pglXGetFBConfigAttrib(gdi_display, cur, GLX_GREEN_SIZE, &gb);
414 pglXGetFBConfigAttrib(gdi_display, cur, GLX_BLUE_SIZE, &bb);
415 pglXGetFBConfigAttrib(gdi_display, cur, GLX_ALPHA_SIZE, &ab);
418 ppfd->cRedShift = gb + bb + ab;
419 ppfd->cBlueBits = bb;
420 ppfd->cBlueShift = ab;
421 ppfd->cGreenBits = gb;
422 ppfd->cGreenShift = bb + ab;
423 ppfd->cAlphaBits = ab;
424 ppfd->cAlphaShift = 0;
429 ppfd->cBlueShift = 0;
430 ppfd->cGreenBits = 0;
431 ppfd->cGreenShift = 0;
432 ppfd->cAlphaBits = 0;
433 ppfd->cAlphaShift = 0;
435 /* Accums : to do ... */
438 pglXGetFBConfigAttrib(gdi_display, cur, GLX_DEPTH_SIZE, &value);
439 ppfd->cDepthBits = value;
442 pglXGetFBConfigAttrib(gdi_display, cur, GLX_STENCIL_SIZE, &value);
443 ppfd->cStencilBits = value;
447 /* Aux : to do ... */
449 ppfd->iLayerType = PFD_MAIN_PLANE;
451 if (TRACE_ON(opengl)) {
452 dump_PIXELFORMATDESCRIPTOR(ppfd);
456 if (NULL != cfgs) XFree(cfgs);
463 * X11DRV_GetPixelFormat
465 * Get the pixel-format id used by this DC
467 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
468 TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
470 return physDev->current_pf;
474 * X11DRV_SetPixelFormat
476 * Set the pixel-format id used by this DC
478 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
480 const PIXELFORMATDESCRIPTOR *ppfd) {
481 TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
483 physDev->current_pf = iPixelFormat;
485 if (TRACE_ON(opengl)) {
487 GLXFBConfig* cfgs_fmt = NULL;
493 * How to test if hdc current drawable is compatible (visual/FBConfig) ?
495 * in case of root window created HDCs we crash here :(
497 Drawable drawable = get_drawable( physDev->hdc );
498 TRACE(" drawable (%p,%p) have :\n", drawable, root_window);
499 pglXQueryDrawable(gdi_display, drawable, GLX_FBCONFIG_ID, (unsigned int*) &value);
500 TRACE(" - FBCONFIG_ID as 0x%x\n", tmp);
501 pglXQueryDrawable(gdi_display, drawable, GLX_VISUAL_ID, (unsigned int*) &value);
502 TRACE(" - VISUAL_ID as 0x%x\n", tmp);
503 pglXQueryDrawable(gdi_display, drawable, GLX_WIDTH, (unsigned int*) &value);
504 TRACE(" - WIDTH as %d\n", tmp);
505 pglXQueryDrawable(gdi_display, drawable, GLX_HEIGHT, (unsigned int*) &value);
506 TRACE(" - HEIGHT as %d\n", tmp);
508 cfgs_fmt = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &nCfgs_fmt);
509 cur_cfg = cfgs_fmt[iPixelFormat - 1];
510 gl_test = pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_FBCONFIG_ID, &value);
512 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
514 TRACE(" FBConfig have :\n");
515 TRACE(" - FBCONFIG_ID 0x%x\n", value);
516 pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_VISUAL_ID, &value);
517 TRACE(" - VISUAL_ID 0x%x\n", value);
518 pglXGetFBConfigAttrib(gdi_display, cur_cfg, GLX_DRAWABLE_TYPE, &value);
519 TRACE(" - DRAWABLE_TYPE 0x%x\n", value);
529 * Swap the buffers of this DC
531 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
533 ERR("No libGL on this box - disabling OpenGL support !\n");
537 TRACE_(opengl)("(%p)\n", physDev);
540 pglXSwapBuffers(gdi_display, physDev->drawable);
546 /***********************************************************************
547 * X11DRV_setup_opengl_visual
549 * Setup the default visual used for OpenGL and Direct3D, and the desktop
550 * window (if it exists). If OpenGL isn't available, the visual is simply
551 * set to the default visual for the display
553 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
555 XVisualInfo *visual = NULL;
556 /* In order to support OpenGL or D3D, we require a double-buffered visual and stencil buffer support, */
557 int dblBuf[] = {GLX_RGBA,GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, GLX_DOUBLEBUFFER, None};
558 if (!has_opengl()) return NULL;
561 visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf);
563 if (visual == NULL) {
564 /* fallback to no stencil */
565 int dblBuf2[] = {GLX_RGBA,GLX_DEPTH_SIZE, 16, GLX_DOUBLEBUFFER, None};
566 WARN("Failed to get a visual with at least 8 bits of stencil\n");
569 visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf2);
571 if (visual == NULL) {
572 /* This should only happen if we cannot find a match with a depth size 16 */
573 FIXME("Failed to find a suitable visual\n");
577 TRACE("Visual ID %lx Chosen\n",visual->visualid);
581 XID create_glxpixmap(X11DRV_PDEVICE *physDev)
585 XVisualInfo template;
590 cfgs = pglXGetFBConfigs(gdi_display, DefaultScreen(gdi_display), &num);
591 pglXGetFBConfigAttrib(gdi_display, cfgs[physDev->current_pf - 1], GLX_VISUAL_ID, (int *)&template.visualid);
593 vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
595 ret = pglXCreateGLXPixmap(gdi_display, vis, physDev->bitmap->pixmap);
599 TRACE("return %lx\n", ret);
603 BOOL destroy_glxpixmap(XID glxpixmap)
606 pglXDestroyGLXPixmap(gdi_display, glxpixmap);
611 #else /* no OpenGL includes */
613 void X11DRV_OpenGL_Init(Display *display)
617 /***********************************************************************
618 * ChoosePixelFormat (X11DRV.@)
620 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
621 const PIXELFORMATDESCRIPTOR *ppfd) {
622 ERR("No OpenGL support compiled in.\n");
627 /***********************************************************************
628 * DescribePixelFormat (X11DRV.@)
630 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
633 PIXELFORMATDESCRIPTOR *ppfd) {
634 ERR("No OpenGL support compiled in.\n");
639 /***********************************************************************
640 * GetPixelFormat (X11DRV.@)
642 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
643 ERR("No OpenGL support compiled in.\n");
648 /***********************************************************************
649 * SetPixelFormat (X11DRV.@)
651 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
653 const PIXELFORMATDESCRIPTOR *ppfd) {
654 ERR("No OpenGL support compiled in.\n");
659 /***********************************************************************
660 * SwapBuffers (X11DRV.@)
662 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
663 ERR_(opengl)("No OpenGL support compiled in.\n");
668 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
673 XID create_glxpixmap(X11DRV_PDEVICE *physDev)
678 BOOL destroy_glxpixmap(XID glxpixmap)
683 #endif /* defined(HAVE_OPENGL) */