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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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
, 24, GLX_STENCIL_SIZE
, 8, GLX_ALPHA_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 16 bits depth, no alpha */
565 int dblBuf2
[] = {GLX_RGBA
,GLX_DEPTH_SIZE
, 16, GLX_STENCIL_SIZE
, 8, GLX_DOUBLEBUFFER
, None
};
566 WARN("Failed to get a visual with at least 24 bits depth\n");
569 visual
= pglXChooseVisual(display
, DefaultScreen(display
), dblBuf2
);
571 if (visual
== NULL
) {
572 /* fallback to no stencil */
573 int dblBuf2
[] = {GLX_RGBA
,GLX_DEPTH_SIZE
, 16, GLX_DOUBLEBUFFER
, None
};
574 WARN("Failed to get a visual with at least 8 bits of stencil\n");
577 visual
= pglXChooseVisual(display
, DefaultScreen(display
), dblBuf2
);
579 if (visual
== NULL
) {
580 /* This should only happen if we cannot find a match with a depth size 16 */
581 FIXME("Failed to find a suitable visual\n");
586 TRACE("Visual ID %lx Chosen\n",visual
->visualid
);
590 XID
create_glxpixmap(X11DRV_PDEVICE
*physDev
)
594 XVisualInfo
template;
599 cfgs
= pglXGetFBConfigs(gdi_display
, DefaultScreen(gdi_display
), &num
);
600 pglXGetFBConfigAttrib(gdi_display
, cfgs
[physDev
->current_pf
- 1], GLX_VISUAL_ID
, (int *)&template.visualid
);
602 vis
= XGetVisualInfo(gdi_display
, VisualIDMask
, &template, &num
);
604 ret
= pglXCreateGLXPixmap(gdi_display
, vis
, physDev
->bitmap
->pixmap
);
608 TRACE("return %lx\n", ret
);
612 BOOL
destroy_glxpixmap(XID glxpixmap
)
615 pglXDestroyGLXPixmap(gdi_display
, glxpixmap
);
620 #else /* no OpenGL includes */
622 void X11DRV_OpenGL_Init(Display
*display
)
626 /***********************************************************************
627 * ChoosePixelFormat (X11DRV.@)
629 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE
*physDev
,
630 const PIXELFORMATDESCRIPTOR
*ppfd
) {
631 ERR("No OpenGL support compiled in.\n");
636 /***********************************************************************
637 * DescribePixelFormat (X11DRV.@)
639 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE
*physDev
,
642 PIXELFORMATDESCRIPTOR
*ppfd
) {
643 ERR("No OpenGL support compiled in.\n");
648 /***********************************************************************
649 * GetPixelFormat (X11DRV.@)
651 int X11DRV_GetPixelFormat(X11DRV_PDEVICE
*physDev
) {
652 ERR("No OpenGL support compiled in.\n");
657 /***********************************************************************
658 * SetPixelFormat (X11DRV.@)
660 BOOL
X11DRV_SetPixelFormat(X11DRV_PDEVICE
*physDev
,
662 const PIXELFORMATDESCRIPTOR
*ppfd
) {
663 ERR("No OpenGL support compiled in.\n");
668 /***********************************************************************
669 * SwapBuffers (X11DRV.@)
671 BOOL
X11DRV_SwapBuffers(X11DRV_PDEVICE
*physDev
) {
672 ERR_(opengl
)("No OpenGL support compiled in.\n");
677 XVisualInfo
*X11DRV_setup_opengl_visual( Display
*display
)
682 XID
create_glxpixmap(X11DRV_PDEVICE
*physDev
)
687 BOOL
destroy_glxpixmap(XID glxpixmap
)
692 #endif /* defined(HAVE_OPENGL) */