2 * X11DRV OpenGL functions
4 * Copyright 2000 Lionel Ulmer
5 * Copyright 2005 Alex Woods
6 * Copyright 2005 Raphael Junqueira
7 * Copyright 2006 Roderick Colenbrander
8 * Copyright 2006 Tomas Carnecky
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
26 #include "wine/port.h"
34 #include "wine/library.h"
35 #include "wine/debug.h"
37 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
38 WINE_DECLARE_DEBUG_CHANNEL(opengl);
52 #ifdef HAVE_GL_GLEXT_H
53 # include <GL/glext.h>
62 /* Redefines the constants */
63 #define CALLBACK __stdcall
64 #define WINAPI __stdcall
65 #define APIENTRY WINAPI
68 WINE_DECLARE_DEBUG_CHANNEL(fps);
70 typedef struct wine_glextension {
79 const char *glVersion;
80 const char *glExtensions;
84 const char *glxServerVersion;
85 const char *glxServerExtensions;
87 const char *glxClientVersion;
88 const char *glxClientExtensions;
90 const char *glxExtensions;
93 char wglExtensions[4096];
96 typedef struct wine_glpixelformat {
104 typedef struct wine_glcontext {
107 WineGLPixelFormat *fmt;
110 X11DRV_PDEVICE *physDev;
113 BOOL scissor_enabled;
114 struct wine_glcontext *next;
115 struct wine_glcontext *prev;
118 typedef struct wine_glpbuffer {
121 WineGLPixelFormat* fmt;
127 int use_render_texture; /* This is also the internal texture format */
128 int texture_bind_target;
130 GLint texture_format;
131 GLuint texture_target;
137 static Wine_GLContext *context_list;
138 static struct WineGLInfo WineGLInfo = { 0 };
139 static int use_render_texture_emulation = 1;
140 static int use_render_texture_ati = 0;
141 static int swap_interval = 1;
143 #define MAX_EXTENSIONS 16
144 static const WineGLExtension *WineGLExtensionList[MAX_EXTENSIONS];
145 static int WineGLExtensionListSize;
147 static WineGLPixelFormat *WineGLPixelFormatList;
148 static int WineGLPixelFormatListSize = 0;
150 static void X11DRV_WineGL_LoadExtensions(void);
152 static void dump_PIXELFORMATDESCRIPTOR(const PIXELFORMATDESCRIPTOR *ppfd) {
153 TRACE(" - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
154 TRACE(" - dwFlags : ");
155 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) TRACE(#tv " ")
156 TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
157 TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
158 TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
159 TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
160 TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
161 TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
162 TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
163 TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
164 TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
165 TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
166 TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
167 TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
168 TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
169 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
170 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
171 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
175 TRACE(" - iPixelType : ");
176 switch (ppfd->iPixelType) {
177 case PFD_TYPE_RGBA: TRACE("PFD_TYPE_RGBA"); break;
178 case PFD_TYPE_COLORINDEX: TRACE("PFD_TYPE_COLORINDEX"); break;
182 TRACE(" - Color : %d\n", ppfd->cColorBits);
183 TRACE(" - Red : %d\n", ppfd->cRedBits);
184 TRACE(" - Green : %d\n", ppfd->cGreenBits);
185 TRACE(" - Blue : %d\n", ppfd->cBlueBits);
186 TRACE(" - Alpha : %d\n", ppfd->cAlphaBits);
187 TRACE(" - Accum : %d\n", ppfd->cAccumBits);
188 TRACE(" - Depth : %d\n", ppfd->cDepthBits);
189 TRACE(" - Stencil : %d\n", ppfd->cStencilBits);
190 TRACE(" - Aux : %d\n", ppfd->cAuxBuffers);
192 TRACE(" - iLayerType : ");
193 switch (ppfd->iLayerType) {
194 case PFD_MAIN_PLANE: TRACE("PFD_MAIN_PLANE"); break;
195 case PFD_OVERLAY_PLANE: TRACE("PFD_OVERLAY_PLANE"); break;
196 case (BYTE)PFD_UNDERLAY_PLANE: TRACE("PFD_UNDERLAY_PLANE"); break;
201 #define PUSH1(attribs,att) do { attribs[nAttribs++] = (att); } while (0)
202 #define PUSH2(attribs,att,value) do { attribs[nAttribs++] = (att); attribs[nAttribs++] = (value); } while(0)
204 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
206 MAKE_FUNCPTR(glXChooseVisual)
207 MAKE_FUNCPTR(glXCreateContext)
208 MAKE_FUNCPTR(glXCreateGLXPixmap)
209 MAKE_FUNCPTR(glXGetCurrentContext)
210 MAKE_FUNCPTR(glXGetCurrentDrawable)
211 MAKE_FUNCPTR(glXDestroyContext)
212 MAKE_FUNCPTR(glXDestroyGLXPixmap)
213 MAKE_FUNCPTR(glXGetConfig)
214 MAKE_FUNCPTR(glXIsDirect)
215 MAKE_FUNCPTR(glXMakeCurrent)
216 MAKE_FUNCPTR(glXSwapBuffers)
217 MAKE_FUNCPTR(glXQueryExtension)
218 MAKE_FUNCPTR(glXQueryVersion)
219 MAKE_FUNCPTR(glXUseXFont)
222 MAKE_FUNCPTR(glXGetClientString)
223 MAKE_FUNCPTR(glXQueryExtensionsString)
224 MAKE_FUNCPTR(glXQueryServerString)
227 MAKE_FUNCPTR(glXGetFBConfigs)
228 MAKE_FUNCPTR(glXChooseFBConfig)
229 MAKE_FUNCPTR(glXCreatePbuffer)
230 MAKE_FUNCPTR(glXCreateNewContext)
231 MAKE_FUNCPTR(glXDestroyPbuffer)
232 MAKE_FUNCPTR(glXGetFBConfigAttrib)
233 MAKE_FUNCPTR(glXGetVisualFromFBConfig)
234 MAKE_FUNCPTR(glXMakeContextCurrent)
235 MAKE_FUNCPTR(glXQueryDrawable)
236 MAKE_FUNCPTR(glXGetCurrentReadDrawable)
239 static void* (*pglXGetProcAddressARB)(const GLubyte *);
240 static BOOL (*pglXBindTexImageARB)(Display *dpy, GLXPbuffer pbuffer, int buffer);
241 static BOOL (*pglXReleaseTexImageARB)(Display *dpy, GLXPbuffer pbuffer, int buffer);
242 static BOOL (*pglXDrawableAttribARB)(Display *dpy, GLXDrawable draw, const int *attribList);
243 static int (*pglXSwapIntervalSGI)(int);
245 /* NV GLX Extension */
246 static void* (*pglXAllocateMemoryNV)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
247 static void (*pglXFreeMemoryNV)(GLvoid *pointer);
249 /* Standard OpenGL */
250 MAKE_FUNCPTR(glBindTexture)
251 MAKE_FUNCPTR(glBitmap)
252 MAKE_FUNCPTR(glCopyTexSubImage1D)
253 MAKE_FUNCPTR(glCopyTexImage2D)
254 MAKE_FUNCPTR(glCopyTexSubImage2D)
255 MAKE_FUNCPTR(glDisable)
256 MAKE_FUNCPTR(glDrawBuffer)
257 MAKE_FUNCPTR(glEnable)
258 MAKE_FUNCPTR(glEndList)
259 MAKE_FUNCPTR(glGetError)
260 MAKE_FUNCPTR(glGetIntegerv)
261 MAKE_FUNCPTR(glGetString)
262 MAKE_FUNCPTR(glIsEnabled)
263 MAKE_FUNCPTR(glNewList)
264 MAKE_FUNCPTR(glPixelStorei)
265 MAKE_FUNCPTR(glReadPixels)
266 MAKE_FUNCPTR(glScissor)
267 MAKE_FUNCPTR(glTexImage2D)
268 MAKE_FUNCPTR(glViewport)
271 static BOOL X11DRV_WineGL_InitOpenglInfo(void)
273 static BOOL infoInitialized = FALSE;
275 int screen = DefaultScreen(gdi_display);
276 Window win = RootWindow(gdi_display, screen);
278 XVisualInfo template;
281 GLXContext ctx = NULL;
285 infoInitialized = TRUE;
289 visual = DefaultVisual(gdi_display, screen);
290 template.visualid = XVisualIDFromVisual(visual);
291 vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
293 WORD old_fs = wine_get_fs();
294 /* Create a GLX Context. Without one we can't query GL information */
295 ctx = pglXCreateContext(gdi_display, vis, None, GL_TRUE);
296 if (wine_get_fs() != old_fs)
298 wine_set_fs( old_fs );
300 ERR( "%%fs register corrupted, probably broken ATI driver, disabling OpenGL.\n" );
301 ERR( "You need to set the \"UseFastTls\" option to \"2\" in your X config file.\n" );
307 pglXMakeCurrent(gdi_display, win, ctx);
309 ERR(" couldn't initialize OpenGL, expect problems\n");
314 WineGLInfo.glVersion = (const char *) pglGetString(GL_VERSION);
315 WineGLInfo.glExtensions = strdup((const char *) pglGetString(GL_EXTENSIONS));
317 /* Get the common GLX version supported by GLX client and server ( major/minor) */
318 pglXQueryVersion(gdi_display, &WineGLInfo.glxVersion[0], &WineGLInfo.glxVersion[1]);
320 WineGLInfo.glxServerVersion = pglXQueryServerString(gdi_display, screen, GLX_VERSION);
321 WineGLInfo.glxServerExtensions = pglXQueryServerString(gdi_display, screen, GLX_EXTENSIONS);
323 WineGLInfo.glxClientVersion = pglXGetClientString(gdi_display, GLX_VERSION);
324 WineGLInfo.glxClientExtensions = pglXGetClientString(gdi_display, GLX_EXTENSIONS);
326 WineGLInfo.glxExtensions = pglXQueryExtensionsString(gdi_display, screen);
327 WineGLInfo.glxDirect = pglXIsDirect(gdi_display, ctx);
329 TRACE("GL version : %s.\n", WineGLInfo.glVersion);
330 TRACE("GL renderer : %s.\n", pglGetString(GL_RENDERER));
331 TRACE("GLX version : %d.%d.\n", WineGLInfo.glxVersion[0], WineGLInfo.glxVersion[1]);
332 TRACE("Server GLX version : %s.\n", WineGLInfo.glxServerVersion);
333 TRACE("Server GLX vendor: : %s.\n", pglXQueryServerString(gdi_display, screen, GLX_VENDOR));
334 TRACE("Client GLX version : %s.\n", WineGLInfo.glxClientVersion);
335 TRACE("Client GLX vendor: : %s.\n", pglXGetClientString(gdi_display, GLX_VENDOR));
336 TRACE("Direct rendering enabled: %s\n", WineGLInfo.glxDirect ? "True" : "False");
340 pglXMakeCurrent(gdi_display, None, NULL);
341 pglXDestroyContext(gdi_display, ctx);
347 static BOOL has_opengl(void)
349 static int init_done;
350 static void *opengl_handle;
351 const char *glx_extensions;
353 int error_base, event_base;
355 if (init_done) return (opengl_handle != NULL);
358 /* No need to load any other libraries as according to the ABI, libGL should be self-sufficient
359 and include all dependencies */
360 opengl_handle = wine_dlopen(SONAME_LIBGL, RTLD_NOW|RTLD_GLOBAL, NULL, 0);
361 if (opengl_handle == NULL) return FALSE;
363 pglXGetProcAddressARB = wine_dlsym(opengl_handle, "glXGetProcAddressARB", NULL, 0);
364 if (pglXGetProcAddressARB == NULL) {
365 ERR("could not find glXGetProcAddressARB in libGL.\n");
369 #define LOAD_FUNCPTR(f) if((p##f = (void*)pglXGetProcAddressARB((const unsigned char*)#f)) == NULL) goto sym_not_found;
371 LOAD_FUNCPTR(glXChooseVisual)
372 LOAD_FUNCPTR(glXCreateContext)
373 LOAD_FUNCPTR(glXCreateGLXPixmap)
374 LOAD_FUNCPTR(glXGetCurrentContext)
375 LOAD_FUNCPTR(glXGetCurrentDrawable)
376 LOAD_FUNCPTR(glXDestroyContext)
377 LOAD_FUNCPTR(glXDestroyGLXPixmap)
378 LOAD_FUNCPTR(glXGetConfig)
379 LOAD_FUNCPTR(glXIsDirect)
380 LOAD_FUNCPTR(glXMakeCurrent)
381 LOAD_FUNCPTR(glXSwapBuffers)
382 LOAD_FUNCPTR(glXQueryExtension)
383 LOAD_FUNCPTR(glXQueryVersion)
384 LOAD_FUNCPTR(glXUseXFont)
387 LOAD_FUNCPTR(glXGetClientString)
388 LOAD_FUNCPTR(glXQueryExtensionsString)
389 LOAD_FUNCPTR(glXQueryServerString)
392 LOAD_FUNCPTR(glXCreatePbuffer)
393 LOAD_FUNCPTR(glXCreateNewContext)
394 LOAD_FUNCPTR(glXDestroyPbuffer)
395 LOAD_FUNCPTR(glXMakeContextCurrent)
396 LOAD_FUNCPTR(glXGetCurrentReadDrawable)
397 LOAD_FUNCPTR(glXGetFBConfigs)
399 /* Standard OpenGL calls */
400 LOAD_FUNCPTR(glBindTexture)
401 LOAD_FUNCPTR(glBitmap)
402 LOAD_FUNCPTR(glCopyTexSubImage1D)
403 LOAD_FUNCPTR(glCopyTexImage2D)
404 LOAD_FUNCPTR(glCopyTexSubImage2D)
405 LOAD_FUNCPTR(glDisable)
406 LOAD_FUNCPTR(glDrawBuffer)
407 LOAD_FUNCPTR(glEnable)
408 LOAD_FUNCPTR(glEndList)
409 LOAD_FUNCPTR(glGetError)
410 LOAD_FUNCPTR(glGetIntegerv)
411 LOAD_FUNCPTR(glGetString)
412 LOAD_FUNCPTR(glIsEnabled)
413 LOAD_FUNCPTR(glNewList)
414 LOAD_FUNCPTR(glPixelStorei)
415 LOAD_FUNCPTR(glReadPixels)
416 LOAD_FUNCPTR(glScissor)
417 LOAD_FUNCPTR(glTexImage2D)
418 LOAD_FUNCPTR(glViewport)
421 /* It doesn't matter if these fail. They'll only be used if the driver reports
422 the associated extension is available (and if a driver reports the extension
423 is available but fails to provide the functions, it's quite broken) */
424 #define LOAD_FUNCPTR(f) p##f = (void*)pglXGetProcAddressARB((const unsigned char*)#f);
425 /* NV GLX Extension */
426 LOAD_FUNCPTR(glXAllocateMemoryNV)
427 LOAD_FUNCPTR(glXFreeMemoryNV)
430 if(!X11DRV_WineGL_InitOpenglInfo()) {
431 wine_dlclose(opengl_handle, NULL, 0);
432 opengl_handle = NULL;
437 if (pglXQueryExtension(gdi_display, &error_base, &event_base) == True) {
438 TRACE("GLX is up and running error_base = %d\n", error_base);
440 wine_dlclose(opengl_handle, NULL, 0);
441 opengl_handle = NULL;
444 /* In case of GLX you have direct and indirect rendering. Most of the time direct rendering is used
445 * as in general only that is hardware accelerated. In some cases like in case of remote X indirect
448 * The main problem for our OpenGL code is that we need certain GLX calls but their presence
449 * depends on the reported GLX client / server version and on the client / server extension list.
450 * Those don't have to be the same.
452 * In general the server GLX information should be used in case of indirect rendering. When direct
453 * rendering is used, the OpenGL client library is responsible for which GLX calls are available.
454 * Nvidia's OpenGL drivers are the best in terms of GLX features. At the moment of writing their
455 * 8762 drivers support 1.3 for the server and 1.4 for the client and they support lots of extensions.
456 * Unfortunately it is much more complicated for Mesa/DRI-based drivers and ATI's drivers.
457 * Both sets of drivers report a server version of 1.2 and the client version can be 1.3 or 1.4.
458 * Further, in case of at least ATI's drivers, one crucial extension needed for our pixel format code
459 * is only available in the list of server extensions and not in the client list.
461 * The versioning checks below try to take into account the comments from above.
464 /* Depending on the use of direct or indirect rendering we need either the list of extensions
465 * exported by the client or by the server.
467 if(WineGLInfo.glxDirect)
468 glx_extensions = WineGLInfo.glxClientExtensions;
470 glx_extensions = WineGLInfo.glxServerExtensions;
472 /* Based on the default opengl context we decide whether direct or indirect rendering is used.
473 * In case of indirect rendering we check if the GLX version of the server is 1.2 and else
474 * the client version is checked.
476 if ((!WineGLInfo.glxDirect && !strcmp("1.2", WineGLInfo.glxServerVersion)) ||
477 (WineGLInfo.glxDirect && !strcmp("1.2", WineGLInfo.glxClientVersion)))
479 if (NULL != strstr(glx_extensions, "GLX_SGIX_fbconfig")) {
480 pglXChooseFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfigSGIX");
481 pglXGetFBConfigAttrib = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttribSGIX");
482 pglXGetVisualFromFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfigSGIX");
484 ERR(" glx_version is %s and GLX_SGIX_fbconfig extension is unsupported. Expect problems.\n", WineGLInfo.glxClientVersion);
487 pglXChooseFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfig");
488 pglXGetFBConfigAttrib = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttrib");
489 pglXGetVisualFromFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfig");
492 /* The mesa libGL client library seems to forward glXQueryDrawable to the Xserver, so only
493 * enable this function when the Xserver understand GLX 1.3 or newer
495 if (!strcmp("1.2", WineGLInfo.glxServerVersion))
496 pglXQueryDrawable = NULL;
498 pglXQueryDrawable = wine_dlsym(RTLD_DEFAULT, "glXQueryDrawable", NULL, 0);
500 if (NULL != strstr(glx_extensions, "GLX_ATI_render_texture")) {
501 pglXBindTexImageARB = (void*)pglXGetProcAddressARB((const GLubyte *) "glXBindTexImageARB");
502 pglXReleaseTexImageARB = (void*)pglXGetProcAddressARB((const GLubyte *) "glXReleaseTexImageARB");
503 pglXDrawableAttribARB = (void*)pglXGetProcAddressARB((const GLubyte *) "glXDrawableAttribARB");
506 X11DRV_WineGL_LoadExtensions();
509 return (opengl_handle != NULL);
512 wine_dlclose(opengl_handle, NULL, 0);
513 opengl_handle = NULL;
517 static inline Wine_GLContext *alloc_context(void)
521 if ((ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLContext))))
523 ret->next = context_list;
524 if (context_list) context_list->prev = ret;
530 static inline void free_context(Wine_GLContext *context)
532 if (context->next != NULL) context->next->prev = context->prev;
533 if (context->prev != NULL) context->prev->next = context->next;
534 else context_list = context->next;
536 HeapFree(GetProcessHeap(), 0, context);
539 static inline Wine_GLContext *get_context_from_GLXContext(GLXContext ctx)
542 if (!ctx) return NULL;
543 for (ret = context_list; ret; ret = ret->next) if (ctx == ret->ctx) break;
548 * get_hdc_from_Drawable (internal)
550 * For use by wglGetCurrentReadDCARB.
552 static inline HDC get_hdc_from_Drawable(GLXDrawable d)
555 for (ret = context_list; ret; ret = ret->next) {
556 if (d == ret->physDev->drawable) {
563 static inline BOOL is_valid_context( Wine_GLContext *ctx )
566 for (ptr = context_list; ptr; ptr = ptr->next) if (ptr == ctx) break;
567 return (ptr != NULL);
570 static int describeContext(Wine_GLContext* ctx) {
573 TRACE(" Context %p have (vis:%p):\n", ctx, ctx->vis);
574 pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_FBCONFIG_ID, &tmp);
575 TRACE(" - FBCONFIG_ID 0x%x\n", tmp);
576 pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_VISUAL_ID, &tmp);
577 TRACE(" - VISUAL_ID 0x%x\n", tmp);
582 static int describeDrawable(Wine_GLContext* ctx, Drawable drawable) {
585 int attribList[3] = { GLX_FBCONFIG_ID, 0, None };
588 if (pglXQueryDrawable == NULL) {
589 /** glXQueryDrawable not available so returns not supported */
593 TRACE(" Drawable %p have :\n", (void*) drawable);
594 pglXQueryDrawable(gdi_display, drawable, GLX_WIDTH, (unsigned int*) &tmp);
595 TRACE(" - WIDTH as %d\n", tmp);
596 pglXQueryDrawable(gdi_display, drawable, GLX_HEIGHT, (unsigned int*) &tmp);
597 TRACE(" - HEIGHT as %d\n", tmp);
598 pglXQueryDrawable(gdi_display, drawable, GLX_FBCONFIG_ID, (unsigned int*) &tmp);
599 TRACE(" - FBCONFIG_ID as 0x%x\n", tmp);
602 fbCfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), attribList, &nElements);
603 if (fbCfgs == NULL) {
607 pglXGetFBConfigAttrib(gdi_display, fbCfgs[0], GLX_VISUAL_ID, &tmp);
608 TRACE(" - VISUAL_ID as 0x%x\n", tmp);
615 static int ConvertAttribWGLtoGLX(const int* iWGLAttr, int* oGLXAttr, Wine_GLPBuffer* pbuf) {
620 int nvfloatattrib = GLX_DONT_CARE;
623 /* The list of WGL attributes is allowed to be NULL. We don't return here for NULL
624 * because we need to do fixups for GLX_DRAWABLE_TYPE/GLX_RENDER_TYPE/GLX_FLOAT_COMPONENTS_NV. */
625 while (iWGLAttr && 0 != iWGLAttr[cur]) {
626 TRACE("pAttr[%d] = %x\n", cur, iWGLAttr[cur]);
628 switch (iWGLAttr[cur]) {
629 case WGL_COLOR_BITS_ARB:
630 pop = iWGLAttr[++cur];
631 PUSH2(oGLXAttr, GLX_BUFFER_SIZE, pop);
632 TRACE("pAttr[%d] = GLX_BUFFER_SIZE: %d\n", cur, pop);
634 case WGL_BLUE_BITS_ARB:
635 pop = iWGLAttr[++cur];
636 PUSH2(oGLXAttr, GLX_BLUE_SIZE, pop);
637 TRACE("pAttr[%d] = GLX_BLUE_SIZE: %d\n", cur, pop);
639 case WGL_RED_BITS_ARB:
640 pop = iWGLAttr[++cur];
641 PUSH2(oGLXAttr, GLX_RED_SIZE, pop);
642 TRACE("pAttr[%d] = GLX_RED_SIZE: %d\n", cur, pop);
644 case WGL_GREEN_BITS_ARB:
645 pop = iWGLAttr[++cur];
646 PUSH2(oGLXAttr, GLX_GREEN_SIZE, pop);
647 TRACE("pAttr[%d] = GLX_GREEN_SIZE: %d\n", cur, pop);
649 case WGL_ALPHA_BITS_ARB:
650 pop = iWGLAttr[++cur];
651 PUSH2(oGLXAttr, GLX_ALPHA_SIZE, pop);
652 TRACE("pAttr[%d] = GLX_ALPHA_SIZE: %d\n", cur, pop);
654 case WGL_DEPTH_BITS_ARB:
655 pop = iWGLAttr[++cur];
656 PUSH2(oGLXAttr, GLX_DEPTH_SIZE, pop);
657 TRACE("pAttr[%d] = GLX_DEPTH_SIZE: %d\n", cur, pop);
659 case WGL_STENCIL_BITS_ARB:
660 pop = iWGLAttr[++cur];
661 PUSH2(oGLXAttr, GLX_STENCIL_SIZE, pop);
662 TRACE("pAttr[%d] = GLX_STENCIL_SIZE: %d\n", cur, pop);
664 case WGL_DOUBLE_BUFFER_ARB:
665 pop = iWGLAttr[++cur];
666 PUSH2(oGLXAttr, GLX_DOUBLEBUFFER, pop);
667 TRACE("pAttr[%d] = GLX_DOUBLEBUFFER: %d\n", cur, pop);
670 case WGL_PIXEL_TYPE_ARB:
671 pop = iWGLAttr[++cur];
672 TRACE("pAttr[%d] = WGL_PIXEL_TYPE_ARB: %d\n", cur, pop);
674 case WGL_TYPE_COLORINDEX_ARB: pixelattrib = GLX_COLOR_INDEX_BIT; break ;
675 case WGL_TYPE_RGBA_ARB: pixelattrib = GLX_RGBA_BIT; break ;
676 /* This is the same as WGL_TYPE_RGBA_FLOAT_ATI but the GLX constants differ, only the ARB GLX one is widely supported so use that */
677 case WGL_TYPE_RGBA_FLOAT_ATI: pixelattrib = GLX_RGBA_FLOAT_BIT; break ;
679 ERR("unexpected PixelType(%x)\n", pop);
684 case WGL_SUPPORT_GDI_ARB:
685 pop = iWGLAttr[++cur];
686 PUSH2(oGLXAttr, GLX_X_RENDERABLE, pop);
687 TRACE("pAttr[%d] = WGL_SUPPORT_GDI_ARB: %d\n", cur, pop);
690 case WGL_DRAW_TO_BITMAP_ARB:
691 pop = iWGLAttr[++cur];
692 TRACE("pAttr[%d] = WGL_DRAW_TO_BITMAP_ARB: %d\n", cur, pop);
693 /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
695 drawattrib |= GLX_PIXMAP_BIT;
699 case WGL_DRAW_TO_WINDOW_ARB:
700 pop = iWGLAttr[++cur];
701 TRACE("pAttr[%d] = WGL_DRAW_TO_WINDOW_ARB: %d\n", cur, pop);
702 /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
704 drawattrib |= GLX_WINDOW_BIT;
708 case WGL_DRAW_TO_PBUFFER_ARB:
709 pop = iWGLAttr[++cur];
710 TRACE("pAttr[%d] = WGL_DRAW_TO_PBUFFER_ARB: %d\n", cur, pop);
711 /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
713 drawattrib |= GLX_PBUFFER_BIT;
717 case WGL_ACCELERATION_ARB:
718 case WGL_SUPPORT_OPENGL_ARB:
719 pop = iWGLAttr[++cur];
720 /** nothing to do, if we are here, supposing support Accelerated OpenGL */
721 TRACE("pAttr[%d] = WGL_SUPPORT_OPENGL_ARB: %d\n", cur, pop);
724 case WGL_PBUFFER_LARGEST_ARB:
725 pop = iWGLAttr[++cur];
726 PUSH2(oGLXAttr, GLX_LARGEST_PBUFFER, pop);
727 TRACE("pAttr[%d] = GLX_LARGEST_PBUFFER: %x\n", cur, pop);
730 case WGL_SAMPLE_BUFFERS_ARB:
731 pop = iWGLAttr[++cur];
732 PUSH2(oGLXAttr, GLX_SAMPLE_BUFFERS_ARB, pop);
733 TRACE("pAttr[%d] = GLX_SAMPLE_BUFFERS_ARB: %x\n", cur, pop);
736 case WGL_SAMPLES_ARB:
737 pop = iWGLAttr[++cur];
738 PUSH2(oGLXAttr, GLX_SAMPLES_ARB, pop);
739 TRACE("pAttr[%d] = GLX_SAMPLES_ARB: %x\n", cur, pop);
742 case WGL_TEXTURE_FORMAT_ARB:
743 case WGL_TEXTURE_TARGET_ARB:
744 case WGL_MIPMAP_TEXTURE_ARB:
745 TRACE("WGL_render_texture Attributes: %x as %x\n", iWGLAttr[cur], iWGLAttr[cur + 1]);
746 pop = iWGLAttr[++cur];
748 ERR("trying to use GLX_Pbuffer Attributes without Pbuffer (was %x)\n", iWGLAttr[cur]);
750 if (use_render_texture_ati) {
751 /** nothing to do here */
753 else if (!use_render_texture_emulation) {
754 if (WGL_NO_TEXTURE_ARB != pop) {
755 ERR("trying to use WGL_render_texture Attributes without support (was %x)\n", iWGLAttr[cur]);
756 return -1; /** error: don't support it */
758 PUSH2(oGLXAttr, GLX_X_RENDERABLE, pop);
759 drawattrib |= GLX_PBUFFER_BIT;
763 case WGL_FLOAT_COMPONENTS_NV:
764 nvfloatattrib = iWGLAttr[++cur];
765 TRACE("pAttr[%d] = WGL_FLOAT_COMPONENTS_NV: %x\n", cur, nvfloatattrib);
767 case WGL_BIND_TO_TEXTURE_RGB_ARB:
768 case WGL_BIND_TO_TEXTURE_RGBA_ARB:
769 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV:
770 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV:
771 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV:
772 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV:
773 pop = iWGLAttr[++cur];
774 /** cannot be converted, see direct handling on
775 * - wglGetPixelFormatAttribivARB
776 * TODO: wglChoosePixelFormat
781 FIXME("unsupported %x WGL Attribute\n", iWGLAttr[cur]);
787 /* Apply the OR'd drawable type bitmask now EVEN when WGL_DRAW_TO* is unset.
788 * It is needed in all cases because GLX_DRAWABLE_TYPE default to GLX_WINDOW_BIT. */
789 PUSH2(oGLXAttr, GLX_DRAWABLE_TYPE, drawattrib);
790 TRACE("pAttr[?] = GLX_DRAWABLE_TYPE: %#x\n", drawattrib);
792 /* Set GLX_RENDER_TYPE all the time */
793 PUSH2(oGLXAttr, GLX_RENDER_TYPE, pixelattrib);
794 TRACE("pAttr[?] = GLX_RENDER_TYPE: %#x\n", pixelattrib);
796 /* Set GLX_FLOAT_COMPONENTS_NV all the time */
797 if(strstr(WineGLInfo.glxExtensions, "GLX_NV_float_buffer")) {
798 PUSH2(oGLXAttr, GLX_FLOAT_COMPONENTS_NV, nvfloatattrib);
799 TRACE("pAttr[?] = GLX_FLOAT_COMPONENTS_NV: %#x\n", nvfloatattrib);
805 static int get_render_type_from_fbconfig(Display *display, GLXFBConfig fbconfig)
807 int render_type=0, render_type_bit;
808 pglXGetFBConfigAttrib(display, fbconfig, GLX_RENDER_TYPE, &render_type_bit);
809 switch(render_type_bit)
812 render_type = GLX_RGBA_TYPE;
814 case GLX_COLOR_INDEX_BIT:
815 render_type = GLX_COLOR_INDEX_TYPE;
817 case GLX_RGBA_FLOAT_BIT:
818 render_type = GLX_RGBA_FLOAT_TYPE;
821 ERR("Unknown render_type: %x\n", render_type);
826 static BOOL get_fbconfig_from_visualid(Display *display, Visual *visual, GLXFBConfig *fbconfig, int *fmt_id)
828 GLXFBConfig* cfgs = NULL;
835 if(!display || !visual) {
836 ERR("Invalid display or visual\n");
839 visualid = XVisualIDFromVisual(visual);
841 /* Get a list of all available framebuffer configurations */
842 cfgs = pglXGetFBConfigs(display, DefaultScreen(display), &nCfgs);
843 if (NULL == cfgs || 0 == nCfgs) {
844 ERR("glXChooseFBConfig returns NULL\n");
845 if(cfgs != NULL) XFree(cfgs);
849 /* Find the requested offscreen format and count the number of offscreen formats */
850 for(i=0; i<nCfgs; i++) {
851 pglXGetFBConfigAttrib(display, cfgs[i], GLX_VISUAL_ID, &tmp_vis_id);
852 pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &tmp_fmt_id);
854 /* We are looking up the GLX index of our main visual and have found it :) */
855 if(visualid == tmp_vis_id) {
856 TRACE("Found FBCONFIG_ID 0x%x at index %d for VISUAL_ID 0x%x\n", tmp_fmt_id, i, tmp_vis_id);
858 *fmt_id = tmp_fmt_id;
864 ERR("No fbconfig found for Wine's main visual (0x%lx), expect problems!\n", visualid);
869 static BOOL init_formats(Display *display, int screen, Visual *visual)
871 int fmt_id, tmp_vis_id, tmp_fmt_id, nCfgs, i;
873 GLXFBConfig fbconfig;
874 int nOffscreenFormats = 0;
876 /* Locate the fbconfig correspondig to our main visual */
877 if(!get_fbconfig_from_visualid(display, visual, &fbconfig, &fmt_id)) {
878 ERR("Can't get the FBCONFIG_ID for the main visual, expect problems!\n");
882 /* As mentioned in various parts of the code only the format of the main visual can be used for onscreen rendering.
883 * Next to this format there are also so called offscreen rendering formats (used for pbuffers) which can be supported
884 * because they don't need a visual. Below we use glXGetFBConfigs instead of glXChooseFBConfig to enumerate the fb configurations
885 * because this call lists both types of formats instead of only onscreen ones. */
886 cfgs = pglXGetFBConfigs(display, DefaultScreen(display), &nCfgs);
887 if (NULL == cfgs || 0 == nCfgs) {
888 WARN("glXChooseFBConfig returns NULL\n");
889 if(cfgs != NULL) XFree(cfgs);
891 /* We only have the single format of Wine's main visual */
892 WineGLPixelFormatList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(WineGLPixelFormat));
893 WineGLPixelFormatList[0].iPixelFormat = 1;
894 WineGLPixelFormatList[0].fbconfig = fbconfig;
895 WineGLPixelFormatList[0].fmt_id = fmt_id;
896 WineGLPixelFormatList[0].render_type = get_render_type_from_fbconfig(display, fbconfig);
897 WineGLPixelFormatList[0].offscreenOnly = FALSE;
898 WineGLPixelFormatListSize = 1;
901 /* Count the number of offscreen formats to determine the size for our pixelformat list */
902 for(i=0; i<nCfgs; i++) {
903 pglXGetFBConfigAttrib(display, cfgs[i], GLX_VISUAL_ID, &tmp_vis_id);
905 /* We have found an offscreen rendering format :) */
906 if(tmp_vis_id == 0) {
910 TRACE("Number of offscreen formats: %d\n", nOffscreenFormats);
912 /* Allocate memory for all the offscreen pixelformats and the format of Wine's main visual */
913 WineGLPixelFormatList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (1+nOffscreenFormats)*sizeof(WineGLPixelFormat));
914 WineGLPixelFormatList[0].iPixelFormat = 1;
915 WineGLPixelFormatList[0].fbconfig = fbconfig;
916 WineGLPixelFormatList[0].fmt_id = fmt_id;
917 WineGLPixelFormatList[0].render_type = get_render_type_from_fbconfig(display, fbconfig);
918 WineGLPixelFormatList[0].offscreenOnly = FALSE;
919 WineGLPixelFormatListSize = 1;
921 /* Fill the list with offscreen formats */
922 for(i=0; i<nCfgs; i++) {
923 pglXGetFBConfigAttrib(display, cfgs[i], GLX_VISUAL_ID, &tmp_vis_id);
924 pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &tmp_fmt_id);
926 /* We have found an offscreen rendering format :) */
927 if(tmp_vis_id == 0) {
928 TRACE("Found offscreen format FBCONFIG_ID 0x%x corresponding to iPixelFormat %d at GLX index %d\n", tmp_fmt_id, WineGLPixelFormatListSize+1, i);
929 WineGLPixelFormatList[WineGLPixelFormatListSize].iPixelFormat = WineGLPixelFormatListSize+1; /* The index starts at 1 */
930 WineGLPixelFormatList[WineGLPixelFormatListSize].fbconfig = cfgs[i];
931 WineGLPixelFormatList[WineGLPixelFormatListSize].fmt_id = tmp_fmt_id;
932 WineGLPixelFormatList[WineGLPixelFormatListSize].render_type = get_render_type_from_fbconfig(display, cfgs[i]);
933 WineGLPixelFormatList[WineGLPixelFormatListSize].offscreenOnly = TRUE;
934 WineGLPixelFormatListSize++;
939 if(cfgs != NULL) XFree(cfgs);
944 /* GLX can advertise dozens of different pixelformats including offscreen and onscreen ones.
945 * In our WGL implementation we only support a subset of these formats namely the format of
946 * Wine's main visual and offscreen formats (if they are available).
947 * This function converts a WGL format to its corresponding GLX one. It returns a WineGLPixelFormat
948 * and it returns the number of supported WGL formats in fmt_count.
950 static WineGLPixelFormat* ConvertPixelFormatWGLtoGLX(Display *display, int iPixelFormat, BOOL AllowOffscreen, int *fmt_count)
952 WineGLPixelFormat *res = NULL;
954 /* Init the list of pixel formats when we need it */
955 if(!WineGLPixelFormatListSize)
956 init_formats(display, DefaultScreen(display), visual);
958 /* Check if the pixelformat is valid. Note that it is legal to pass an invalid
959 * iPixelFormat in case of probing the number of pixelformats.
961 if((iPixelFormat <= 0) || (iPixelFormat > WineGLPixelFormatListSize)) {
963 *fmt_count = WineGLPixelFormatListSize;
965 *fmt_count = 1; /* Only show the format of our main visual */
967 else if(iPixelFormat == 1) {
968 res = &WineGLPixelFormatList[0];
969 *fmt_count = 1; /* Only show the format of our main visual */
971 else if((WineGLPixelFormatList[iPixelFormat-1].offscreenOnly == TRUE) && AllowOffscreen) {
972 res = &WineGLPixelFormatList[iPixelFormat-1];
973 *fmt_count = WineGLPixelFormatListSize;
974 TRACE("Returning FBConfig=%p for iPixelFormat=%d\n", res->fbconfig, iPixelFormat);
977 TRACE("Number of returned pixelformats=%d\n", *fmt_count);
982 /* Search our internal pixelformat list for the WGL format corresponding to the given fbconfig */
983 static int ConvertPixelFormatGLXtoWGL(Display *display, int fmt_id)
987 /* Init the list of pixel formats when we need it */
988 if(!WineGLPixelFormatListSize)
989 init_formats(display, DefaultScreen(display), visual);
991 for(i=0; i<WineGLPixelFormatListSize; i++) {
992 if(WineGLPixelFormatList[i].fmt_id == fmt_id) {
993 TRACE("Returning iPixelFormat %d for fmt_id 0x%x\n", WineGLPixelFormatList[i].iPixelFormat, fmt_id);
994 return WineGLPixelFormatList[i].iPixelFormat;
997 TRACE("No compatible format found for fmt_id 0x%x\n", fmt_id);
1002 * X11DRV_ChoosePixelFormat
1004 * Equivalent to glXChooseVisual.
1006 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
1007 const PIXELFORMATDESCRIPTOR *ppfd) {
1008 WineGLPixelFormat *fmt;
1012 if (!has_opengl()) {
1013 ERR("No libGL on this box - disabling OpenGL support !\n");
1017 if (TRACE_ON(opengl)) {
1018 TRACE("(%p,%p)\n", physDev, ppfd);
1020 dump_PIXELFORMATDESCRIPTOR((const PIXELFORMATDESCRIPTOR *) ppfd);
1025 ERR("Can't get an opengl visual!\n");
1029 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, 1 /* main visual */, FALSE /* offscreen */, &value);
1030 /* In case an fbconfig was found, check if it matches to the requirements of the ppfd */
1032 ERR("Can't find a matching FBCONFIG_ID for VISUAL_ID 0x%lx!\n", visual->visualid);
1039 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
1040 if (value & GLX_RGBA_BIT)
1041 iPixelType = PFD_TYPE_RGBA;
1043 iPixelType = PFD_TYPE_COLORINDEX;
1045 if (ppfd->iPixelType != iPixelType) {
1046 TRACE("pixel type mismatch\n");
1051 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value); if (value) dwFlags |= PFD_DOUBLEBUFFER;
1052 if (!(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) && (ppfd->dwFlags & PFD_DOUBLEBUFFER)) {
1053 if (!(dwFlags & PFD_DOUBLEBUFFER)) {
1054 TRACE("dbl buffer mismatch\n");
1060 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value); if (value) dwFlags |= PFD_STEREO;
1061 if (!(ppfd->dwFlags & PFD_STEREO_DONTCARE) && (ppfd->dwFlags & PFD_STEREO)) {
1062 if (!(dwFlags & PFD_STEREO)) {
1063 TRACE("stereo mismatch\n");
1069 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &value);
1070 if (ppfd->iPixelType==PFD_TYPE_RGBA && ppfd->cAlphaBits && !value) {
1071 TRACE("alpha mismatch\n");
1076 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &value);
1077 if (ppfd->cDepthBits && !value) {
1078 TRACE("depth mismatch\n");
1083 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &value);
1084 if (ppfd->cStencilBits && !value) {
1085 TRACE("stencil mismatch\n");
1090 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_AUX_BUFFERS, &value);
1091 if (ppfd->cAuxBuffers && !value) {
1092 TRACE("aux mismatch\n");
1096 /* When we pass all the checks we have found a matching format :) */
1098 TRACE("Successfully found a matching mode, returning index: %d\n", ret);
1103 TRACE("No matching mode was found returning 0\n");
1105 wine_tsx11_unlock();
1110 * X11DRV_DescribePixelFormat
1112 * Get the pixel-format descriptor associated to the given id
1114 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
1117 PIXELFORMATDESCRIPTOR *ppfd) {
1118 /*XVisualInfo *vis;*/
1121 WineGLPixelFormat *fmt;
1125 if (!has_opengl()) {
1126 ERR("No libGL on this box - disabling OpenGL support !\n");
1130 TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
1132 /* Look for the iPixelFormat in our list of supported formats. If it is supported we get the index in the FBConfig table and the number of supported formats back */
1133 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_count);
1135 /* The application is only querying the number of pixelformats */
1137 } else if(fmt == NULL) {
1138 WARN("unexpected iPixelFormat(%d): not >=1 and <=nFormats(%d), returning NULL!\n", iPixelFormat, fmt_count);
1142 if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
1143 ERR("Wrong structure size !\n");
1144 /* Should set error */
1150 memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
1151 ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
1154 /* These flags are always the same... */
1155 ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
1156 /* Now the flags extracted from the Visual */
1160 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_CONFIG_CAVEAT, &value);
1161 if(value == GLX_SLOW_CONFIG)
1162 ppfd->dwFlags |= PFD_GENERIC_ACCELERATED;
1164 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
1165 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
1168 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
1169 if (value & GLX_RGBA_BIT)
1170 ppfd->iPixelType = PFD_TYPE_RGBA;
1172 ppfd->iPixelType = PFD_TYPE_COLORINDEX;
1175 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BUFFER_SIZE, &value);
1176 ppfd->cColorBits = value;
1178 /* Red, green, blue and alpha bits / shifts */
1179 if (ppfd->iPixelType == PFD_TYPE_RGBA) {
1180 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RED_SIZE, &rb);
1181 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_GREEN_SIZE, &gb);
1182 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BLUE_SIZE, &bb);
1183 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &ab);
1185 ppfd->cRedBits = rb;
1186 ppfd->cRedShift = gb + bb + ab;
1187 ppfd->cBlueBits = bb;
1188 ppfd->cBlueShift = ab;
1189 ppfd->cGreenBits = gb;
1190 ppfd->cGreenShift = bb + ab;
1191 ppfd->cAlphaBits = ab;
1192 ppfd->cAlphaShift = 0;
1195 ppfd->cRedShift = 0;
1196 ppfd->cBlueBits = 0;
1197 ppfd->cBlueShift = 0;
1198 ppfd->cGreenBits = 0;
1199 ppfd->cGreenShift = 0;
1200 ppfd->cAlphaBits = 0;
1201 ppfd->cAlphaShift = 0;
1204 /* Accum RGBA bits */
1205 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_RED_SIZE, &rb);
1206 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_GREEN_SIZE, &gb);
1207 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_BLUE_SIZE, &bb);
1208 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_ALPHA_SIZE, &ab);
1210 ppfd->cAccumBits = rb+gb+bb+ab;
1211 ppfd->cAccumRedBits = rb;
1212 ppfd->cAccumGreenBits = gb;
1213 ppfd->cAccumBlueBits = bb;
1214 ppfd->cAccumAlphaBits = ab;
1217 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &value);
1218 ppfd->cDepthBits = value;
1221 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &value);
1222 ppfd->cStencilBits = value;
1224 wine_tsx11_unlock();
1226 /* Aux : to do ... */
1228 ppfd->iLayerType = PFD_MAIN_PLANE;
1230 if (TRACE_ON(opengl)) {
1231 dump_PIXELFORMATDESCRIPTOR(ppfd);
1238 * X11DRV_GetPixelFormat
1240 * Get the pixel-format id used by this DC
1242 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
1243 WineGLPixelFormat *fmt;
1245 TRACE("(%p)\n", physDev);
1247 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, physDev->current_pf, TRUE, &tmp);
1250 /* This happens on HDCs on which SetPixelFormat wasn't called yet */
1251 ERR("Unable to find a WineGLPixelFormat for iPixelFormat=%d\n", physDev->current_pf);
1254 else if(fmt->offscreenOnly)
1256 /* Offscreen formats can't be used with traditional WGL calls.
1257 * As has been verified on Windows GetPixelFormat doesn't fail but returns iPixelFormat=1. */
1258 TRACE("Returning iPixelFormat=1 for offscreen format: %d\n", fmt->iPixelFormat);
1262 return physDev->current_pf;
1263 TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
1267 * X11DRV_SetPixelFormat
1269 * Set the pixel-format id used by this DC
1271 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
1273 const PIXELFORMATDESCRIPTOR *ppfd) {
1274 WineGLPixelFormat *fmt;
1277 TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
1279 if (!has_opengl()) {
1280 ERR("No libGL on this box - disabling OpenGL support !\n");
1284 /* SetPixelFormat is not allowed on the X root_window e.g. GetDC(0) */
1285 if(get_glxdrawable(physDev) == root_window)
1287 ERR("Invalid operation on root_window\n");
1291 /* Check if iPixelFormat is in our list of supported formats to see if it is supported. */
1292 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &value);
1294 ERR("Invalid iPixelFormat: %d\n", iPixelFormat);
1298 physDev->current_pf = iPixelFormat;
1300 if (TRACE_ON(opengl)) {
1304 * How to test if hdc current drawable is compatible (visual/FBConfig) ?
1306 * in case of root window created HDCs we crash here :(
1308 Drawable drawable = get_drawable( physDev->hdc );
1309 TRACE(" drawable (%p,%p) have :\n", drawable, root_window);
1310 pglXQueryDrawable(gdi_display, drawable, GLX_FBCONFIG_ID, (unsigned int*) &value);
1311 TRACE(" - FBCONFIG_ID as 0x%x\n", tmp);
1312 pglXQueryDrawable(gdi_display, drawable, GLX_VISUAL_ID, (unsigned int*) &value);
1313 TRACE(" - VISUAL_ID as 0x%x\n", tmp);
1314 pglXQueryDrawable(gdi_display, drawable, GLX_WIDTH, (unsigned int*) &value);
1315 TRACE(" - WIDTH as %d\n", tmp);
1316 pglXQueryDrawable(gdi_display, drawable, GLX_HEIGHT, (unsigned int*) &value);
1317 TRACE(" - HEIGHT as %d\n", tmp);
1319 gl_test = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_FBCONFIG_ID, &value);
1321 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
1323 TRACE(" FBConfig have :\n");
1324 TRACE(" - FBCONFIG_ID 0x%x\n", value);
1325 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_VISUAL_ID, &value);
1326 TRACE(" - VISUAL_ID 0x%x\n", value);
1327 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
1328 TRACE(" - DRAWABLE_TYPE 0x%x\n", value);
1335 * X11DRV_wglCreateContext
1337 * For OpenGL32 wglCreateContext.
1339 HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev)
1341 Wine_GLContext *ret;
1342 WineGLPixelFormat *fmt;
1343 int hdcPF = physDev->current_pf;
1347 HDC hdc = physDev->hdc;
1349 TRACE("(%p)->(PF:%d)\n", hdc, hdcPF);
1351 if (!has_opengl()) {
1352 ERR("No libGL on this box - disabling OpenGL support !\n");
1356 /* First, get the visual in use by the X11DRV */
1357 if (!gdi_display) return 0;
1359 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, hdcPF, TRUE /* Offscreen */, &fmt_count);
1360 /* We can render using the iPixelFormat (1) of Wine's Main visual AND using some offscreen formats.
1361 * Note that standard WGL-calls don't recognize offscreen-only formats. For that reason pbuffers
1362 * use a sort of 'proxy' HDC (wglGetPbufferDCARB).
1363 * If this fails something is very wrong on the system. */
1365 ERR("Cannot get FB Config for iPixelFormat %d, expect problems!\n", hdcPF);
1366 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1370 if (fmt_count < hdcPF) {
1371 ERR("(%p): unexpected pixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, hdcPF, fmt_count);
1372 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1376 gl_test = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_FBCONFIG_ID, &value);
1378 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
1379 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1383 /* The context will be allocated in the wglMakeCurrent call */
1385 ret = alloc_context();
1386 wine_tsx11_unlock();
1388 ret->physDev = physDev;
1392 ret->vis = pglXGetVisualFromFBConfig(gdi_display, fmt->fbconfig);
1394 TRACE(" creating context %p (GL context creation delayed)\n", ret);
1399 * X11DRV_wglDeleteContext
1401 * For OpenGL32 wglDeleteContext.
1403 BOOL X11DRV_wglDeleteContext(HGLRC hglrc)
1405 Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1408 TRACE("(%p)\n", hglrc);
1410 if (!has_opengl()) {
1411 ERR("No libGL on this box - disabling OpenGL support !\n");
1416 /* A game (Half Life not to name it) deletes twice the same context,
1417 * so make sure it is valid first */
1418 if (is_valid_context( ctx ))
1420 if (ctx->ctx) pglXDestroyContext(gdi_display, ctx->ctx);
1425 WARN("Error deleting context !\n");
1426 SetLastError(ERROR_INVALID_HANDLE);
1429 wine_tsx11_unlock();
1435 * X11DRV_wglGetCurrentReadDCARB
1437 * For OpenGL32 wglGetCurrentReadDCARB.
1439 static HDC WINAPI X11DRV_wglGetCurrentReadDCARB(void)
1447 gl_d = pglXGetCurrentReadDrawable();
1448 ret = get_hdc_from_Drawable(gl_d);
1449 wine_tsx11_unlock();
1451 TRACE(" returning %p (GL drawable %lu)\n", ret, gl_d);
1456 * X11DRV_wglGetProcAddress
1458 * For OpenGL32 wglGetProcAddress.
1460 PROC X11DRV_wglGetProcAddress(LPCSTR lpszProc)
1463 const WineGLExtension *ext;
1465 int padding = 32 - strlen(lpszProc);
1469 if (!has_opengl()) {
1470 ERR("No libGL on this box - disabling OpenGL support !\n");
1474 /* Check the table of WGL extensions to see if we need to return a WGL extension
1475 * or a function pointer to a native OpenGL function. */
1476 if(strncmp(lpszProc, "wgl", 3) != 0) {
1477 return pglXGetProcAddressARB((const GLubyte*)lpszProc);
1479 TRACE("('%s'):%*s", lpszProc, padding, " ");
1480 for (i = 0; i < WineGLExtensionListSize; ++i) {
1481 ext = WineGLExtensionList[i];
1482 for (j = 0; ext->extEntryPoints[j].funcName; ++j) {
1483 if (strcmp(ext->extEntryPoints[j].funcName, lpszProc) == 0) {
1484 TRACE("(%p) - WineGL\n", ext->extEntryPoints[j].funcAddress);
1485 return ext->extEntryPoints[j].funcAddress;
1491 ERR("(%s) - not found\n", lpszProc);
1495 /***********************************************************************
1496 * sync_current_drawable
1498 * Adjust the current viewport and scissor in order to position
1499 * and size the current drawable correctly on the parent window.
1501 static void sync_current_drawable(BOOL updatedc)
1507 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1511 if (ctx && ctx->physDev)
1514 GetClipBox(ctx->physDev->hdc, &rc); /* Make sure physDev is up to date */
1516 dy = ctx->physDev->drawable_rect.bottom - ctx->physDev->drawable_rect.top -
1517 ctx->physDev->dc_rect.bottom;
1518 width = ctx->physDev->dc_rect.right - ctx->physDev->dc_rect.left;
1519 height = ctx->physDev->dc_rect.bottom - ctx->physDev->dc_rect.top;
1523 pglViewport(ctx->physDev->dc_rect.left + ctx->viewport.left,
1524 dy + ctx->viewport.top,
1525 ctx->viewport.right ? (ctx->viewport.right - ctx->viewport.left) : width,
1526 ctx->viewport.bottom ? (ctx->viewport.bottom - ctx->viewport.top) : height);
1528 pglEnable(GL_SCISSOR_TEST);
1530 if (ctx->scissor_enabled)
1531 pglScissor(ctx->physDev->dc_rect.left + min(width, max(0, ctx->scissor.left)),
1532 dy + min(height, max(0, ctx->scissor.top)),
1533 min(width, max(0, ctx->scissor.right - ctx->scissor.left)),
1534 min(height, max(0, ctx->scissor.bottom - ctx->scissor.top)));
1536 pglScissor(ctx->physDev->dc_rect.left, dy, width, height);
1538 wine_tsx11_unlock();
1543 * X11DRV_wglMakeCurrent
1545 * For OpenGL32 wglMakeCurrent.
1547 BOOL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
1549 HDC hdc = physDev->hdc;
1550 DWORD type = GetObjectType(hdc);
1552 TRACE("(%p,%p)\n", hdc, hglrc);
1554 if (!has_opengl()) {
1555 ERR("No libGL on this box - disabling OpenGL support !\n");
1560 if (hglrc == NULL) {
1561 ret = pglXMakeCurrent(gdi_display, None, NULL);
1562 NtCurrentTeb()->glContext = NULL;
1564 Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1565 Drawable drawable = get_glxdrawable(physDev);
1566 if (ctx->ctx == NULL) {
1567 /* The describe lines below are for debugging purposes only */
1568 if (TRACE_ON(wgl)) {
1569 describeDrawable(ctx, drawable);
1570 describeContext(ctx);
1573 /* Create a GLX context using the same visual as chosen earlier in wglCreateContext.
1574 * We are certain that the drawable and context are compatible as we only allow compatible formats.
1576 TRACE(" Creating GLX Context\n");
1578 ctx->ctx = pglXCreateContext(gdi_display, ctx->vis, NULL, type == OBJ_MEMDC ? False : True);
1579 else /* Create a GLX Context for a pbuffer */
1580 ctx->ctx = pglXCreateNewContext(gdi_display, ctx->fmt->fbconfig, ctx->fmt->render_type, NULL, True);
1582 TRACE(" created a delayed OpenGL context (%p)\n", ctx->ctx);
1584 TRACE(" make current for dis %p, drawable %p, ctx %p\n", gdi_display, (void*) drawable, ctx->ctx);
1585 ret = pglXMakeCurrent(gdi_display, drawable, ctx->ctx);
1586 NtCurrentTeb()->glContext = ctx;
1589 ctx->physDev = physDev;
1591 if (type == OBJ_MEMDC)
1593 ctx->do_escape = TRUE;
1594 pglDrawBuffer(GL_FRONT_LEFT);
1598 sync_current_drawable(FALSE);
1602 wine_tsx11_unlock();
1603 TRACE(" returning %s\n", (ret ? "True" : "False"));
1608 * X11DRV_wglMakeContextCurrentARB
1610 * For OpenGL32 wglMakeContextCurrentARB
1612 BOOL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* hDrawDev, X11DRV_PDEVICE* hReadDev, HGLRC hglrc)
1615 TRACE("(%p,%p,%p)\n", hDrawDev, hReadDev, hglrc);
1617 if (!has_opengl()) {
1618 ERR("No libGL on this box - disabling OpenGL support !\n");
1623 if (hglrc == NULL) {
1624 ret = pglXMakeCurrent(gdi_display, None, NULL);
1625 NtCurrentTeb()->glContext = NULL;
1627 if (NULL == pglXMakeContextCurrent) {
1630 Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1631 Drawable d_draw = get_glxdrawable(hDrawDev);
1632 Drawable d_read = get_glxdrawable(hReadDev);
1634 if (ctx->ctx == NULL) {
1635 ctx->ctx = pglXCreateContext(gdi_display, ctx->vis, NULL, GetObjectType(hDrawDev->hdc) == OBJ_MEMDC ? False : True);
1636 TRACE(" created a delayed OpenGL context (%p)\n", ctx->ctx);
1638 ret = pglXMakeContextCurrent(gdi_display, d_draw, d_read, ctx->ctx);
1639 NtCurrentTeb()->glContext = ctx;
1642 wine_tsx11_unlock();
1644 TRACE(" returning %s\n", (ret ? "True" : "False"));
1649 * X11DRV_wglShareLists
1651 * For OpenGL32 wglShaderLists.
1653 BOOL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
1654 Wine_GLContext *org = (Wine_GLContext *) hglrc1;
1655 Wine_GLContext *dest = (Wine_GLContext *) hglrc2;
1657 TRACE("(%p, %p)\n", org, dest);
1659 if (!has_opengl()) {
1660 ERR("No libGL on this box - disabling OpenGL support !\n");
1664 if (NULL != dest && dest->ctx != NULL) {
1665 ERR("Could not share display lists, context already created !\n");
1668 if (org->ctx == NULL) {
1670 describeContext(org);
1673 org->ctx = pglXCreateContext(gdi_display, org->vis, NULL, GetObjectType(org->physDev->hdc) == OBJ_MEMDC ? False : True);
1674 else /* Create a GLX Context for a pbuffer */
1675 org->ctx = pglXCreateNewContext(gdi_display, org->fmt->fbconfig, org->fmt->render_type, NULL, True);
1676 wine_tsx11_unlock();
1677 TRACE(" created a delayed OpenGL context (%p) for Wine context %p\n", org->ctx, org);
1681 describeContext(dest);
1682 /* Create the destination context with display lists shared */
1684 dest->ctx = pglXCreateContext(gdi_display, dest->vis, org->ctx, GetObjectType(org->physDev->hdc) == OBJ_MEMDC ? False : True);
1685 else /* Create a GLX Context for a pbuffer */
1686 dest->ctx = pglXCreateNewContext(gdi_display, dest->fmt->fbconfig, dest->fmt->render_type, org->ctx, True);
1687 wine_tsx11_unlock();
1688 TRACE(" created a delayed OpenGL context (%p) for Wine context %p sharing lists with OpenGL ctx %p\n", dest->ctx, dest, org->ctx);
1695 static BOOL internal_wglUseFontBitmaps(HDC hdc, DWORD first, DWORD count, DWORD listBase, DWORD (WINAPI *GetGlyphOutline_ptr)(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,LPVOID,const MAT2*))
1697 /* We are running using client-side rendering fonts... */
1701 void *bitmap = NULL, *gl_bitmap = NULL;
1705 pglGetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
1706 pglPixelStorei(GL_UNPACK_ALIGNMENT, 4);
1707 wine_tsx11_unlock();
1709 for (glyph = first; glyph < first + count; glyph++) {
1710 unsigned int needed_size = GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, NULL);
1711 int height, width_int;
1713 TRACE("Glyph : %3d / List : %d\n", glyph, listBase);
1714 if (needed_size == GDI_ERROR) {
1715 TRACE(" - needed size : %d (GDI_ERROR)\n", needed_size);
1718 TRACE(" - needed size : %d\n", needed_size);
1721 if (needed_size > size) {
1723 HeapFree(GetProcessHeap(), 0, bitmap);
1724 HeapFree(GetProcessHeap(), 0, gl_bitmap);
1725 bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1726 gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1728 if (GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, NULL) == GDI_ERROR) goto error;
1729 if (TRACE_ON(opengl)) {
1730 unsigned int height, width, bitmask;
1731 unsigned char *bitmap_ = (unsigned char *) bitmap;
1733 TRACE(" - bbox : %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
1734 TRACE(" - origin : (%d , %d)\n", gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
1735 TRACE(" - increment : %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
1736 if (needed_size != 0) {
1737 TRACE(" - bitmap :\n");
1738 for (height = 0; height < gm.gmBlackBoxY; height++) {
1740 for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++, bitmask >>= 1) {
1745 if (*bitmap_ & bitmask)
1750 bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
1756 /* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to invert the
1757 * glyph for it to be drawn properly.
1759 if (needed_size != 0) {
1760 width_int = (gm.gmBlackBoxX + 31) / 32;
1761 for (height = 0; height < gm.gmBlackBoxY; height++) {
1763 for (width = 0; width < width_int; width++) {
1764 ((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int + width] =
1765 ((int *) bitmap)[height * width_int + width];
1771 pglNewList(listBase++, GL_COMPILE);
1772 if (needed_size != 0) {
1773 pglBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
1774 0 - (int) gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - (int) gm.gmptGlyphOrigin.y,
1775 gm.gmCellIncX, gm.gmCellIncY,
1778 /* This is the case of 'empty' glyphs like the space character */
1779 pglBitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
1782 wine_tsx11_unlock();
1786 pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
1787 wine_tsx11_unlock();
1789 HeapFree(GetProcessHeap(), 0, bitmap);
1790 HeapFree(GetProcessHeap(), 0, gl_bitmap);
1795 pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
1796 wine_tsx11_unlock();
1798 HeapFree(GetProcessHeap(), 0, bitmap);
1799 HeapFree(GetProcessHeap(), 0, gl_bitmap);
1804 * X11DRV_wglUseFontBitmapsA
1806 * For OpenGL32 wglUseFontBitmapsA.
1808 BOOL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
1810 Font fid = physDev->font;
1812 TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
1814 if (!has_opengl()) {
1815 ERR("No libGL on this box - disabling OpenGL support !\n");
1820 return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineA);
1824 /* I assume that the glyphs are at the same position for X and for Windows */
1825 pglXUseXFont(fid, first, count, listBase);
1826 wine_tsx11_unlock();
1831 * X11DRV_wglUseFontBitmapsW
1833 * For OpenGL32 wglUseFontBitmapsW.
1835 BOOL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
1837 Font fid = physDev->font;
1839 TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
1841 if (!has_opengl()) {
1842 ERR("No libGL on this box - disabling OpenGL support !\n");
1847 return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineW);
1850 WARN("Using the glX API for the WCHAR variant - some characters may come out incorrectly !\n");
1853 /* I assume that the glyphs are at the same position for X and for Windows */
1854 pglXUseXFont(fid, first, count, listBase);
1855 wine_tsx11_unlock();
1859 static void WINAPI X11DRV_wglDisable(GLenum cap)
1861 if (cap == GL_SCISSOR_TEST)
1863 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1866 ctx->scissor_enabled = FALSE;
1872 wine_tsx11_unlock();
1876 static void WINAPI X11DRV_wglEnable(GLenum cap)
1878 if (cap == GL_SCISSOR_TEST)
1880 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1883 ctx->scissor_enabled = TRUE;
1889 wine_tsx11_unlock();
1893 /* WGL helper function which handles differences in glGetIntegerv from WGL and GLX */
1894 static void WINAPI X11DRV_wglGetIntegerv(GLenum pname, GLint* params)
1901 GLXContext gl_ctx = pglXGetCurrentContext();
1902 Wine_GLContext* ret = get_context_from_GLXContext(gl_ctx);
1904 pglGetIntegerv(pname, params);
1906 * if we cannot find a Wine Context
1907 * we only have the default wine desktop context,
1908 * so if we have only a 24 depth say we have 32
1910 if (NULL == ret && 24 == *params) {
1913 TRACE("returns GL_DEPTH_BITS as '%d'\n", *params);
1918 GLXContext gl_ctx = pglXGetCurrentContext();
1919 Wine_GLContext* ret = get_context_from_GLXContext(gl_ctx);
1921 pglXGetFBConfigAttrib(gdi_display, ret->fmt->fbconfig, GLX_ALPHA_SIZE, params);
1922 TRACE("returns GL_ALPHA_BITS as '%d'\n", *params);
1926 pglGetIntegerv(pname, params);
1929 wine_tsx11_unlock();
1932 static GLboolean WINAPI X11DRV_wglIsEnabled(GLenum cap)
1934 GLboolean enabled = False;
1936 if (cap == GL_SCISSOR_TEST)
1938 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1941 enabled = ctx->scissor_enabled;
1946 enabled = pglIsEnabled(cap);
1947 wine_tsx11_unlock();
1952 static void WINAPI X11DRV_wglScissor(GLint x, GLint y, GLsizei width, GLsizei height)
1954 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1958 ctx->scissor.left = x;
1959 ctx->scissor.top = y;
1960 ctx->scissor.right = x + width;
1961 ctx->scissor.bottom = y + height;
1963 sync_current_drawable(TRUE);
1967 static void WINAPI X11DRV_wglViewport(GLint x, GLint y, GLsizei width, GLsizei height)
1969 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1973 ctx->viewport.left = x;
1974 ctx->viewport.top = y;
1975 ctx->viewport.right = x + width;
1976 ctx->viewport.bottom = y + height;
1978 sync_current_drawable(TRUE);
1983 * X11DRV_wglGetExtensionsStringARB
1985 * WGL_ARB_extensions_string: wglGetExtensionsStringARB
1987 static const char * WINAPI X11DRV_wglGetExtensionsStringARB(HDC hdc) {
1988 TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
1989 return WineGLInfo.wglExtensions;
1993 * X11DRV_wglCreatePbufferARB
1995 * WGL_ARB_pbuffer: wglCreatePbufferARB
1997 static HPBUFFERARB WINAPI X11DRV_wglCreatePbufferARB(HDC hdc, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList)
1999 Wine_GLPBuffer* object = NULL;
2000 WineGLPixelFormat *fmt = NULL;
2005 TRACE("(%p, %d, %d, %d, %p)\n", hdc, iPixelFormat, iWidth, iHeight, piAttribList);
2007 if (0 >= iPixelFormat) {
2008 ERR("(%p): unexpected iPixelFormat(%d) <= 0, returns NULL\n", hdc, iPixelFormat);
2009 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2010 return NULL; /* unexpected error */
2013 /* Convert the WGL pixelformat to a GLX format, if it fails then the format is invalid */
2014 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, TRUE /* Offscreen */, &nCfgs);
2016 ERR("(%p): unexpected iPixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, iPixelFormat, nCfgs);
2017 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2018 goto create_failed; /* unexpected error */
2021 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLPBuffer));
2022 if (NULL == object) {
2023 SetLastError(ERROR_NO_SYSTEM_RESOURCES);
2024 goto create_failed; /* unexpected error */
2027 object->display = gdi_display;
2028 object->width = iWidth;
2029 object->height = iHeight;
2032 PUSH2(attribs, GLX_PBUFFER_WIDTH, iWidth);
2033 PUSH2(attribs, GLX_PBUFFER_HEIGHT, iHeight);
2034 while (piAttribList && 0 != *piAttribList) {
2036 switch (*piAttribList) {
2037 case WGL_PBUFFER_LARGEST_ARB: {
2039 attr_v = *piAttribList;
2040 TRACE("WGL_LARGEST_PBUFFER_ARB = %d\n", attr_v);
2041 PUSH2(attribs, GLX_LARGEST_PBUFFER, attr_v);
2045 case WGL_TEXTURE_FORMAT_ARB: {
2047 attr_v = *piAttribList;
2048 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_FORMAT_ARB as %x\n", attr_v);
2049 if (use_render_texture_ati) {
2052 case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
2053 case WGL_TEXTURE_RGB_ARB: type = GLX_TEXTURE_RGB_ATI; break ;
2054 case WGL_TEXTURE_RGBA_ARB: type = GLX_TEXTURE_RGBA_ATI; break ;
2056 SetLastError(ERROR_INVALID_DATA);
2059 object->use_render_texture = 1;
2060 PUSH2(attribs, GLX_TEXTURE_FORMAT_ATI, type);
2062 if (WGL_NO_TEXTURE_ARB == attr_v) {
2063 object->use_render_texture = 0;
2065 if (!use_render_texture_emulation) {
2066 SetLastError(ERROR_INVALID_DATA);
2070 case WGL_TEXTURE_RGB_ARB:
2071 object->use_render_texture = GL_RGB;
2072 object->texture_bpp = 3;
2073 object->texture_format = GL_RGB;
2074 object->texture_type = GL_UNSIGNED_BYTE;
2076 case WGL_TEXTURE_RGBA_ARB:
2077 object->use_render_texture = GL_RGBA;
2078 object->texture_bpp = 4;
2079 object->texture_format = GL_RGBA;
2080 object->texture_type = GL_UNSIGNED_BYTE;
2083 /* WGL_FLOAT_COMPONENTS_NV */
2084 case WGL_TEXTURE_FLOAT_R_NV:
2085 object->use_render_texture = GL_FLOAT_R_NV;
2086 object->texture_bpp = 4;
2087 object->texture_format = GL_RED;
2088 object->texture_type = GL_FLOAT;
2090 case WGL_TEXTURE_FLOAT_RG_NV:
2091 object->use_render_texture = GL_FLOAT_RG_NV;
2092 object->texture_bpp = 8;
2093 object->texture_format = GL_LUMINANCE_ALPHA;
2094 object->texture_type = GL_FLOAT;
2096 case WGL_TEXTURE_FLOAT_RGB_NV:
2097 object->use_render_texture = GL_FLOAT_RGB_NV;
2098 object->texture_bpp = 12;
2099 object->texture_format = GL_RGB;
2100 object->texture_type = GL_FLOAT;
2102 case WGL_TEXTURE_FLOAT_RGBA_NV:
2103 object->use_render_texture = GL_FLOAT_RGBA_NV;
2104 object->texture_bpp = 16;
2105 object->texture_format = GL_RGBA;
2106 object->texture_type = GL_FLOAT;
2109 ERR("Unknown texture format: %x\n", attr_v);
2110 SetLastError(ERROR_INVALID_DATA);
2118 case WGL_TEXTURE_TARGET_ARB: {
2120 attr_v = *piAttribList;
2121 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_TARGET_ARB as %x\n", attr_v);
2122 if (use_render_texture_ati) {
2125 case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
2126 case WGL_TEXTURE_CUBE_MAP_ARB: type = GLX_TEXTURE_CUBE_MAP_ATI; break ;
2127 case WGL_TEXTURE_1D_ARB: type = GLX_TEXTURE_1D_ATI; break ;
2128 case WGL_TEXTURE_2D_ARB: type = GLX_TEXTURE_2D_ATI; break ;
2130 SetLastError(ERROR_INVALID_DATA);
2133 PUSH2(attribs, GLX_TEXTURE_TARGET_ATI, type);
2135 if (WGL_NO_TEXTURE_ARB == attr_v) {
2136 object->texture_target = 0;
2138 if (!use_render_texture_emulation) {
2139 SetLastError(ERROR_INVALID_DATA);
2143 case WGL_TEXTURE_CUBE_MAP_ARB: {
2144 if (iWidth != iHeight) {
2145 SetLastError(ERROR_INVALID_DATA);
2148 object->texture_target = GL_TEXTURE_CUBE_MAP;
2149 object->texture_bind_target = GL_TEXTURE_BINDING_CUBE_MAP;
2152 case WGL_TEXTURE_1D_ARB: {
2154 SetLastError(ERROR_INVALID_DATA);
2157 object->texture_target = GL_TEXTURE_1D;
2158 object->texture_bind_target = GL_TEXTURE_BINDING_1D;
2161 case WGL_TEXTURE_2D_ARB: {
2162 object->texture_target = GL_TEXTURE_2D;
2163 object->texture_bind_target = GL_TEXTURE_BINDING_2D;
2166 case WGL_TEXTURE_RECTANGLE_NV: {
2167 object->texture_target = GL_TEXTURE_RECTANGLE_NV;
2168 object->texture_bind_target = GL_TEXTURE_BINDING_RECTANGLE_NV;
2172 ERR("Unknown texture target: %x\n", attr_v);
2173 SetLastError(ERROR_INVALID_DATA);
2181 case WGL_MIPMAP_TEXTURE_ARB: {
2183 attr_v = *piAttribList;
2184 TRACE("WGL_render_texture Attribute: WGL_MIPMAP_TEXTURE_ARB as %x\n", attr_v);
2185 if (use_render_texture_ati) {
2186 PUSH2(attribs, GLX_MIPMAP_TEXTURE_ATI, attr_v);
2188 if (!use_render_texture_emulation) {
2189 SetLastError(ERROR_INVALID_DATA);
2199 PUSH1(attribs, None);
2200 object->drawable = pglXCreatePbuffer(gdi_display, fmt->fbconfig, attribs);
2201 TRACE("new Pbuffer drawable as %p\n", (void*) object->drawable);
2202 if (!object->drawable) {
2203 SetLastError(ERROR_NO_SYSTEM_RESOURCES);
2204 goto create_failed; /* unexpected error */
2206 TRACE("->(%p)\n", object);
2207 return (HPBUFFERARB) object;
2210 HeapFree(GetProcessHeap(), 0, object);
2211 TRACE("->(FAILED)\n");
2212 return (HPBUFFERARB) NULL;
2216 * X11DRV_wglDestroyPbufferARB
2218 * WGL_ARB_pbuffer: wglDestroyPbufferARB
2220 static GLboolean WINAPI X11DRV_wglDestroyPbufferARB(HPBUFFERARB hPbuffer)
2222 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2223 TRACE("(%p)\n", hPbuffer);
2224 if (NULL == object) {
2225 SetLastError(ERROR_INVALID_HANDLE);
2228 pglXDestroyPbuffer(object->display, object->drawable);
2229 HeapFree(GetProcessHeap(), 0, object);
2234 * X11DRV_wglGetPbufferDCARB
2236 * WGL_ARB_pbuffer: wglGetPbufferDCARB
2237 * The function wglGetPbufferDCARB returns a device context for a pbuffer.
2238 * Gdi32 implements the part of this function which creates a device context.
2239 * This part associates the physDev with the X drawable of the pbuffer.
2241 HDC X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *physDev, HPBUFFERARB hPbuffer)
2243 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2244 if (NULL == object) {
2245 SetLastError(ERROR_INVALID_HANDLE);
2249 /* The function wglGetPbufferDCARB returns a DC to which the pbuffer can be connected.
2250 * All formats in our pixelformat list are compatible with each other and the main drawable. */
2251 physDev->current_pf = object->fmt->iPixelFormat;
2252 physDev->drawable = object->drawable;
2253 SetRect( &physDev->drawable_rect, 0, 0, object->width, object->height );
2254 physDev->dc_rect = physDev->drawable_rect;
2256 TRACE("(%p)->(%p)\n", hPbuffer, physDev->hdc);
2257 return physDev->hdc;
2261 * X11DRV_wglQueryPbufferARB
2263 * WGL_ARB_pbuffer: wglQueryPbufferARB
2265 static GLboolean WINAPI X11DRV_wglQueryPbufferARB(HPBUFFERARB hPbuffer, int iAttribute, int *piValue)
2267 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2268 TRACE("(%p, 0x%x, %p)\n", hPbuffer, iAttribute, piValue);
2269 if (NULL == object) {
2270 SetLastError(ERROR_INVALID_HANDLE);
2273 switch (iAttribute) {
2274 case WGL_PBUFFER_WIDTH_ARB:
2275 pglXQueryDrawable(object->display, object->drawable, GLX_WIDTH, (unsigned int*) piValue);
2277 case WGL_PBUFFER_HEIGHT_ARB:
2278 pglXQueryDrawable(object->display, object->drawable, GLX_HEIGHT, (unsigned int*) piValue);
2281 case WGL_PBUFFER_LOST_ARB:
2282 FIXME("unsupported WGL_PBUFFER_LOST_ARB (need glXSelectEvent/GLX_DAMAGED work)\n");
2285 case WGL_TEXTURE_FORMAT_ARB:
2286 if (use_render_texture_ati) {
2288 int type = WGL_NO_TEXTURE_ARB;
2289 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_FORMAT_ATI, &tmp);
2291 case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2292 case GLX_TEXTURE_RGB_ATI: type = WGL_TEXTURE_RGB_ARB; break ;
2293 case GLX_TEXTURE_RGBA_ATI: type = WGL_TEXTURE_RGBA_ARB; break ;
2297 if (!object->use_render_texture) {
2298 *piValue = WGL_NO_TEXTURE_ARB;
2300 if (!use_render_texture_emulation) {
2301 SetLastError(ERROR_INVALID_HANDLE);
2304 switch(object->use_render_texture) {
2306 *piValue = WGL_TEXTURE_RGB_ARB;
2309 *piValue = WGL_TEXTURE_RGBA_ARB;
2311 /* WGL_FLOAT_COMPONENTS_NV */
2313 *piValue = WGL_TEXTURE_FLOAT_R_NV;
2315 case GL_FLOAT_RG_NV:
2316 *piValue = WGL_TEXTURE_FLOAT_RG_NV;
2318 case GL_FLOAT_RGB_NV:
2319 *piValue = WGL_TEXTURE_FLOAT_RGB_NV;
2321 case GL_FLOAT_RGBA_NV:
2322 *piValue = WGL_TEXTURE_FLOAT_RGBA_NV;
2325 ERR("Unknown texture format: %x\n", object->use_render_texture);
2331 case WGL_TEXTURE_TARGET_ARB:
2332 if (use_render_texture_ati) {
2334 int type = WGL_NO_TEXTURE_ARB;
2335 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_TARGET_ATI, &tmp);
2337 case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2338 case GLX_TEXTURE_CUBE_MAP_ATI: type = WGL_TEXTURE_CUBE_MAP_ARB; break ;
2339 case GLX_TEXTURE_1D_ATI: type = WGL_TEXTURE_1D_ARB; break ;
2340 case GLX_TEXTURE_2D_ATI: type = WGL_TEXTURE_2D_ARB; break ;
2344 if (!object->texture_target) {
2345 *piValue = WGL_NO_TEXTURE_ARB;
2347 if (!use_render_texture_emulation) {
2348 SetLastError(ERROR_INVALID_DATA);
2351 switch (object->texture_target) {
2352 case GL_TEXTURE_1D: *piValue = WGL_TEXTURE_1D_ARB; break;
2353 case GL_TEXTURE_2D: *piValue = WGL_TEXTURE_2D_ARB; break;
2354 case GL_TEXTURE_CUBE_MAP: *piValue = WGL_TEXTURE_CUBE_MAP_ARB; break;
2355 case GL_TEXTURE_RECTANGLE_NV: *piValue = WGL_TEXTURE_RECTANGLE_NV; break;
2361 case WGL_MIPMAP_TEXTURE_ARB:
2362 if (use_render_texture_ati) {
2363 pglXQueryDrawable(object->display, object->drawable, GLX_MIPMAP_TEXTURE_ATI, (unsigned int*) piValue);
2365 *piValue = GL_FALSE; /** don't support that */
2366 FIXME("unsupported WGL_ARB_render_texture attribute query for 0x%x\n", iAttribute);
2371 FIXME("unexpected attribute %x\n", iAttribute);
2379 * X11DRV_wglReleasePbufferDCARB
2381 * WGL_ARB_pbuffer: wglReleasePbufferDCARB
2383 static int WINAPI X11DRV_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer, HDC hdc)
2385 TRACE("(%p, %p)\n", hPbuffer, hdc);
2391 * X11DRV_wglSetPbufferAttribARB
2393 * WGL_ARB_pbuffer: wglSetPbufferAttribARB
2395 static GLboolean WINAPI X11DRV_wglSetPbufferAttribARB(HPBUFFERARB hPbuffer, const int *piAttribList)
2397 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2398 WARN("(%p, %p): alpha-testing, report any problem\n", hPbuffer, piAttribList);
2399 if (NULL == object) {
2400 SetLastError(ERROR_INVALID_HANDLE);
2403 if (!object->use_render_texture) {
2404 SetLastError(ERROR_INVALID_HANDLE);
2407 if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2410 if (NULL != pglXDrawableAttribARB) {
2411 if (use_render_texture_ati) {
2412 FIXME("Need conversion for GLX_ATI_render_texture\n");
2414 return pglXDrawableAttribARB(object->display, object->drawable, piAttribList);
2420 * X11DRV_wglChoosePixelFormatARB
2422 * WGL_ARB_pixel_format: wglChoosePixelFormatARB
2424 static GLboolean WINAPI X11DRV_wglChoosePixelFormatARB(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
2429 GLXFBConfig* cfgs = NULL;
2436 TRACE("(%p, %p, %p, %d, %p, %p): hackish\n", hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
2437 if (NULL != pfAttribFList) {
2438 FIXME("unused pfAttribFList\n");
2441 nAttribs = ConvertAttribWGLtoGLX(piAttribIList, attribs, NULL);
2442 if (-1 == nAttribs) {
2443 WARN("Cannot convert WGL to GLX attributes\n");
2446 PUSH1(attribs, None);
2448 /* Search for FB configurations matching the requirements in attribs */
2449 cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), attribs, &nCfgs);
2451 WARN("Compatible Pixel Format not found\n");
2455 /* Loop through all matching formats and check if they are suitable.
2456 * Note that this function should at max return nMaxFormats different formats */
2457 for (it = 0; it < nCfgs; ++it) {
2458 gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs[it], GLX_FBCONFIG_ID, &fmt_id);
2460 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
2464 /* Search for the format in our list of compatible formats */
2465 fmt = ConvertPixelFormatGLXtoWGL(gdi_display, fmt_id);
2469 if(pfmt_it < nMaxFormats) {
2470 piFormats[pfmt_it] = fmt;
2471 TRACE("at %d/%d found FBCONFIG_ID 0x%x (%d)\n", it + 1, nCfgs, fmt_id, piFormats[pfmt_it]);
2476 *nNumFormats = pfmt_it;
2483 * X11DRV_wglGetPixelFormatAttribivARB
2485 * WGL_ARB_pixel_format: wglGetPixelFormatAttribivARB
2487 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues)
2490 WineGLPixelFormat *fmt = NULL;
2494 int nWGLFormats = 0;
2496 TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
2498 if (0 < iLayerPlane) {
2499 FIXME("unsupported iLayerPlane(%d) > 0, returns FALSE\n", iLayerPlane);
2503 /* Convert the WGL pixelformat to a GLX one, if this fails then most likely the iPixelFormat isn't supoprted.
2504 * We don't have to fail yet as a program can specify an invaled iPixelFormat (lets say 0) if it wants to query
2505 * the number of supported WGL formats. Whether the iPixelFormat is valid is handled in the for-loop below. */
2506 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, TRUE /* Offscreen */, &nWGLFormats);
2508 WARN("Unable to convert iPixelFormat %d to a GLX one!\n", iPixelFormat);
2511 for (i = 0; i < nAttributes; ++i) {
2512 const int curWGLAttr = piAttributes[i];
2513 TRACE("pAttr[%d] = %x\n", i, curWGLAttr);
2515 switch (curWGLAttr) {
2516 case WGL_NUMBER_PIXEL_FORMATS_ARB:
2517 piValues[i] = nWGLFormats;
2520 case WGL_SUPPORT_OPENGL_ARB:
2521 piValues[i] = GL_TRUE;
2524 case WGL_ACCELERATION_ARB:
2525 curGLXAttr = GLX_CONFIG_CAVEAT;
2526 if (!fmt) goto pix_error;
2527 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2528 if (hTest) goto get_error;
2530 case GLX_NONE: piValues[i] = WGL_FULL_ACCELERATION_ARB; break;
2531 case GLX_SLOW_CONFIG: piValues[i] = WGL_NO_ACCELERATION_ARB; break;
2532 case GLX_NON_CONFORMANT_CONFIG: piValues[i] = WGL_FULL_ACCELERATION_ARB; break;
2534 ERR("unexpected Config Caveat(%x)\n", tmp);
2535 piValues[i] = WGL_NO_ACCELERATION_ARB;
2539 case WGL_TRANSPARENT_ARB:
2540 curGLXAttr = GLX_TRANSPARENT_TYPE;
2541 if (!fmt) goto pix_error;
2542 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2543 if (hTest) goto get_error;
2544 piValues[i] = GL_FALSE;
2545 if (GLX_NONE != tmp) piValues[i] = GL_TRUE;
2548 case WGL_PIXEL_TYPE_ARB:
2549 curGLXAttr = GLX_RENDER_TYPE;
2550 if (!fmt) goto pix_error;
2551 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2552 if (hTest) goto get_error;
2553 TRACE("WGL_PIXEL_TYPE_ARB: GLX_RENDER_TYPE = 0x%x\n", tmp);
2554 if (tmp & GLX_RGBA_BIT) { piValues[i] = WGL_TYPE_RGBA_ARB; }
2555 else if (tmp & GLX_COLOR_INDEX_BIT) { piValues[i] = WGL_TYPE_COLORINDEX_ARB; }
2556 else if (tmp & GLX_RGBA_FLOAT_BIT) { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
2557 else if (tmp & GLX_RGBA_FLOAT_ATI_BIT) { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
2559 ERR("unexpected RenderType(%x)\n", tmp);
2560 piValues[i] = WGL_TYPE_RGBA_ARB;
2564 case WGL_COLOR_BITS_ARB:
2565 curGLXAttr = GLX_BUFFER_SIZE;
2568 case WGL_BIND_TO_TEXTURE_RGB_ARB:
2569 if (use_render_texture_ati) {
2570 curGLXAttr = GLX_BIND_TO_TEXTURE_RGB_ATI;
2573 case WGL_BIND_TO_TEXTURE_RGBA_ARB:
2574 if (use_render_texture_ati) {
2575 curGLXAttr = GLX_BIND_TO_TEXTURE_RGBA_ATI;
2578 if (!use_render_texture_emulation) {
2579 piValues[i] = GL_FALSE;
2582 curGLXAttr = GLX_RENDER_TYPE;
2583 if (!fmt) goto pix_error;
2584 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2585 if (hTest) goto get_error;
2586 if (GLX_COLOR_INDEX_BIT == tmp) {
2587 piValues[i] = GL_FALSE;
2590 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
2591 if (hTest) goto get_error;
2592 piValues[i] = (tmp & GLX_PBUFFER_BIT) ? GL_TRUE : GL_FALSE;
2595 case WGL_BLUE_BITS_ARB:
2596 curGLXAttr = GLX_BLUE_SIZE;
2598 case WGL_RED_BITS_ARB:
2599 curGLXAttr = GLX_RED_SIZE;
2601 case WGL_GREEN_BITS_ARB:
2602 curGLXAttr = GLX_GREEN_SIZE;
2604 case WGL_ALPHA_BITS_ARB:
2605 curGLXAttr = GLX_ALPHA_SIZE;
2607 case WGL_DEPTH_BITS_ARB:
2608 curGLXAttr = GLX_DEPTH_SIZE;
2610 case WGL_STENCIL_BITS_ARB:
2611 curGLXAttr = GLX_STENCIL_SIZE;
2613 case WGL_DOUBLE_BUFFER_ARB:
2614 curGLXAttr = GLX_DOUBLEBUFFER;
2616 case WGL_STEREO_ARB:
2617 curGLXAttr = GLX_STEREO;
2619 case WGL_AUX_BUFFERS_ARB:
2620 curGLXAttr = GLX_AUX_BUFFERS;
2623 case WGL_SUPPORT_GDI_ARB:
2624 curGLXAttr = GLX_X_RENDERABLE;
2627 case WGL_DRAW_TO_WINDOW_ARB:
2628 case WGL_DRAW_TO_BITMAP_ARB:
2629 case WGL_DRAW_TO_PBUFFER_ARB:
2630 if (!fmt) goto pix_error;
2631 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
2632 if (hTest) goto get_error;
2633 if((curWGLAttr == WGL_DRAW_TO_WINDOW_ARB && (tmp&GLX_WINDOW_BIT)) ||
2634 (curWGLAttr == WGL_DRAW_TO_BITMAP_ARB && (tmp&GLX_PIXMAP_BIT)) ||
2635 (curWGLAttr == WGL_DRAW_TO_PBUFFER_ARB && (tmp&GLX_PBUFFER_BIT)))
2636 piValues[i] = GL_TRUE;
2638 piValues[i] = GL_FALSE;
2641 case WGL_PBUFFER_LARGEST_ARB:
2642 curGLXAttr = GLX_LARGEST_PBUFFER;
2645 case WGL_SAMPLE_BUFFERS_ARB:
2646 curGLXAttr = GLX_SAMPLE_BUFFERS_ARB;
2649 case WGL_SAMPLES_ARB:
2650 curGLXAttr = GLX_SAMPLES_ARB;
2653 case WGL_FLOAT_COMPONENTS_NV:
2654 curGLXAttr = GLX_FLOAT_COMPONENTS_NV;
2657 case WGL_ACCUM_RED_BITS_ARB:
2658 curGLXAttr = GLX_ACCUM_RED_SIZE;
2660 case WGL_ACCUM_GREEN_BITS_ARB:
2661 curGLXAttr = GLX_ACCUM_GREEN_SIZE;
2663 case WGL_ACCUM_BLUE_BITS_ARB:
2664 curGLXAttr = GLX_ACCUM_BLUE_SIZE;
2666 case WGL_ACCUM_ALPHA_BITS_ARB:
2667 curGLXAttr = GLX_ACCUM_ALPHA_SIZE;
2669 case WGL_ACCUM_BITS_ARB:
2670 if (!fmt) goto pix_error;
2671 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_RED_SIZE, &tmp);
2672 if (hTest) goto get_error;
2674 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_GREEN_SIZE, &tmp);
2675 if (hTest) goto get_error;
2677 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_BLUE_SIZE, &tmp);
2678 if (hTest) goto get_error;
2680 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_ALPHA_SIZE, &tmp);
2681 if (hTest) goto get_error;
2686 FIXME("unsupported %x WGL Attribute\n", curWGLAttr);
2689 /* Retrieve a GLX FBConfigAttrib when the attribute to query is valid and
2690 * iPixelFormat != 0. When iPixelFormat is 0 the only value which makes
2691 * sense to query is WGL_NUMBER_PIXEL_FORMATS_ARB.
2693 * TODO: properly test the behavior of wglGetPixelFormatAttrib*v on Windows
2694 * and check which options can work using iPixelFormat=0 and which not.
2695 * A problem would be that this function is an extension. This would
2696 * mean that the behavior could differ between different vendors (ATI, Nvidia, ..).
2698 if (0 != curGLXAttr && iPixelFormat != 0) {
2699 if (!fmt) goto pix_error;
2700 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, piValues + i);
2701 if (hTest) goto get_error;
2704 piValues[i] = GL_FALSE;
2710 ERR("(%p): unexpected failure on GetFBConfigAttrib(%x) returns FALSE\n", hdc, curGLXAttr);
2714 ERR("(%p): unexpected iPixelFormat(%d) vs nFormats(%d), returns FALSE\n", hdc, iPixelFormat, nWGLFormats);
2719 * X11DRV_wglGetPixelFormatAttribfvARB
2721 * WGL_ARB_pixel_format: wglGetPixelFormatAttribfvARB
2723 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues)
2729 TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
2731 /* Allocate a temporary array to store integer values */
2732 attr = HeapAlloc(GetProcessHeap(), 0, nAttributes * sizeof(int));
2734 ERR("couldn't allocate %d array\n", nAttributes);
2738 /* Piggy-back on wglGetPixelFormatAttribivARB */
2739 ret = X11DRV_wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, attr);
2741 /* Convert integer values to float. Should also check for attributes
2742 that can give decimal values here */
2743 for (i=0; i<nAttributes;i++) {
2744 pfValues[i] = attr[i];
2748 HeapFree(GetProcessHeap(), 0, attr);
2753 * X11DRV_wglBindTexImageARB
2755 * WGL_ARB_render_texture: wglBindTexImageARB
2757 static GLboolean WINAPI X11DRV_wglBindTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
2759 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2760 TRACE("(%p, %d)\n", hPbuffer, iBuffer);
2761 if (NULL == object) {
2762 SetLastError(ERROR_INVALID_HANDLE);
2765 if (!object->use_render_texture) {
2766 SetLastError(ERROR_INVALID_HANDLE);
2770 if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2771 static int init = 0;
2772 int prev_binded_texture = 0;
2773 GLXContext prev_context = pglXGetCurrentContext();
2774 Drawable prev_drawable = pglXGetCurrentDrawable();
2775 GLXContext tmp_context;
2777 /* Our render_texture emulation is basic and lacks some features (1D/Cube support).
2778 This is mostly due to lack of demos/games using them. Further the use of glReadPixels
2779 isn't ideal performance wise but I wasn't able to get other ways working.
2782 init = 1; /* Only show the FIXME once for performance reasons */
2783 FIXME("partial stub!\n");
2786 TRACE("drawable=%p, context=%p\n", (void*)object->drawable, prev_context);
2787 tmp_context = pglXCreateNewContext(gdi_display, object->fmt->fbconfig, object->fmt->render_type, prev_context, True);
2789 pglGetIntegerv(object->texture_bind_target, &prev_binded_texture);
2791 /* Switch to our pbuffer */
2792 pglXMakeCurrent(gdi_display, object->drawable, tmp_context);
2794 /* Make sure that the prev_binded_texture is set as the current texture state isn't shared between contexts.
2795 * After that upload the pbuffer texture data. */
2796 pglBindTexture(object->texture_target, prev_binded_texture);
2797 pglCopyTexImage2D(object->texture_target, 0, object->use_render_texture, 0, 0, object->width, object->height, 0);
2799 /* Switch back to the original drawable and upload the pbuffer-texture */
2800 pglXMakeCurrent(object->display, prev_drawable, prev_context);
2801 pglXDestroyContext(gdi_display, tmp_context);
2805 if (NULL != pglXBindTexImageARB) {
2806 return pglXBindTexImageARB(object->display, object->drawable, iBuffer);
2812 * X11DRV_wglReleaseTexImageARB
2814 * WGL_ARB_render_texture: wglReleaseTexImageARB
2816 static GLboolean WINAPI X11DRV_wglReleaseTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
2818 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2819 TRACE("(%p, %d)\n", hPbuffer, iBuffer);
2820 if (NULL == object) {
2821 SetLastError(ERROR_INVALID_HANDLE);
2824 if (!object->use_render_texture) {
2825 SetLastError(ERROR_INVALID_HANDLE);
2828 if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2831 if (NULL != pglXReleaseTexImageARB) {
2832 return pglXReleaseTexImageARB(object->display, object->drawable, iBuffer);
2838 * X11DRV_wglGetExtensionsStringEXT
2840 * WGL_EXT_extensions_string: wglGetExtensionsStringEXT
2842 static const char * WINAPI X11DRV_wglGetExtensionsStringEXT(void) {
2843 TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
2844 return WineGLInfo.wglExtensions;
2848 * X11DRV_wglGetSwapIntervalEXT
2850 * WGL_EXT_swap_control: wglGetSwapIntervalEXT
2852 static int WINAPI X11DRV_wglGetSwapIntervalEXT(VOID) {
2853 FIXME("(),stub!\n");
2854 return swap_interval;
2858 * X11DRV_wglSwapIntervalEXT
2860 * WGL_EXT_swap_control: wglSwapIntervalEXT
2862 static BOOL WINAPI X11DRV_wglSwapIntervalEXT(int interval) {
2863 TRACE("(%d)\n", interval);
2864 swap_interval = interval;
2865 if (NULL != pglXSwapIntervalSGI) {
2866 return 0 == pglXSwapIntervalSGI(interval);
2868 WARN("(): GLX_SGI_swap_control extension seems not supported\n");
2873 * X11DRV_wglAllocateMemoryNV
2875 * WGL_NV_vertex_array_range: wglAllocateMemoryNV
2877 static void* WINAPI X11DRV_wglAllocateMemoryNV(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority) {
2878 TRACE("(%d, %f, %f, %f)\n", size, readfreq, writefreq, priority );
2879 if (pglXAllocateMemoryNV == NULL)
2882 return pglXAllocateMemoryNV(size, readfreq, writefreq, priority);
2886 * X11DRV_wglFreeMemoryNV
2888 * WGL_NV_vertex_array_range: wglFreeMemoryNV
2890 static void WINAPI X11DRV_wglFreeMemoryNV(GLvoid* pointer) {
2891 TRACE("(%p)\n", pointer);
2892 if (pglXFreeMemoryNV == NULL)
2895 pglXFreeMemoryNV(pointer);
2899 * glxRequireVersion (internal)
2901 * Check if the supported GLX version matches requiredVersion.
2903 static BOOL glxRequireVersion(int requiredVersion)
2905 /* Both requiredVersion and glXVersion[1] contains the minor GLX version */
2906 if(requiredVersion <= WineGLInfo.glxVersion[1])
2912 static BOOL glxRequireExtension(const char *requiredExtension)
2914 if (strstr(WineGLInfo.glxClientExtensions, requiredExtension) == NULL) {
2921 static void register_extension_string(const char *ext)
2923 strcat(WineGLInfo.wglExtensions, " ");
2924 strcat(WineGLInfo.wglExtensions, ext);
2926 TRACE("'%s'\n", ext);
2929 static BOOL register_extension(const WineGLExtension * ext)
2933 assert( WineGLExtensionListSize < MAX_EXTENSIONS );
2934 WineGLExtensionList[WineGLExtensionListSize++] = ext;
2936 strcat(WineGLInfo.wglExtensions, " ");
2937 strcat(WineGLInfo.wglExtensions, ext->extName);
2939 TRACE("'%s'\n", ext->extName);
2941 for (i = 0; ext->extEntryPoints[i].funcName; ++i)
2942 TRACE(" - '%s'\n", ext->extEntryPoints[i].funcName);
2947 static const WineGLExtension WGL_internal_functions =
2951 { "wglDisable", X11DRV_wglDisable },
2952 { "wglEnable", X11DRV_wglEnable },
2953 { "wglGetIntegerv", X11DRV_wglGetIntegerv },
2954 { "wglIsEnabled", X11DRV_wglIsEnabled },
2955 { "wglScissor", X11DRV_wglScissor },
2956 { "wglViewport", X11DRV_wglViewport },
2961 static const WineGLExtension WGL_ARB_extensions_string =
2963 "WGL_ARB_extensions_string",
2965 { "wglGetExtensionsStringARB", X11DRV_wglGetExtensionsStringARB },
2969 static const WineGLExtension WGL_ARB_make_current_read =
2971 "WGL_ARB_make_current_read",
2973 { "wglGetCurrentReadDCARB", X11DRV_wglGetCurrentReadDCARB },
2974 { "wglMakeContextCurrentARB", X11DRV_wglMakeContextCurrentARB },
2978 static const WineGLExtension WGL_ARB_multisample =
2980 "WGL_ARB_multisample",
2983 static const WineGLExtension WGL_ARB_pbuffer =
2987 { "wglCreatePbufferARB", X11DRV_wglCreatePbufferARB },
2988 { "wglDestroyPbufferARB", X11DRV_wglDestroyPbufferARB },
2989 { "wglGetPbufferDCARB", X11DRV_wglGetPbufferDCARB },
2990 { "wglQueryPbufferARB", X11DRV_wglQueryPbufferARB },
2991 { "wglReleasePbufferDCARB", X11DRV_wglReleasePbufferDCARB },
2992 { "wglSetPbufferAttribARB", X11DRV_wglSetPbufferAttribARB },
2996 static const WineGLExtension WGL_ARB_pixel_format =
2998 "WGL_ARB_pixel_format",
3000 { "wglChoosePixelFormatARB", X11DRV_wglChoosePixelFormatARB },
3001 { "wglGetPixelFormatAttribfvARB", X11DRV_wglGetPixelFormatAttribfvARB },
3002 { "wglGetPixelFormatAttribivARB", X11DRV_wglGetPixelFormatAttribivARB },
3006 static const WineGLExtension WGL_ARB_render_texture =
3008 "WGL_ARB_render_texture",
3010 { "wglBindTexImageARB", X11DRV_wglBindTexImageARB },
3011 { "wglReleaseTexImageARB", X11DRV_wglReleaseTexImageARB },
3015 static const WineGLExtension WGL_EXT_extensions_string =
3017 "WGL_EXT_extensions_string",
3019 { "wglGetExtensionsStringEXT", X11DRV_wglGetExtensionsStringEXT },
3023 static const WineGLExtension WGL_EXT_swap_control =
3025 "WGL_EXT_swap_control",
3027 { "wglSwapIntervalEXT", X11DRV_wglSwapIntervalEXT },
3028 { "wglGetSwapIntervalEXT", X11DRV_wglGetSwapIntervalEXT },
3032 static const WineGLExtension WGL_NV_vertex_array_range =
3034 "WGL_NV_vertex_array_range",
3036 { "wglAllocateMemoryNV", X11DRV_wglAllocateMemoryNV },
3037 { "wglFreeMemoryNV", X11DRV_wglFreeMemoryNV },
3042 * X11DRV_WineGL_LoadExtensions
3044 static void X11DRV_WineGL_LoadExtensions(void)
3046 WineGLInfo.wglExtensions[0] = 0;
3048 /* Load Wine internal functions */
3049 register_extension(&WGL_internal_functions);
3051 /* ARB Extensions */
3053 if(glxRequireExtension("GLX_ARB_fbconfig_float"))
3055 register_extension_string("WGL_ARB_pixel_format_float");
3056 register_extension_string("WGL_ATI_pixel_format_float");
3059 register_extension(&WGL_ARB_extensions_string);
3061 if (glxRequireVersion(3))
3062 register_extension(&WGL_ARB_make_current_read);
3064 if (glxRequireExtension("GLX_ARB_multisample"))
3065 register_extension(&WGL_ARB_multisample);
3067 /* In general pbuffer functionality requires support in the X-server. The functionality is
3068 * available either when the GLX_SGIX_pbuffer is present or when the GLX server version is 1.3.
3069 * All display drivers except for Nvidia's use the GLX module from Xfree86/Xorg which only
3070 * supports GLX 1.2. The endresult is that only Nvidia's drivers support pbuffers.
3072 * The only other drive which has pbuffer support is Ati's FGLRX driver. They provide clientside GLX 1.3 support
3073 * without support in the X-server (which other Mesa based drivers require).
3075 * Support pbuffers when the GLX version is 1.3 and GLX_SGIX_pbuffer is available. Further pbuffers can
3076 * also be supported when GLX_ATI_render_texture is available. This extension depends on pbuffers, so when it
3077 * is available pbuffers must be available too. */
3078 if ( (glxRequireVersion(3) && glxRequireExtension("GLX_SGIX_pbuffer")) || glxRequireExtension("GLX_ATI_render_texture"))
3079 register_extension(&WGL_ARB_pbuffer);
3081 register_extension(&WGL_ARB_pixel_format);
3083 /* Support WGL_ARB_render_texture when there's support or pbuffer based emulation */
3084 if (glxRequireExtension("GLX_ATI_render_texture") ||
3085 glxRequireExtension("GLX_ARB_render_texture") ||
3086 (glxRequireVersion(3) && glxRequireExtension("GLX_SGIX_pbuffer") && use_render_texture_emulation))
3088 register_extension(&WGL_ARB_render_texture);
3090 /* The WGL version of GLX_NV_float_buffer requires render_texture */
3091 if(glxRequireExtension("GLX_NV_float_buffer"))
3092 register_extension_string("WGL_NV_float_buffer");
3094 /* Again there's no GLX equivalent for this extension, so depend on the required GL extension */
3095 if(strstr(WineGLInfo.glExtensions, "GL_NV_texture_rectangle") != NULL)
3096 register_extension_string("WGL_NV_texture_rectangle");
3099 /* EXT Extensions */
3101 register_extension(&WGL_EXT_extensions_string);
3103 /* Load this extension even when it isn't backed by a GLX extension because it is has been around for ages.
3104 * Games like Call of Duty and K.O.T.O.R. rely on it. Further our emulation is good enough. */
3105 register_extension(&WGL_EXT_swap_control);
3107 /* The OpenGL extension GL_NV_vertex_array_range adds wgl/glX functions which aren't exported as 'real' wgl/glX extensions. */
3108 if(strstr(WineGLInfo.glExtensions, "GL_NV_vertex_array_range") != NULL)
3109 register_extension(&WGL_NV_vertex_array_range);
3113 static XID create_glxpixmap(X11DRV_PDEVICE *physDev)
3117 XVisualInfo template;
3122 /* Retrieve the visualid from our main visual which is the only visual we can use */
3123 template.visualid = XVisualIDFromVisual(visual);
3124 vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
3126 ret = pglXCreateGLXPixmap(gdi_display, vis, physDev->bitmap->pixmap);
3128 wine_tsx11_unlock();
3129 TRACE("return %lx\n", ret);
3133 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
3139 if (physDev->bitmap->hbitmap == BITMAP_stock_phys_bitmap.hbitmap)
3140 ret = physDev->drawable; /* PBuffer */
3143 if(!physDev->bitmap->glxpixmap)
3144 physDev->bitmap->glxpixmap = create_glxpixmap(physDev);
3145 ret = physDev->bitmap->glxpixmap;
3149 ret = physDev->drawable;
3153 BOOL destroy_glxpixmap(XID glxpixmap)
3156 pglXDestroyGLXPixmap(gdi_display, glxpixmap);
3157 wine_tsx11_unlock();
3162 * X11DRV_SwapBuffers
3164 * Swap the buffers of this DC
3166 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev)
3168 GLXDrawable drawable;
3169 if (!has_opengl()) {
3170 ERR("No libGL on this box - disabling OpenGL support !\n");
3174 TRACE_(opengl)("(%p)\n", physDev);
3176 drawable = get_glxdrawable(physDev);
3178 pglXSwapBuffers(gdi_display, drawable);
3179 wine_tsx11_unlock();
3184 static long prev_time, frames;
3186 DWORD time = GetTickCount();
3188 /* every 1.5 seconds */
3189 if (time - prev_time > 1500) {
3190 TRACE_(fps)("@ approx %.2ffps\n", 1000.0*frames/(time - prev_time));
3199 /***********************************************************************
3200 * X11DRV_setup_opengl_visual
3202 * Setup the default visual used for OpenGL and Direct3D, and the desktop
3203 * window (if it exists). If OpenGL isn't available, the visual is simply
3204 * set to the default visual for the display
3206 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
3208 XVisualInfo *visual = NULL;
3211 /* In order to support OpenGL or D3D, we require a double-buffered visual and stencil buffer support,
3212 * D3D and some applications can make use of aux buffers.
3214 int visualProperties[][11] = {
3215 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_AUX_BUFFERS, 1, None },
3216 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8, GLX_ALPHA_SIZE, 8, None },
3217 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, None },
3218 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16, None },
3225 for (i = 0; i < sizeof(visualProperties)/sizeof(visualProperties[0]); ++i) {
3226 visual = pglXChooseVisual(display, DefaultScreen(display), visualProperties[i]);
3230 wine_tsx11_unlock();
3233 TRACE("Visual ID %lx Chosen\n", visual->visualid);
3235 WARN("No suitable visual found\n");
3240 #else /* no OpenGL includes */
3242 /***********************************************************************
3243 * ChoosePixelFormat (X11DRV.@)
3245 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
3246 const PIXELFORMATDESCRIPTOR *ppfd) {
3247 ERR("No OpenGL support compiled in.\n");
3252 /***********************************************************************
3253 * DescribePixelFormat (X11DRV.@)
3255 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
3258 PIXELFORMATDESCRIPTOR *ppfd) {
3259 ERR("No OpenGL support compiled in.\n");
3264 /***********************************************************************
3265 * GetPixelFormat (X11DRV.@)
3267 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
3268 ERR("No OpenGL support compiled in.\n");
3273 /***********************************************************************
3274 * SetPixelFormat (X11DRV.@)
3276 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
3278 const PIXELFORMATDESCRIPTOR *ppfd) {
3279 ERR("No OpenGL support compiled in.\n");
3284 /***********************************************************************
3285 * SwapBuffers (X11DRV.@)
3287 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
3288 ERR_(opengl)("No OpenGL support compiled in.\n");
3294 * X11DRV_wglCreateContext
3296 * For OpenGL32 wglCreateContext.
3298 HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev) {
3299 ERR_(opengl)("No OpenGL support compiled in.\n");
3304 * X11DRV_wglDeleteContext
3306 * For OpenGL32 wglDeleteContext.
3308 BOOL X11DRV_wglDeleteContext(HGLRC hglrc) {
3309 ERR_(opengl)("No OpenGL support compiled in.\n");
3314 * X11DRV_wglGetProcAddress
3316 * For OpenGL32 wglGetProcAddress.
3318 PROC X11DRV_wglGetProcAddress(LPCSTR lpszProc) {
3319 ERR_(opengl)("No OpenGL support compiled in.\n");
3323 HDC X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *hDevice, void *hPbuffer)
3325 ERR_(opengl)("No OpenGL support compiled in.\n");
3329 BOOL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* hDrawDev, X11DRV_PDEVICE* hReadDev, HGLRC hglrc) {
3330 ERR_(opengl)("No OpenGL support compiled in.\n");
3335 * X11DRV_wglMakeCurrent
3337 * For OpenGL32 wglMakeCurrent.
3339 BOOL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
3340 ERR_(opengl)("No OpenGL support compiled in.\n");
3345 * X11DRV_wglShareLists
3347 * For OpenGL32 wglShaderLists.
3349 BOOL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
3350 ERR_(opengl)("No OpenGL support compiled in.\n");
3355 * X11DRV_wglUseFontBitmapsA
3357 * For OpenGL32 wglUseFontBitmapsA.
3359 BOOL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
3361 ERR_(opengl)("No OpenGL support compiled in.\n");
3366 * X11DRV_wglUseFontBitmapsW
3368 * For OpenGL32 wglUseFontBitmapsW.
3370 BOOL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
3372 ERR_(opengl)("No OpenGL support compiled in.\n");
3376 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
3381 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
3386 BOOL destroy_glxpixmap(XID glxpixmap)
3391 #endif /* defined(HAVE_OPENGL) */