?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wgl: Don't set a pixel format on windows that already have one.
[wine.git] / dlls / winex11.drv / opengl.c
blob091aee5eabdaf367c82a9940aeaf80932d83bebc
1 /*
2 * X11DRV OpenGL functions
3 *
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
9 *
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.
14 *
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.
19 *
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
23 */
24
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <assert.h>
29 #include <stdlib.h>
30 #include <string.h>
31
32 #include "x11drv.h"
33 #include "winternl.h"
34 #include "wine/library.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
38 WINE_DECLARE_DEBUG_CHANNEL(opengl);
39
40 #ifdef SONAME_LIBGL
41
42 #undef APIENTRY
43 #undef CALLBACK
44 #undef WINAPI
45
46 #ifdef HAVE_GL_GL_H
47 # include <GL/gl.h>
48 #endif
49 #ifdef HAVE_GL_GLX_H
50 # include <GL/glx.h>
51 #endif
52 #ifdef HAVE_GL_GLEXT_H
53 # include <GL/glext.h>
54 #endif
55
56 #include "wine/wgl.h"
57
58 #undef APIENTRY
59 #undef CALLBACK
60 #undef WINAPI
61
62 /* Redefines the constants */
63 #define CALLBACK __stdcall
64 #define WINAPI __stdcall
65 #define APIENTRY WINAPI
66
67
68 WINE_DECLARE_DEBUG_CHANNEL(fps);
69
70 typedef struct wine_glextension {
71 const char *extName;
72 struct {
73 const char *funcName;
74 void *funcAddress;
75 } extEntryPoints[8];
76 } WineGLExtension;
77
78 struct WineGLInfo {
79 const char *glVersion;
80 const char *glExtensions;
81
82 int glxVersion[2];
83
84 const char *glxServerVersion;
85 const char *glxServerVendor;
86 const char *glxServerExtensions;
87
88 const char *glxClientVersion;
89 const char *glxClientVendor;
90 const char *glxClientExtensions;
91
92 const char *glxExtensions;
93
94 BOOL glxDirect;
95 char wglExtensions[4096];
96 };
97
98 typedef struct wine_glpixelformat {
99 int iPixelFormat;
100 GLXFBConfig fbconfig;
101 int fmt_id;
102 int render_type;
103 BOOL offscreenOnly;
104 } WineGLPixelFormat;
105
106 typedef struct wine_glcontext {
107 HDC hdc;
108 XVisualInfo *vis;
109 WineGLPixelFormat *fmt;
110 GLXContext ctx;
111 BOOL do_escape;
112 X11DRV_PDEVICE *physDev;
113 X11DRV_PDEVICE *pReadDev;
114 RECT viewport;
115 RECT scissor;
116 BOOL scissor_enabled;
117 struct wine_glcontext *next;
118 struct wine_glcontext *prev;
119 } Wine_GLContext;
120
121 typedef struct wine_glpbuffer {
122 Drawable drawable;
123 Display* display;
124 WineGLPixelFormat* fmt;
125 int width;
126 int height;
127 int* attribList;
128 HDC hdc;
129
130 int use_render_texture; /* This is also the internal texture format */
131 int texture_bind_target;
132 int texture_bpp;
133 GLint texture_format;
134 GLuint texture_target;
135 GLenum texture_type;
136 GLuint texture;
137 int texture_level;
138 } Wine_GLPBuffer;
139
140 static Wine_GLContext *context_list;
141 static struct WineGLInfo WineGLInfo = { 0 };
142 static int use_render_texture_emulation = 1;
143 static int use_render_texture_ati = 0;
144 static int swap_interval = 1;
145
146 #define MAX_EXTENSIONS 16
147 static const WineGLExtension *WineGLExtensionList[MAX_EXTENSIONS];
148 static int WineGLExtensionListSize;
149
150 static WineGLPixelFormat *WineGLPixelFormatList;
151 static int WineGLPixelFormatListSize = 0;
152 static int WineGLPixelFormatOnScreenSize = 0;
153
154 static void X11DRV_WineGL_LoadExtensions(void);
155 static BOOL glxRequireVersion(int requiredVersion);
156 static BOOL glxRequireExtension(const char *requiredExtension);
157
158 static void dump_PIXELFORMATDESCRIPTOR(const PIXELFORMATDESCRIPTOR *ppfd) {
159 TRACE(" - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
160 TRACE(" - dwFlags : ");
161 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) TRACE(#tv " ")
162 TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
163 TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
164 TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
165 TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
166 TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
167 TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
168 TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
169 TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
170 TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
171 TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
172 TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
173 TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
174 TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
175 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
176 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
177 TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
178 /* PFD_SUPPORT_COMPOSITION is new in Vista, it is similar to composition
179 * under X e.g. COMPOSITE + GLX_EXT_TEXTURE_FROM_PIXMAP. */
180 TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_COMPOSITION);
181 #undef TEST_AND_DUMP
182 TRACE("\n");
183
184 TRACE(" - iPixelType : ");
185 switch (ppfd->iPixelType) {
186 case PFD_TYPE_RGBA: TRACE("PFD_TYPE_RGBA"); break;
187 case PFD_TYPE_COLORINDEX: TRACE("PFD_TYPE_COLORINDEX"); break;
188 }
189 TRACE("\n");
190
191 TRACE(" - Color : %d\n", ppfd->cColorBits);
192 TRACE(" - Red : %d\n", ppfd->cRedBits);
193 TRACE(" - Green : %d\n", ppfd->cGreenBits);
194 TRACE(" - Blue : %d\n", ppfd->cBlueBits);
195 TRACE(" - Alpha : %d\n", ppfd->cAlphaBits);
196 TRACE(" - Accum : %d\n", ppfd->cAccumBits);
197 TRACE(" - Depth : %d\n", ppfd->cDepthBits);
198 TRACE(" - Stencil : %d\n", ppfd->cStencilBits);
199 TRACE(" - Aux : %d\n", ppfd->cAuxBuffers);
200
201 TRACE(" - iLayerType : ");
202 switch (ppfd->iLayerType) {
203 case PFD_MAIN_PLANE: TRACE("PFD_MAIN_PLANE"); break;
204 case PFD_OVERLAY_PLANE: TRACE("PFD_OVERLAY_PLANE"); break;
205 case (BYTE)PFD_UNDERLAY_PLANE: TRACE("PFD_UNDERLAY_PLANE"); break;
206 }
207 TRACE("\n");
208 }
209
210 #define PUSH1(attribs,att) do { attribs[nAttribs++] = (att); } while (0)
211 #define PUSH2(attribs,att,value) do { attribs[nAttribs++] = (att); attribs[nAttribs++] = (value); } while(0)
212
213 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
214 /* GLX 1.0 */
215 MAKE_FUNCPTR(glXChooseVisual)
216 MAKE_FUNCPTR(glXCreateContext)
217 MAKE_FUNCPTR(glXCreateGLXPixmap)
218 MAKE_FUNCPTR(glXGetCurrentContext)
219 MAKE_FUNCPTR(glXGetCurrentDrawable)
220 MAKE_FUNCPTR(glXDestroyContext)
221 MAKE_FUNCPTR(glXDestroyGLXPixmap)
222 MAKE_FUNCPTR(glXGetConfig)
223 MAKE_FUNCPTR(glXIsDirect)
224 MAKE_FUNCPTR(glXMakeCurrent)
225 MAKE_FUNCPTR(glXSwapBuffers)
226 MAKE_FUNCPTR(glXQueryExtension)
227 MAKE_FUNCPTR(glXQueryVersion)
228 MAKE_FUNCPTR(glXUseXFont)
229
230 /* GLX 1.1 */
231 MAKE_FUNCPTR(glXGetClientString)
232 MAKE_FUNCPTR(glXQueryExtensionsString)
233 MAKE_FUNCPTR(glXQueryServerString)
234
235 /* GLX 1.3 */
236 MAKE_FUNCPTR(glXGetFBConfigs)
237 MAKE_FUNCPTR(glXChooseFBConfig)
238 MAKE_FUNCPTR(glXCreatePbuffer)
239 MAKE_FUNCPTR(glXCreateNewContext)
240 MAKE_FUNCPTR(glXDestroyPbuffer)
241 MAKE_FUNCPTR(glXGetFBConfigAttrib)
242 MAKE_FUNCPTR(glXGetVisualFromFBConfig)
243 MAKE_FUNCPTR(glXMakeContextCurrent)
244 MAKE_FUNCPTR(glXQueryDrawable)
245 MAKE_FUNCPTR(glXGetCurrentReadDrawable)
246
247 /* GLX Extensions */
248 static void* (*pglXGetProcAddressARB)(const GLubyte *);
249 static int (*pglXSwapIntervalSGI)(int);
250
251 /* ATI GLX Extensions */
252 static BOOL (*pglXBindTexImageATI)(Display *dpy, GLXPbuffer pbuffer, int buffer);
253 static BOOL (*pglXReleaseTexImageATI)(Display *dpy, GLXPbuffer pbuffer, int buffer);
254 static BOOL (*pglXDrawableAttribATI)(Display *dpy, GLXDrawable draw, const int *attribList);
255
256 /* NV GLX Extension */
257 static void* (*pglXAllocateMemoryNV)(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority);
258 static void (*pglXFreeMemoryNV)(GLvoid *pointer);
259
260 /* Standard OpenGL */
261 MAKE_FUNCPTR(glBindTexture)
262 MAKE_FUNCPTR(glBitmap)
263 MAKE_FUNCPTR(glCopyTexSubImage1D)
264 MAKE_FUNCPTR(glCopyTexImage2D)
265 MAKE_FUNCPTR(glCopyTexSubImage2D)
266 MAKE_FUNCPTR(glDisable)
267 MAKE_FUNCPTR(glDrawBuffer)
268 MAKE_FUNCPTR(glEnable)
269 MAKE_FUNCPTR(glEndList)
270 MAKE_FUNCPTR(glGetError)
271 MAKE_FUNCPTR(glGetIntegerv)
272 MAKE_FUNCPTR(glGetString)
273 MAKE_FUNCPTR(glIsEnabled)
274 MAKE_FUNCPTR(glNewList)
275 MAKE_FUNCPTR(glPixelStorei)
276 MAKE_FUNCPTR(glReadPixels)
277 MAKE_FUNCPTR(glScissor)
278 MAKE_FUNCPTR(glTexImage2D)
279 MAKE_FUNCPTR(glViewport)
280 #undef MAKE_FUNCPTR
281
282 static BOOL X11DRV_WineGL_InitOpenglInfo(void)
283 {
284 static BOOL infoInitialized = FALSE;
285
286 int screen = DefaultScreen(gdi_display);
287 Window win = RootWindow(gdi_display, screen);
288 Visual *visual;
289 XVisualInfo template;
290 XVisualInfo *vis;
291 int num;
292 GLXContext ctx = NULL;
293
294 if (infoInitialized)
295 return TRUE;
296 infoInitialized = TRUE;
297
298 wine_tsx11_lock();
299
300 visual = DefaultVisual(gdi_display, screen);
301 template.visualid = XVisualIDFromVisual(visual);
302 vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
303 if (vis) {
304 WORD old_fs = wine_get_fs();
305 /* Create a GLX Context. Without one we can't query GL information */
306 ctx = pglXCreateContext(gdi_display, vis, None, GL_TRUE);
307 if (wine_get_fs() != old_fs)
308 {
309 wine_set_fs( old_fs );
310 wine_tsx11_unlock();
311 ERR( "%%fs register corrupted, probably broken ATI driver, disabling OpenGL.\n" );
312 ERR( "You need to set the \"UseFastTls\" option to \"2\" in your X config file.\n" );
313 return FALSE;
314 }
315 }
316
317 if (ctx) {
318 pglXMakeCurrent(gdi_display, win, ctx);
319 } else {
320 ERR(" couldn't initialize OpenGL, expect problems\n");
321 wine_tsx11_unlock();
322 return FALSE;
323 }
324
325 WineGLInfo.glVersion = (const char *) pglGetString(GL_VERSION);
326 WineGLInfo.glExtensions = strdup((const char *) pglGetString(GL_EXTENSIONS));
327
328 /* Get the common GLX version supported by GLX client and server ( major/minor) */
329 pglXQueryVersion(gdi_display, &WineGLInfo.glxVersion[0], &WineGLInfo.glxVersion[1]);
330
331 WineGLInfo.glxServerVersion = pglXQueryServerString(gdi_display, screen, GLX_VERSION);
332 WineGLInfo.glxServerVendor = pglXQueryServerString(gdi_display, screen, GLX_VENDOR);
333 WineGLInfo.glxServerExtensions = pglXQueryServerString(gdi_display, screen, GLX_EXTENSIONS);
334
335 WineGLInfo.glxClientVersion = pglXGetClientString(gdi_display, GLX_VERSION);
336 WineGLInfo.glxClientVendor = pglXGetClientString(gdi_display, GLX_VENDOR);
337 WineGLInfo.glxClientExtensions = pglXGetClientString(gdi_display, GLX_EXTENSIONS);
338
339 WineGLInfo.glxExtensions = pglXQueryExtensionsString(gdi_display, screen);
340 WineGLInfo.glxDirect = pglXIsDirect(gdi_display, ctx);
341
342 TRACE("GL version : %s.\n", WineGLInfo.glVersion);
343 TRACE("GL renderer : %s.\n", pglGetString(GL_RENDERER));
344 TRACE("GLX version : %d.%d.\n", WineGLInfo.glxVersion[0], WineGLInfo.glxVersion[1]);
345 TRACE("Server GLX version : %s.\n", WineGLInfo.glxServerVersion);
346 TRACE("Server GLX vendor: : %s.\n", WineGLInfo.glxServerVendor);
347 TRACE("Client GLX version : %s.\n", WineGLInfo.glxClientVersion);
348 TRACE("Client GLX vendor: : %s.\n", WineGLInfo.glxClientVendor);
349 TRACE("Direct rendering enabled: %s\n", WineGLInfo.glxDirect ? "True" : "False");
350
351 if(vis) XFree(vis);
352 if(ctx) {
353 pglXMakeCurrent(gdi_display, None, NULL);
354 pglXDestroyContext(gdi_display, ctx);
355 }
356 wine_tsx11_unlock();
357 return TRUE;
358 }
359
360 static BOOL has_opengl(void)
361 {
362 static int init_done;
363 static void *opengl_handle;
364
365 int error_base, event_base;
366
367 if (init_done) return (opengl_handle != NULL);
368 init_done = 1;
369
370 /* No need to load any other libraries as according to the ABI, libGL should be self-sufficient
371 and include all dependencies */
372 opengl_handle = wine_dlopen(SONAME_LIBGL, RTLD_NOW|RTLD_GLOBAL, NULL, 0);
373 if (opengl_handle == NULL) return FALSE;
374
375 pglXGetProcAddressARB = wine_dlsym(opengl_handle, "glXGetProcAddressARB", NULL, 0);
376 if (pglXGetProcAddressARB == NULL) {
377 ERR("could not find glXGetProcAddressARB in libGL.\n");
378 return FALSE;
379 }
380
381 #define LOAD_FUNCPTR(f) if((p##f = (void*)pglXGetProcAddressARB((const unsigned char*)#f)) == NULL) goto sym_not_found;
382 /* GLX 1.0 */
383 LOAD_FUNCPTR(glXChooseVisual)
384 LOAD_FUNCPTR(glXCreateContext)
385 LOAD_FUNCPTR(glXCreateGLXPixmap)
386 LOAD_FUNCPTR(glXGetCurrentContext)
387 LOAD_FUNCPTR(glXGetCurrentDrawable)
388 LOAD_FUNCPTR(glXDestroyContext)
389 LOAD_FUNCPTR(glXDestroyGLXPixmap)
390 LOAD_FUNCPTR(glXGetConfig)
391 LOAD_FUNCPTR(glXIsDirect)
392 LOAD_FUNCPTR(glXMakeCurrent)
393 LOAD_FUNCPTR(glXSwapBuffers)
394 LOAD_FUNCPTR(glXQueryExtension)
395 LOAD_FUNCPTR(glXQueryVersion)
396 LOAD_FUNCPTR(glXUseXFont)
397
398 /* GLX 1.1 */
399 LOAD_FUNCPTR(glXGetClientString)
400 LOAD_FUNCPTR(glXQueryExtensionsString)
401 LOAD_FUNCPTR(glXQueryServerString)
402
403 /* GLX 1.3 */
404 LOAD_FUNCPTR(glXCreatePbuffer)
405 LOAD_FUNCPTR(glXCreateNewContext)
406 LOAD_FUNCPTR(glXDestroyPbuffer)
407 LOAD_FUNCPTR(glXMakeContextCurrent)
408 LOAD_FUNCPTR(glXGetCurrentReadDrawable)
409 LOAD_FUNCPTR(glXGetFBConfigs)
410
411 /* Standard OpenGL calls */
412 LOAD_FUNCPTR(glBindTexture)
413 LOAD_FUNCPTR(glBitmap)
414 LOAD_FUNCPTR(glCopyTexSubImage1D)
415 LOAD_FUNCPTR(glCopyTexImage2D)
416 LOAD_FUNCPTR(glCopyTexSubImage2D)
417 LOAD_FUNCPTR(glDisable)
418 LOAD_FUNCPTR(glDrawBuffer)
419 LOAD_FUNCPTR(glEnable)
420 LOAD_FUNCPTR(glEndList)
421 LOAD_FUNCPTR(glGetError)
422 LOAD_FUNCPTR(glGetIntegerv)
423 LOAD_FUNCPTR(glGetString)
424 LOAD_FUNCPTR(glIsEnabled)
425 LOAD_FUNCPTR(glNewList)
426 LOAD_FUNCPTR(glPixelStorei)
427 LOAD_FUNCPTR(glReadPixels)
428 LOAD_FUNCPTR(glScissor)
429 LOAD_FUNCPTR(glTexImage2D)
430 LOAD_FUNCPTR(glViewport)
431 #undef LOAD_FUNCPTR
432
433 /* It doesn't matter if these fail. They'll only be used if the driver reports
434 the associated extension is available (and if a driver reports the extension
435 is available but fails to provide the functions, it's quite broken) */
436 #define LOAD_FUNCPTR(f) p##f = (void*)pglXGetProcAddressARB((const unsigned char*)#f);
437 /* NV GLX Extension */
438 LOAD_FUNCPTR(glXAllocateMemoryNV)
439 LOAD_FUNCPTR(glXFreeMemoryNV)
440 #undef LOAD_FUNCPTR
441
442 if(!X11DRV_WineGL_InitOpenglInfo()) {
443 wine_dlclose(opengl_handle, NULL, 0);
444 opengl_handle = NULL;
445 return FALSE;
446 }
447
448 wine_tsx11_lock();
449 if (pglXQueryExtension(gdi_display, &error_base, &event_base) == True) {
450 TRACE("GLX is up and running error_base = %d\n", error_base);
451 } else {
452 wine_dlclose(opengl_handle, NULL, 0);
453 opengl_handle = NULL;
454 }
455
456 /* In case of GLX you have direct and indirect rendering. Most of the time direct rendering is used
457 * as in general only that is hardware accelerated. In some cases like in case of remote X indirect
458 * rendering is used.
459 *
460 * The main problem for our OpenGL code is that we need certain GLX calls but their presence
461 * depends on the reported GLX client / server version and on the client / server extension list.
462 * Those don't have to be the same.
463 *
464 * In general the server GLX information lists the capabilities in case of indirect rendering.
465 * When direct rendering is used, the OpenGL client library is responsible for which GLX calls are
466 * available and in that case the client GLX informat can be used.
467 * OpenGL programs should use the 'intersection' of both sets of information which is advertised
468 * in the GLX version/extension list. When a program does this it works for certain for both
469 * direct and indirect rendering.
470 *
471 * The problem we are having in this area is that ATI's Linux drivers are broken. For some reason
472 * they haven't added some very important GLX extensions like GLX_SGIX_fbconfig to their client
473 * extension list which causes this extension not to be listed. (Wine requires this extension).
474 * ATI advertises a GLX client version of 1.3 which implies that this fbconfig extension among
475 * pbuffers is around.
476 *
477 * In order to provide users of Ati's proprietary drivers with OpenGL support, we need to detect
478 * the ATI drivers and from then on use GLX client information for them.
479 */
480
481 if(glxRequireVersion(3)) {
482 pglXChooseFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfig");
483 pglXGetFBConfigAttrib = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttrib");
484 pglXGetVisualFromFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfig");
485 pglXQueryDrawable = (void*)pglXGetProcAddressARB((const GLubyte *) "glXQueryDrawable");
486 } else if(glxRequireExtension("GLX_SGIX_fbconfig")) {
487 pglXChooseFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfigSGIX");
488 pglXGetFBConfigAttrib = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttribSGIX");
489 pglXGetVisualFromFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfigSGIX");
490
491 /* The mesa libGL client library seems to forward glXQueryDrawable to the Xserver, so only
492 * enable this function when the Xserver understand GLX 1.3 or newer
493 */
494 pglXQueryDrawable = NULL;
495 } else if(strcmp("ATI", WineGLInfo.glxClientVendor) == 0) {
496 TRACE("Overriding ATI GLX capabilities!\n");
497 pglXChooseFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXChooseFBConfig");
498 pglXGetFBConfigAttrib = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetFBConfigAttrib");
499 pglXGetVisualFromFBConfig = (void*)pglXGetProcAddressARB((const GLubyte *) "glXGetVisualFromFBConfig");
500 pglXQueryDrawable = (void*)pglXGetProcAddressARB((const GLubyte *) "glXQueryDrawable");
501
502 /* Use client GLX information in case of the ATI drivers. We override the
503 * capabilities over here and not somewhere else as ATI might better their
504 * life in the future. In case they release proper drivers this block of
505 * code won't be called. */
506 WineGLInfo.glxExtensions = WineGLInfo.glxClientExtensions;
507 } else {
508 ERR(" glx_version is %s and GLX_SGIX_fbconfig extension is unsupported. Expect problems.\n", WineGLInfo.glxServerVersion);
509 }
510
511 if(glxRequireExtension("GLX_ATI_render_texture")) {
512 use_render_texture_ati = 1;
513 pglXBindTexImageATI = (void*)pglXGetProcAddressARB((const GLubyte *) "glXBindTexImageATI");
514 pglXReleaseTexImageATI = (void*)pglXGetProcAddressARB((const GLubyte *) "glXReleaseTexImageATI");
515 pglXDrawableAttribATI = (void*)pglXGetProcAddressARB((const GLubyte *) "glXDrawableAttribATI");
516 }
517
518 X11DRV_WineGL_LoadExtensions();
519
520 wine_tsx11_unlock();
521 return (opengl_handle != NULL);
522
523 sym_not_found:
524 wine_dlclose(opengl_handle, NULL, 0);
525 opengl_handle = NULL;
526 return FALSE;
527 }
528
529 static inline Wine_GLContext *alloc_context(void)
530 {
531 Wine_GLContext *ret;
532
533 if ((ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLContext))))
534 {
535 ret->next = context_list;
536 if (context_list) context_list->prev = ret;
537 context_list = ret;
538 }
539 return ret;
540 }
541
542 static inline void free_context(Wine_GLContext *context)
543 {
544 if (context->next != NULL) context->next->prev = context->prev;
545 if (context->prev != NULL) context->prev->next = context->next;
546 else context_list = context->next;
547
548 if (context->vis) XFree(context->vis);
549 HeapFree(GetProcessHeap(), 0, context);
550 }
551
552 static inline BOOL is_valid_context( Wine_GLContext *ctx )
553 {
554 Wine_GLContext *ptr;
555 for (ptr = context_list; ptr; ptr = ptr->next) if (ptr == ctx) break;
556 return (ptr != NULL);
557 }
558
559 static int describeContext(Wine_GLContext* ctx) {
560 int tmp;
561 int ctx_vis_id;
562 TRACE(" Context %p have (vis:%p):\n", ctx, ctx->vis);
563 pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_FBCONFIG_ID, &tmp);
564 TRACE(" - FBCONFIG_ID 0x%x\n", tmp);
565 pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_VISUAL_ID, &tmp);
566 TRACE(" - VISUAL_ID 0x%x\n", tmp);
567 ctx_vis_id = tmp;
568 return ctx_vis_id;
569 }
570
571 static int describeDrawable(Wine_GLContext* ctx, Drawable drawable) {
572 int tmp;
573 int nElements;
574 int attribList[3] = { GLX_FBCONFIG_ID, 0, None };
575 GLXFBConfig *fbCfgs;
576
577 if (pglXQueryDrawable == NULL) {
578 /** glXQueryDrawable not available so returns not supported */
579 return -1;
580 }
581
582 TRACE(" Drawable %p have :\n", (void*) drawable);
583 pglXQueryDrawable(gdi_display, drawable, GLX_WIDTH, (unsigned int*) &tmp);
584 TRACE(" - WIDTH as %d\n", tmp);
585 pglXQueryDrawable(gdi_display, drawable, GLX_HEIGHT, (unsigned int*) &tmp);
586 TRACE(" - HEIGHT as %d\n", tmp);
587 pglXQueryDrawable(gdi_display, drawable, GLX_FBCONFIG_ID, (unsigned int*) &tmp);
588 TRACE(" - FBCONFIG_ID as 0x%x\n", tmp);
589
590 attribList[1] = tmp;
591 fbCfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), attribList, &nElements);
592 if (fbCfgs == NULL) {
593 return -1;
594 }
595
596 pglXGetFBConfigAttrib(gdi_display, fbCfgs[0], GLX_VISUAL_ID, &tmp);
597 TRACE(" - VISUAL_ID as 0x%x\n", tmp);
598
599 XFree(fbCfgs);
600
601 return tmp;
602 }
603
604 static int ConvertAttribWGLtoGLX(const int* iWGLAttr, int* oGLXAttr, Wine_GLPBuffer* pbuf) {
605 int nAttribs = 0;
606 unsigned cur = 0;
607 int pop;
608 int drawattrib = 0;
609 int nvfloatattrib = GLX_DONT_CARE;
610 int pixelattrib = 0;
611
612 /* The list of WGL attributes is allowed to be NULL. We don't return here for NULL
613 * because we need to do fixups for GLX_DRAWABLE_TYPE/GLX_RENDER_TYPE/GLX_FLOAT_COMPONENTS_NV. */
614 while (iWGLAttr && 0 != iWGLAttr[cur]) {
615 TRACE("pAttr[%d] = %x\n", cur, iWGLAttr[cur]);
616
617 switch (iWGLAttr[cur]) {
618 case WGL_COLOR_BITS_ARB:
619 pop = iWGLAttr[++cur];
620 PUSH2(oGLXAttr, GLX_BUFFER_SIZE, pop);
621 TRACE("pAttr[%d] = GLX_BUFFER_SIZE: %d\n", cur, pop);
622 break;
623 case WGL_BLUE_BITS_ARB:
624 pop = iWGLAttr[++cur];
625 PUSH2(oGLXAttr, GLX_BLUE_SIZE, pop);
626 TRACE("pAttr[%d] = GLX_BLUE_SIZE: %d\n", cur, pop);
627 break;
628 case WGL_RED_BITS_ARB:
629 pop = iWGLAttr[++cur];
630 PUSH2(oGLXAttr, GLX_RED_SIZE, pop);
631 TRACE("pAttr[%d] = GLX_RED_SIZE: %d\n", cur, pop);
632 break;
633 case WGL_GREEN_BITS_ARB:
634 pop = iWGLAttr[++cur];
635 PUSH2(oGLXAttr, GLX_GREEN_SIZE, pop);
636 TRACE("pAttr[%d] = GLX_GREEN_SIZE: %d\n", cur, pop);
637 break;
638 case WGL_ALPHA_BITS_ARB:
639 pop = iWGLAttr[++cur];
640 PUSH2(oGLXAttr, GLX_ALPHA_SIZE, pop);
641 TRACE("pAttr[%d] = GLX_ALPHA_SIZE: %d\n", cur, pop);
642 break;
643 case WGL_DEPTH_BITS_ARB:
644 pop = iWGLAttr[++cur];
645 PUSH2(oGLXAttr, GLX_DEPTH_SIZE, pop);
646 TRACE("pAttr[%d] = GLX_DEPTH_SIZE: %d\n", cur, pop);
647 break;
648 case WGL_STENCIL_BITS_ARB:
649 pop = iWGLAttr[++cur];
650 PUSH2(oGLXAttr, GLX_STENCIL_SIZE, pop);
651 TRACE("pAttr[%d] = GLX_STENCIL_SIZE: %d\n", cur, pop);
652 break;
653 case WGL_DOUBLE_BUFFER_ARB:
654 pop = iWGLAttr[++cur];
655 PUSH2(oGLXAttr, GLX_DOUBLEBUFFER, pop);
656 TRACE("pAttr[%d] = GLX_DOUBLEBUFFER: %d\n", cur, pop);
657 break;
658
659 case WGL_PIXEL_TYPE_ARB:
660 pop = iWGLAttr[++cur];
661 TRACE("pAttr[%d] = WGL_PIXEL_TYPE_ARB: %d\n", cur, pop);
662 switch (pop) {
663 case WGL_TYPE_COLORINDEX_ARB: pixelattrib = GLX_COLOR_INDEX_BIT; break ;
664 case WGL_TYPE_RGBA_ARB: pixelattrib = GLX_RGBA_BIT; break ;
665 /* 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 */
666 case WGL_TYPE_RGBA_FLOAT_ATI: pixelattrib = GLX_RGBA_FLOAT_BIT; break ;
667 default:
668 ERR("unexpected PixelType(%x)\n", pop);
669 pop = 0;
670 }
671 break;
672
673 case WGL_SUPPORT_GDI_ARB:
674 pop = iWGLAttr[++cur];
675 PUSH2(oGLXAttr, GLX_X_RENDERABLE, pop);
676 TRACE("pAttr[%d] = WGL_SUPPORT_GDI_ARB: %d\n", cur, pop);
677 break;
678
679 case WGL_DRAW_TO_BITMAP_ARB:
680 pop = iWGLAttr[++cur];
681 TRACE("pAttr[%d] = WGL_DRAW_TO_BITMAP_ARB: %d\n", cur, pop);
682 /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
683 if (pop) {
684 drawattrib |= GLX_PIXMAP_BIT;
685 }
686 break;
687
688 case WGL_DRAW_TO_WINDOW_ARB:
689 pop = iWGLAttr[++cur];
690 TRACE("pAttr[%d] = WGL_DRAW_TO_WINDOW_ARB: %d\n", cur, pop);
691 /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
692 if (pop) {
693 drawattrib |= GLX_WINDOW_BIT;
694 }
695 break;
696
697 case WGL_DRAW_TO_PBUFFER_ARB:
698 pop = iWGLAttr[++cur];
699 TRACE("pAttr[%d] = WGL_DRAW_TO_PBUFFER_ARB: %d\n", cur, pop);
700 /* GLX_DRAWABLE_TYPE flags need to be OR'd together. See below. */
701 if (pop) {
702 drawattrib |= GLX_PBUFFER_BIT;
703 }
704 break;
705
706 case WGL_ACCELERATION_ARB:
707 case WGL_SUPPORT_OPENGL_ARB:
708 pop = iWGLAttr[++cur];
709 /** nothing to do, if we are here, supposing support Accelerated OpenGL */
710 TRACE("pAttr[%d] = WGL_SUPPORT_OPENGL_ARB: %d\n", cur, pop);
711 break;
712
713 case WGL_PBUFFER_LARGEST_ARB:
714 pop = iWGLAttr[++cur];
715 PUSH2(oGLXAttr, GLX_LARGEST_PBUFFER, pop);
716 TRACE("pAttr[%d] = GLX_LARGEST_PBUFFER: %x\n", cur, pop);
717 break;
718
719 case WGL_SAMPLE_BUFFERS_ARB:
720 pop = iWGLAttr[++cur];
721 PUSH2(oGLXAttr, GLX_SAMPLE_BUFFERS_ARB, pop);
722 TRACE("pAttr[%d] = GLX_SAMPLE_BUFFERS_ARB: %x\n", cur, pop);
723 break;
724
725 case WGL_SAMPLES_ARB:
726 pop = iWGLAttr[++cur];
727 PUSH2(oGLXAttr, GLX_SAMPLES_ARB, pop);
728 TRACE("pAttr[%d] = GLX_SAMPLES_ARB: %x\n", cur, pop);
729 break;
730
731 case WGL_TEXTURE_FORMAT_ARB:
732 case WGL_TEXTURE_TARGET_ARB:
733 case WGL_MIPMAP_TEXTURE_ARB:
734 TRACE("WGL_render_texture Attributes: %x as %x\n", iWGLAttr[cur], iWGLAttr[cur + 1]);
735 pop = iWGLAttr[++cur];
736 if (NULL == pbuf) {
737 ERR("trying to use GLX_Pbuffer Attributes without Pbuffer (was %x)\n", iWGLAttr[cur]);
738 }
739 if (use_render_texture_ati) {
740 /** nothing to do here */
741 }
742 else if (!use_render_texture_emulation) {
743 if (WGL_NO_TEXTURE_ARB != pop) {
744 ERR("trying to use WGL_render_texture Attributes without support (was %x)\n", iWGLAttr[cur]);
745 return -1; /** error: don't support it */
746 } else {
747 PUSH2(oGLXAttr, GLX_X_RENDERABLE, pop);
748 drawattrib |= GLX_PBUFFER_BIT;
749 }
750 }
751 break ;
752 case WGL_FLOAT_COMPONENTS_NV:
753 nvfloatattrib = iWGLAttr[++cur];
754 TRACE("pAttr[%d] = WGL_FLOAT_COMPONENTS_NV: %x\n", cur, nvfloatattrib);
755 break ;
756 case WGL_BIND_TO_TEXTURE_RGB_ARB:
757 case WGL_BIND_TO_TEXTURE_RGBA_ARB:
758 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_R_NV:
759 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RG_NV:
760 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV:
761 case WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGBA_NV:
762 pop = iWGLAttr[++cur];
763 /** cannot be converted, see direct handling on
764 * - wglGetPixelFormatAttribivARB
765 * TODO: wglChoosePixelFormat
766 */
767 break ;
768
769 default:
770 FIXME("unsupported %x WGL Attribute\n", iWGLAttr[cur]);
771 break;
772 }
773 ++cur;
774 }
775
776 /* Apply the OR'd drawable type bitmask now EVEN when WGL_DRAW_TO* is unset.
777 * It is needed in all cases because GLX_DRAWABLE_TYPE default to GLX_WINDOW_BIT. */
778 PUSH2(oGLXAttr, GLX_DRAWABLE_TYPE, drawattrib);
779 TRACE("pAttr[?] = GLX_DRAWABLE_TYPE: %#x\n", drawattrib);
780
781 /* Set GLX_RENDER_TYPE all the time */
782 PUSH2(oGLXAttr, GLX_RENDER_TYPE, pixelattrib);
783 TRACE("pAttr[?] = GLX_RENDER_TYPE: %#x\n", pixelattrib);
784
785 /* Set GLX_FLOAT_COMPONENTS_NV all the time */
786 if(strstr(WineGLInfo.glxExtensions, "GLX_NV_float_buffer")) {
787 PUSH2(oGLXAttr, GLX_FLOAT_COMPONENTS_NV, nvfloatattrib);
788 TRACE("pAttr[?] = GLX_FLOAT_COMPONENTS_NV: %#x\n", nvfloatattrib);
789 }
790
791 return nAttribs;
792 }
793
794 static int get_render_type_from_fbconfig(Display *display, GLXFBConfig fbconfig)
795 {
796 int render_type=0, render_type_bit;
797 pglXGetFBConfigAttrib(display, fbconfig, GLX_RENDER_TYPE, &render_type_bit);
798 switch(render_type_bit)
799 {
800 case GLX_RGBA_BIT:
801 render_type = GLX_RGBA_TYPE;
802 break;
803 case GLX_COLOR_INDEX_BIT:
804 render_type = GLX_COLOR_INDEX_TYPE;
805 break;
806 case GLX_RGBA_FLOAT_BIT:
807 render_type = GLX_RGBA_FLOAT_TYPE;
808 break;
809 default:
810 ERR("Unknown render_type: %x\n", render_type);
811 }
812 return render_type;
813 }
814
815 static BOOL init_formats(Display *display, int screen, Visual *visual)
816 {
817 int fmt_id, tmp_fmt_id, nCfgs, i;
818 GLXFBConfig* cfgs;
819 GLXFBConfig fbconfig = NULL;
820 XVisualInfo *visinfo;
821 VisualID visualid = XVisualIDFromVisual(visual);
822 int nOffscreenFormats = 0;
823
824 /* As mentioned in various parts of the code only the format of the main visual can be used for onscreen rendering.
825 * Next to this format there are also so called offscreen rendering formats (used for pbuffers) which can be supported
826 * because they don't need a visual. Below we use glXGetFBConfigs instead of glXChooseFBConfig to enumerate the fb configurations
827 * because this call lists both types of formats instead of only onscreen ones. */
828 cfgs = pglXGetFBConfigs(display, DefaultScreen(display), &nCfgs);
829 if (NULL == cfgs || 0 == nCfgs) {
830 ERR("glXChooseFBConfig returns NULL\n");
831 if(cfgs != NULL) XFree(cfgs);
832 return FALSE;
833 }
834
835 /* Count the number of offscreen formats to determine the size for our pixelformat list */
836 for(i=0; i<nCfgs; i++) {
837 pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &tmp_fmt_id);
838
839 visinfo = pglXGetVisualFromFBConfig(display, cfgs[i]);
840 /* Onscreen formats have a corresponding XVisual, offscreen ones don't */
841 if(!visinfo) {
842 nOffscreenFormats++;
843 } else if(visinfo && visinfo->visualid == visualid) {
844 pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &fmt_id);
845 fbconfig = cfgs[i];
846 XFree(visinfo);
847 }
848 }
849 TRACE("Number of offscreen formats: %d\n", nOffscreenFormats);
850
851 /* Allocate memory for all the offscreen pixelformats and the format of Wine's main visual */
852 WineGLPixelFormatList = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, (1+nOffscreenFormats)*sizeof(WineGLPixelFormat));
853 WineGLPixelFormatList[0].iPixelFormat = 1;
854 WineGLPixelFormatList[0].fbconfig = fbconfig;
855 WineGLPixelFormatList[0].fmt_id = fmt_id;
856 WineGLPixelFormatList[0].render_type = get_render_type_from_fbconfig(display, fbconfig);
857 WineGLPixelFormatList[0].offscreenOnly = FALSE;
858 WineGLPixelFormatListSize = 1;
859 WineGLPixelFormatOnScreenSize = 1;
860
861 /* Fill the list with offscreen formats */
862 for(i=0; i<nCfgs; i++) {
863 pglXGetFBConfigAttrib(display, cfgs[i], GLX_FBCONFIG_ID, &tmp_fmt_id);
864
865 visinfo = pglXGetVisualFromFBConfig(display, cfgs[i]);
866 /* We have found an offscreen rendering format when there is no visualinfo :) */
867 if(!visinfo) {
868 TRACE("Found offscreen format FBCONFIG_ID 0x%x corresponding to iPixelFormat %d at GLX index %d\n", tmp_fmt_id, WineGLPixelFormatListSize+1, i);
869 WineGLPixelFormatList[WineGLPixelFormatListSize].iPixelFormat = WineGLPixelFormatListSize+1; /* The index starts at 1 */
870 WineGLPixelFormatList[WineGLPixelFormatListSize].fbconfig = cfgs[i];
871 WineGLPixelFormatList[WineGLPixelFormatListSize].fmt_id = tmp_fmt_id;
872 WineGLPixelFormatList[WineGLPixelFormatListSize].render_type = get_render_type_from_fbconfig(display, cfgs[i]);
873 WineGLPixelFormatList[WineGLPixelFormatListSize].offscreenOnly = TRUE;
874 WineGLPixelFormatListSize++;
875 } else {
876 XFree(visinfo);
877 }
878 }
879
880 if(cfgs != NULL) XFree(cfgs);
881
882 return TRUE;
883 }
884
885 /* GLX can advertise dozens of different pixelformats including offscreen and onscreen ones.
886 * In our WGL implementation we only support a subset of these formats namely the format of
887 * Wine's main visual and offscreen formats (if they are available).
888 * This function converts a WGL format to its corresponding GLX one. It returns a WineGLPixelFormat
889 * and it returns the number of supported WGL formats in fmt_count.
890 */
891 static WineGLPixelFormat* ConvertPixelFormatWGLtoGLX(Display *display, int iPixelFormat, BOOL AllowOffscreen, int *fmt_count)
892 {
893 WineGLPixelFormat *res = NULL;
894
895 /* Init the list of pixel formats when we need it */
896 if(!WineGLPixelFormatListSize)
897 init_formats(display, DefaultScreen(display), visual);
898
899 /* Check if the pixelformat is valid. Note that it is legal to pass an invalid
900 * iPixelFormat in case of probing the number of pixelformats.
901 */
902 if((iPixelFormat > 0) && (iPixelFormat <= WineGLPixelFormatListSize) &&
903 ((WineGLPixelFormatList[iPixelFormat-1].offscreenOnly == FALSE) ||
904 AllowOffscreen)) {
905 res = &WineGLPixelFormatList[iPixelFormat-1];
906 TRACE("Returning FBConfig=%p for iPixelFormat=%d\n", res->fbconfig, iPixelFormat);
907 }
908
909 if(AllowOffscreen)
910 *fmt_count = WineGLPixelFormatListSize;
911 else
912 *fmt_count = WineGLPixelFormatOnScreenSize;
913
914 TRACE("Number of returned pixelformats=%d\n", *fmt_count);
915
916 return res;
917 }
918
919 /* Search our internal pixelformat list for the WGL format corresponding to the given fbconfig */
920 static WineGLPixelFormat* ConvertPixelFormatGLXtoWGL(Display *display, int fmt_id)
921 {
922 int i;
923
924 /* Init the list of pixel formats when we need it */
925 if(!WineGLPixelFormatListSize)
926 init_formats(display, DefaultScreen(display), visual);
927
928 for(i=0; i<WineGLPixelFormatListSize; i++) {
929 if(WineGLPixelFormatList[i].fmt_id == fmt_id) {
930 TRACE("Returning iPixelFormat %d for fmt_id 0x%x\n", WineGLPixelFormatList[i].iPixelFormat, fmt_id);
931 return &WineGLPixelFormatList[i];
932 }
933 }
934 TRACE("No compatible format found for fmt_id 0x%x\n", fmt_id);
935 return NULL;
936 }
937
938 int pixelformat_from_fbconfig_id(XID fbconfig_id)
939 {
940 WineGLPixelFormat *fmt;
941
942 if (!fbconfig_id) return 0;
943
944 fmt = ConvertPixelFormatGLXtoWGL(gdi_display, fbconfig_id);
945 if(fmt)
946 return fmt->iPixelFormat;
947 /* This will happen on hwnds without a pixel format set; it's ok */
948 return 0;
949 }
950
951
952 /**
953 * X11DRV_ChoosePixelFormat
954 *
955 * Equivalent to glXChooseVisual.
956 */
957 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
958 const PIXELFORMATDESCRIPTOR *ppfd) {
959 WineGLPixelFormat *fmt = NULL;
960 int ret = 0;
961 int nPixelFormats;
962 int value = 0;
963 int i = 0;
964 int bestFormat = -1;
965 int bestDBuffer = -1;
966 int bestStereo = -1;
967 int bestColor = -1;
968 int bestAlpha = -1;
969 int bestDepth = -1;
970 int bestStencil = -1;
971 int bestAux = -1;
972 int score;
973
974 if (!has_opengl()) {
975 ERR("No libGL on this box - disabling OpenGL support !\n");
976 return 0;
977 }
978
979 if (TRACE_ON(opengl)) {
980 TRACE("(%p,%p)\n", physDev, ppfd);
981
982 dump_PIXELFORMATDESCRIPTOR((const PIXELFORMATDESCRIPTOR *) ppfd);
983 }
984
985 wine_tsx11_lock();
986 ConvertPixelFormatWGLtoGLX(gdi_display, 0, FALSE /* offscreen */, &nPixelFormats);
987 for(i=0; i<nPixelFormats; i++)
988 {
989 int dwFlags = 0;
990 int iPixelType = 0;
991 int alpha=0, color=0, depth=0, stencil=0, aux=0;
992
993 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, i+1 /* 1-based index */, FALSE /* offscreen */, &value);
994 score = 0;
995
996 /* Pixel type */
997 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
998 if (value & GLX_RGBA_BIT)
999 iPixelType = PFD_TYPE_RGBA;
1000 else
1001 iPixelType = PFD_TYPE_COLORINDEX;
1002
1003 if (ppfd->iPixelType != iPixelType)
1004 {
1005 TRACE("pixel type mismatch for iPixelFormat=%d\n", i+1);
1006 continue;
1007 }
1008
1009 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value);
1010 if (value) dwFlags |= PFD_DOUBLEBUFFER;
1011 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value);
1012 if (value) dwFlags |= PFD_STEREO;
1013 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BUFFER_SIZE, &color); /* cColorBits */
1014 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &alpha); /* cAlphaBits */
1015 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &depth); /* cDepthBits */
1016 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &stencil); /* cStencilBits */
1017 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_AUX_BUFFERS, &aux); /* cAuxBuffers */
1018
1019 /* The behavior of PDF_STEREO/PFD_STEREO_DONTCARE and PFD_DOUBLEBUFFER / PFD_DOUBLEBUFFER_DONTCARE
1020 * is not very clear on MSDN. They specify that ChoosePixelFormat tries to match pixel formats
1021 * with the flag (PFD_STEREO / PFD_DOUBLEBUFFERING) set. Otherwise it says that it tries to match
1022 * formats without the given flag set.
1023 * A test on Windows using a Radeon 9500pro on WinXP (the driver doesn't support Stereo)
1024 * has indicated that a format without stereo is returned when stereo is unavailable.
1025 * So in case PFD_STEREO is set, formats that support it should have priority above formats
1026 * without. In case PFD_STEREO_DONTCARE is set, stereo is ignored.
1027 *
1028 * To summarize the following is most likely the correct behavior:
1029 * stereo not set -> prefer no-stereo formats, else also accept stereo formats
1030 * stereo set -> prefer stereo formats, else also accept no-stereo formats
1031 * stereo don't care -> it doesn't matter whether we get stereo or not
1032 *
1033 * In Wine we will treat no-stereo the same way as don't care because it makes
1034 * format selection even more complicated and second drivers with Stereo advertise
1035 * each format twice anyway.
1036 */
1037
1038 /* Doublebuffer, see the comments above */
1039 if( !(ppfd->dwFlags & PFD_DOUBLEBUFFER_DONTCARE) ) {
1040 if( ((ppfd->dwFlags & PFD_DOUBLEBUFFER) != bestDBuffer) &&
1041 ((dwFlags & PFD_DOUBLEBUFFER) == (ppfd->dwFlags & PFD_DOUBLEBUFFER)) )
1042 {
1043 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1044 bestStereo = dwFlags & PFD_STEREO;
1045 bestAlpha = alpha;
1046 bestColor = color;
1047 bestDepth = depth;
1048 bestStencil = stencil;
1049 bestAux = aux;
1050 bestFormat = i;
1051 continue;
1052 }
1053 if(bestDBuffer != -1 && (dwFlags & PFD_DOUBLEBUFFER) != bestDBuffer)
1054 continue;
1055 }
1056
1057 /* Stereo, see the comments above. */
1058 if( !(ppfd->dwFlags & PFD_STEREO_DONTCARE) ) {
1059 if( ((ppfd->dwFlags & PFD_STEREO) != bestStereo) &&
1060 ((dwFlags & PFD_STEREO) == (ppfd->dwFlags & PFD_STEREO)) )
1061 {
1062 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1063 bestStereo = dwFlags & PFD_STEREO;
1064 bestAlpha = alpha;
1065 bestColor = color;
1066 bestDepth = depth;
1067 bestStencil = stencil;
1068 bestAux = aux;
1069 bestFormat = i;
1070 continue;
1071 }
1072 if(bestStereo != -1 && (dwFlags & PFD_STEREO) != bestStereo)
1073 continue;
1074 }
1075
1076 /* Below we will do a number of checks to select the 'best' pixelformat.
1077 * We assume the precedence cColorBits > cAlphaBits > cDepthBits > cStencilBits -> cAuxBuffers.
1078 * The code works by trying to match the most important options as close as possible.
1079 * When a reasonable format is found, we will try to match more options. */
1080
1081 /* Color bits */
1082 if( ((ppfd->cColorBits > bestColor) && (color > bestColor)) ||
1083 ((color >= ppfd->cColorBits) && (color < bestColor)) )
1084 {
1085 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1086 bestStereo = dwFlags & PFD_STEREO;
1087 bestAlpha = alpha;
1088 bestColor = color;
1089 bestDepth = depth;
1090 bestStencil = stencil;
1091 bestAux = aux;
1092 bestFormat = i;
1093 continue;
1094 } else if(bestColor != color) { /* Do further checks if the format is compatible */
1095 TRACE("color mismatch for iPixelFormat=%d\n", i+1);
1096 continue;
1097 }
1098
1099 /* Alpha bits */
1100 if( ((ppfd->cAlphaBits > bestAlpha) && (alpha > bestAlpha)) ||
1101 ((alpha >= ppfd->cAlphaBits) && (alpha < bestAlpha)) )
1102 {
1103 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1104 bestStereo = dwFlags & PFD_STEREO;
1105 bestAlpha = alpha;
1106 bestColor = color;
1107 bestDepth = depth;
1108 bestStencil = stencil;
1109 bestAux = aux;
1110 bestFormat = i;
1111 continue;
1112 } else if(bestAlpha != alpha) {
1113 TRACE("alpha mismatch for iPixelFormat=%d\n", i+1);
1114 continue;
1115 }
1116
1117 /* Depth bits */
1118 if( ((ppfd->cDepthBits > bestDepth) && (depth > bestDepth)) ||
1119 ((depth >= ppfd->cDepthBits) && (depth < bestDepth)) )
1120 {
1121 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1122 bestStereo = dwFlags & PFD_STEREO;
1123 bestAlpha = alpha;
1124 bestColor = color;
1125 bestDepth = depth;
1126 bestStencil = stencil;
1127 bestAux = aux;
1128 bestFormat = i;
1129 continue;
1130 } else if(bestDepth != depth) {
1131 TRACE("depth mismatch for iPixelFormat=%d\n", i+1);
1132 continue;
1133 }
1134
1135 /* Stencil bits */
1136 if( ((ppfd->cStencilBits > bestStencil) && (stencil > bestStencil)) ||
1137 ((stencil >= ppfd->cStencilBits) && (stencil < bestStencil)) )
1138 {
1139 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1140 bestStereo = dwFlags & PFD_STEREO;
1141 bestAlpha = alpha;
1142 bestColor = color;
1143 bestDepth = depth;
1144 bestStencil = stencil;
1145 bestAux = aux;
1146 bestFormat = i;
1147 continue;
1148 } else if(bestStencil != stencil) {
1149 TRACE("stencil mismatch for iPixelFormat=%d\n", i+1);
1150 continue;
1151 }
1152
1153 /* Aux buffers */
1154 if( ((ppfd->cAuxBuffers > bestAux) && (aux > bestAux)) ||
1155 ((aux >= ppfd->cAuxBuffers) && (aux < bestAux)) )
1156 {
1157 bestDBuffer = dwFlags & PFD_DOUBLEBUFFER;
1158 bestStereo = dwFlags & PFD_STEREO;
1159 bestAlpha = alpha;
1160 bestColor = color;
1161 bestDepth = depth;
1162 bestStencil = stencil;
1163 bestAux = aux;
1164 bestFormat = i;
1165 continue;
1166 } else if(bestAux != aux) {
1167 TRACE("aux mismatch for iPixelFormat=%d\n", i+1);
1168 continue;
1169 }
1170 }
1171
1172 if(bestFormat == -1) {
1173 TRACE("No matching mode was found returning 0\n");
1174 ret = 0;
1175 }
1176 else {
1177 ret = bestFormat+1; /* the return value should be a 1-based index */
1178 TRACE("Successfully found a matching mode, returning index: %d %x\n", ret, WineGLPixelFormatList[bestFormat].fmt_id);
1179 }
1180
1181 wine_tsx11_unlock();
1182
1183 return ret;
1184 }
1185 /**
1186 * X11DRV_DescribePixelFormat
1187 *
1188 * Get the pixel-format descriptor associated to the given id
1189 */
1190 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
1191 int iPixelFormat,
1192 UINT nBytes,
1193 PIXELFORMATDESCRIPTOR *ppfd) {
1194 /*XVisualInfo *vis;*/
1195 int value;
1196 int rb,gb,bb,ab;
1197 WineGLPixelFormat *fmt;
1198 int ret = 0;
1199 int fmt_count = 0;
1200
1201 if (!has_opengl()) {
1202 ERR("No libGL on this box - disabling OpenGL support !\n");
1203 return 0;
1204 }
1205
1206 TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
1207
1208 /* 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 */
1209 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &fmt_count);
1210 if (ppfd == NULL) {
1211 /* The application is only querying the number of pixelformats */
1212 return fmt_count;
1213 } else if(fmt == NULL) {
1214 WARN("unexpected iPixelFormat(%d): not >=1 and <=nFormats(%d), returning NULL!\n", iPixelFormat, fmt_count);
1215 return 0;
1216 }
1217
1218 if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
1219 ERR("Wrong structure size !\n");
1220 /* Should set error */
1221 return 0;
1222 }
1223
1224 ret = fmt_count;
1225
1226 memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
1227 ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
1228 ppfd->nVersion = 1;
1229
1230 /* These flags are always the same... */
1231 ppfd->dwFlags = PFD_SUPPORT_OPENGL;
1232 /* Now the flags extracted from the Visual */
1233
1234 wine_tsx11_lock();
1235
1236 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_X_RENDERABLE, &value);
1237 if(value)
1238 ppfd->dwFlags |= PFD_SUPPORT_GDI;
1239
1240 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
1241 if(value & GLX_WINDOW_BIT)
1242 ppfd->dwFlags |= PFD_DRAW_TO_WINDOW;
1243 if(value & GLX_PIXMAP_BIT)
1244 ppfd->dwFlags |= PFD_DRAW_TO_BITMAP;
1245
1246 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_CONFIG_CAVEAT, &value);
1247 if(value == GLX_SLOW_CONFIG)
1248 ppfd->dwFlags |= PFD_GENERIC_ACCELERATED;
1249
1250 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &value);
1251 if (value) {
1252 ppfd->dwFlags |= PFD_DOUBLEBUFFER;
1253 ppfd->dwFlags &= ~PFD_SUPPORT_GDI;
1254 }
1255 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
1256
1257 /* Pixel type */
1258 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RENDER_TYPE, &value);
1259 if (value & GLX_RGBA_BIT)
1260 ppfd->iPixelType = PFD_TYPE_RGBA;
1261 else
1262 ppfd->iPixelType = PFD_TYPE_COLORINDEX;
1263
1264 /* Color bits */
1265 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BUFFER_SIZE, &value);
1266 ppfd->cColorBits = value;
1267
1268 /* Red, green, blue and alpha bits / shifts */
1269 if (ppfd->iPixelType == PFD_TYPE_RGBA) {
1270 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_RED_SIZE, &rb);
1271 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_GREEN_SIZE, &gb);
1272 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_BLUE_SIZE, &bb);
1273 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ALPHA_SIZE, &ab);
1274
1275 ppfd->cRedBits = rb;
1276 ppfd->cRedShift = gb + bb + ab;
1277 ppfd->cBlueBits = bb;
1278 ppfd->cBlueShift = ab;
1279 ppfd->cGreenBits = gb;
1280 ppfd->cGreenShift = bb + ab;
1281 ppfd->cAlphaBits = ab;
1282 ppfd->cAlphaShift = 0;
1283 } else {
1284 ppfd->cRedBits = 0;
1285 ppfd->cRedShift = 0;
1286 ppfd->cBlueBits = 0;
1287 ppfd->cBlueShift = 0;
1288 ppfd->cGreenBits = 0;
1289 ppfd->cGreenShift = 0;
1290 ppfd->cAlphaBits = 0;
1291 ppfd->cAlphaShift = 0;
1292 }
1293
1294 /* Accum RGBA bits */
1295 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_RED_SIZE, &rb);
1296 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_GREEN_SIZE, &gb);
1297 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_BLUE_SIZE, &bb);
1298 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_ALPHA_SIZE, &ab);
1299
1300 ppfd->cAccumBits = rb+gb+bb+ab;
1301 ppfd->cAccumRedBits = rb;
1302 ppfd->cAccumGreenBits = gb;
1303 ppfd->cAccumBlueBits = bb;
1304 ppfd->cAccumAlphaBits = ab;
1305
1306 /* Depth bits */
1307 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DEPTH_SIZE, &value);
1308 ppfd->cDepthBits = value;
1309
1310 /* stencil bits */
1311 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_STENCIL_SIZE, &value);
1312 ppfd->cStencilBits = value;
1313
1314 wine_tsx11_unlock();
1315
1316 /* Aux : to do ... */
1317
1318 ppfd->iLayerType = PFD_MAIN_PLANE;
1319
1320 if (TRACE_ON(opengl)) {
1321 dump_PIXELFORMATDESCRIPTOR(ppfd);
1322 }
1323
1324 return ret;
1325 }
1326
1327 /**
1328 * X11DRV_GetPixelFormat
1329 *
1330 * Get the pixel-format id used by this DC
1331 */
1332 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
1333 WineGLPixelFormat *fmt;
1334 int tmp;
1335 TRACE("(%p)\n", physDev);
1336
1337 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, physDev->current_pf, TRUE, &tmp);
1338 if(!fmt)
1339 {
1340 /* This happens on HDCs on which SetPixelFormat wasn't called yet */
1341 ERR("Unable to find a WineGLPixelFormat for iPixelFormat=%d\n", physDev->current_pf);
1342 return 0;
1343 }
1344 else if(fmt->offscreenOnly)
1345 {
1346 /* Offscreen formats can't be used with traditional WGL calls.
1347 * As has been verified on Windows GetPixelFormat doesn't fail but returns iPixelFormat=1. */
1348 TRACE("Returning iPixelFormat=1 for offscreen format: %d\n", fmt->iPixelFormat);
1349 return 1;
1350 }
1351
1352 TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
1353 return physDev->current_pf;
1354 }
1355
1356 /**
1357 * X11DRV_SetPixelFormat
1358 *
1359 * Set the pixel-format id used by this DC
1360 */
1361 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
1362 int iPixelFormat,
1363 const PIXELFORMATDESCRIPTOR *ppfd) {
1364 WineGLPixelFormat *fmt;
1365 int value;
1366 HWND hwnd;
1367
1368 TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
1369
1370 if (!has_opengl()) {
1371 ERR("No libGL on this box - disabling OpenGL support !\n");
1372 return FALSE;
1373 }
1374
1375 /* SetPixelFormat is not allowed on the X root_window e.g. GetDC(0) */
1376 if(get_glxdrawable(physDev) == root_window)
1377 {
1378 ERR("Invalid operation on root_window\n");
1379 return FALSE;
1380 }
1381
1382 /* Check if iPixelFormat is in our list of supported formats to see if it is supported. */
1383 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, FALSE /* Offscreen */, &value);
1384 if(!fmt) {
1385 ERR("Invalid iPixelFormat: %d\n", iPixelFormat);
1386 return FALSE;
1387 }
1388
1389 if(physDev->current_pf) /* cannot change it if already set */
1390 return (physDev->current_pf == iPixelFormat);
1391
1392 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
1393
1394 hwnd = WindowFromDC(physDev->hdc);
1395 if(hwnd) {
1396 if(!(value&GLX_WINDOW_BIT)) {
1397 WARN("Pixel format %d is not compatible for window rendering\n", iPixelFormat);
1398 return FALSE;
1399 }
1400
1401 if(!SendMessageW(hwnd, WM_X11DRV_SET_WIN_FORMAT, (WPARAM)fmt->fmt_id, 0)) {
1402 ERR("Couldn't set format of the window, returning failure\n");
1403 return FALSE;
1404 }
1405 }
1406
1407 physDev->current_pf = iPixelFormat;
1408
1409 if (TRACE_ON(opengl)) {
1410 int gl_test = 0;
1411
1412 gl_test = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_FBCONFIG_ID, &value);
1413 if (gl_test) {
1414 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
1415 } else {
1416 TRACE(" FBConfig have :\n");
1417 TRACE(" - FBCONFIG_ID 0x%x\n", value);
1418 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_VISUAL_ID, &value);
1419 TRACE(" - VISUAL_ID 0x%x\n", value);
1420 pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &value);
1421 TRACE(" - DRAWABLE_TYPE 0x%x\n", value);
1422 }
1423 }
1424 return TRUE;
1425 }
1426
1427 /**
1428 * X11DRV_wglCreateContext
1429 *
1430 * For OpenGL32 wglCreateContext.
1431 */
1432 HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev)
1433 {
1434 Wine_GLContext *ret;
1435 WineGLPixelFormat *fmt;
1436 int hdcPF = physDev->current_pf;
1437 int fmt_count = 0;
1438 HDC hdc = physDev->hdc;
1439
1440 TRACE("(%p)->(PF:%d)\n", hdc, hdcPF);
1441
1442 if (!has_opengl()) {
1443 ERR("No libGL on this box - disabling OpenGL support !\n");
1444 return 0;
1445 }
1446
1447 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, hdcPF, TRUE /* Offscreen */, &fmt_count);
1448 /* We can render using the iPixelFormat (1) of Wine's Main visual AND using some offscreen formats.
1449 * Note that standard WGL-calls don't recognize offscreen-only formats. For that reason pbuffers
1450 * use a sort of 'proxy' HDC (wglGetPbufferDCARB).
1451 * If this fails something is very wrong on the system. */
1452 if(!fmt) {
1453 ERR("Cannot get FB Config for iPixelFormat %d, expect problems!\n", hdcPF);
1454 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
1455 return NULL;
1456 }
1457
1458 /* The context will be allocated in the wglMakeCurrent call */
1459 wine_tsx11_lock();
1460 ret = alloc_context();
1461 wine_tsx11_unlock();
1462 ret->hdc = hdc;
1463 ret->physDev = physDev;
1464 ret->fmt = fmt;
1465
1466 /*ret->vis = vis;*/
1467 ret->vis = pglXGetVisualFromFBConfig(gdi_display, fmt->fbconfig);
1468
1469 TRACE(" creating context %p (GL context creation delayed)\n", ret);
1470 return (HGLRC) ret;
1471 }
1472
1473 /**
1474 * X11DRV_wglDeleteContext
1475 *
1476 * For OpenGL32 wglDeleteContext.
1477 */
1478 BOOL X11DRV_wglDeleteContext(HGLRC hglrc)
1479 {
1480 Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1481 BOOL ret = TRUE;
1482
1483 TRACE("(%p)\n", hglrc);
1484
1485 if (!has_opengl()) {
1486 ERR("No libGL on this box - disabling OpenGL support !\n");
1487 return 0;
1488 }
1489
1490 wine_tsx11_lock();
1491 /* A game (Half Life not to name it) deletes twice the same context,
1492 * so make sure it is valid first */
1493 if (is_valid_context( ctx ))
1494 {
1495 if (ctx->ctx) pglXDestroyContext(gdi_display, ctx->ctx);
1496 free_context(ctx);
1497 }
1498 else
1499 {
1500 WARN("Error deleting context !\n");
1501 SetLastError(ERROR_INVALID_HANDLE);
1502 ret = FALSE;
1503 }
1504 wine_tsx11_unlock();
1505
1506 return ret;
1507 }
1508
1509 /**
1510 * X11DRV_wglGetCurrentReadDCARB
1511 *
1512 * For OpenGL32 wglGetCurrentReadDCARB.
1513 */
1514 static HDC WINAPI X11DRV_wglGetCurrentReadDCARB(void)
1515 {
1516 HDC ret = 0;
1517 Wine_GLContext *ctx = NtCurrentTeb()->glContext;
1518 X11DRV_PDEVICE *physDev = ctx ? ctx->pReadDev : NULL;
1519
1520 if(physDev)
1521 ret = physDev->hdc;
1522
1523 TRACE(" returning %p (GL drawable %lu)\n", ret, physDev ? physDev->drawable : 0);
1524 return ret;
1525 }
1526
1527 /**
1528 * X11DRV_wglGetProcAddress
1529 *
1530 * For OpenGL32 wglGetProcAddress.
1531 */
1532 PROC X11DRV_wglGetProcAddress(LPCSTR lpszProc)
1533 {
1534 int i, j;
1535 const WineGLExtension *ext;
1536
1537 int padding = 32 - strlen(lpszProc);
1538 if (padding < 0)
1539 padding = 0;
1540
1541 if (!has_opengl()) {
1542 ERR("No libGL on this box - disabling OpenGL support !\n");
1543 return 0;
1544 }
1545
1546 /* Check the table of WGL extensions to see if we need to return a WGL extension
1547 * or a function pointer to a native OpenGL function. */
1548 if(strncmp(lpszProc, "wgl", 3) != 0) {
1549 return pglXGetProcAddressARB((const GLubyte*)lpszProc);
1550 } else {
1551 TRACE("('%s'):%*s", lpszProc, padding, " ");
1552 for (i = 0; i < WineGLExtensionListSize; ++i) {
1553 ext = WineGLExtensionList[i];
1554 for (j = 0; ext->extEntryPoints[j].funcName; ++j) {
1555 if (strcmp(ext->extEntryPoints[j].funcName, lpszProc) == 0) {
1556 TRACE("(%p) - WineGL\n", ext->extEntryPoints[j].funcAddress);
1557 return ext->extEntryPoints[j].funcAddress;
1558 }
1559 }
1560 }
1561 }
1562
1563 WARN("(%s) - not found\n", lpszProc);
1564 return NULL;
1565 }
1566
1567 /***********************************************************************
1568 * sync_current_drawable
1569 *
1570 * Adjust the current viewport and scissor in order to position
1571 * and size the current drawable correctly on the parent window.
1572 */
1573 static void sync_current_drawable(BOOL updatedc)
1574 {
1575 int dy;
1576 int width;
1577 int height;
1578 RECT rc;
1579 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1580
1581 TRACE("\n");
1582
1583 if (ctx && ctx->physDev)
1584 {
1585 if (updatedc)
1586 GetClipBox(ctx->physDev->hdc, &rc); /* Make sure physDev is up to date */
1587
1588 dy = ctx->physDev->drawable_rect.bottom - ctx->physDev->drawable_rect.top -
1589 ctx->physDev->dc_rect.bottom;
1590 width = ctx->physDev->dc_rect.right - ctx->physDev->dc_rect.left;
1591 height = ctx->physDev->dc_rect.bottom - ctx->physDev->dc_rect.top;
1592
1593 wine_tsx11_lock();
1594
1595 pglViewport(ctx->physDev->dc_rect.left + ctx->viewport.left,
1596 dy + ctx->viewport.top,
1597 ctx->viewport.right ? (ctx->viewport.right - ctx->viewport.left) : width,
1598 ctx->viewport.bottom ? (ctx->viewport.bottom - ctx->viewport.top) : height);
1599
1600 pglEnable(GL_SCISSOR_TEST);
1601
1602 if (ctx->scissor_enabled)
1603 pglScissor(ctx->physDev->dc_rect.left + min(width, max(0, ctx->scissor.left)),
1604 dy + min(height, max(0, ctx->scissor.top)),
1605 min(width, max(0, ctx->scissor.right - ctx->scissor.left)),
1606 min(height, max(0, ctx->scissor.bottom - ctx->scissor.top)));
1607 else
1608 pglScissor(ctx->physDev->dc_rect.left, dy, width, height);
1609
1610 wine_tsx11_unlock();
1611 }
1612 }
1613
1614 /**
1615 * X11DRV_wglMakeCurrent
1616 *
1617 * For OpenGL32 wglMakeCurrent.
1618 */
1619 BOOL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
1620 BOOL ret;
1621 HDC hdc = physDev->hdc;
1622 DWORD type = GetObjectType(hdc);
1623
1624 TRACE("(%p,%p)\n", hdc, hglrc);
1625
1626 if (!has_opengl()) {
1627 ERR("No libGL on this box - disabling OpenGL support !\n");
1628 return 0;
1629 }
1630
1631 wine_tsx11_lock();
1632 if (hglrc == NULL) {
1633 ret = pglXMakeCurrent(gdi_display, None, NULL);
1634 NtCurrentTeb()->glContext = NULL;
1635 } else {
1636 Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1637 Drawable drawable = get_glxdrawable(physDev);
1638 if (ctx->ctx == NULL) {
1639 /* The describe lines below are for debugging purposes only */
1640 if (TRACE_ON(wgl)) {
1641 describeDrawable(ctx, drawable);
1642 describeContext(ctx);
1643 }
1644
1645 /* Create a GLX context using the same visual as chosen earlier in wglCreateContext.
1646 * We are certain that the drawable and context are compatible as we only allow compatible formats.
1647 */
1648 TRACE(" Creating GLX Context\n");
1649 if(ctx->vis)
1650 ctx->ctx = pglXCreateContext(gdi_display, ctx->vis, NULL, type == OBJ_MEMDC ? False : True);
1651 else /* Create a GLX Context for a pbuffer */
1652 ctx->ctx = pglXCreateNewContext(gdi_display, ctx->fmt->fbconfig, ctx->fmt->render_type, NULL, True);
1653
1654 TRACE(" created a delayed OpenGL context (%p)\n", ctx->ctx);
1655 }
1656 TRACE(" make current for dis %p, drawable %p, ctx %p\n", gdi_display, (void*) drawable, ctx->ctx);
1657 ret = pglXMakeCurrent(gdi_display, drawable, ctx->ctx);
1658 NtCurrentTeb()->glContext = ctx;
1659 if(ret)
1660 {
1661 ctx->hdc = hdc;
1662 ctx->physDev = physDev;
1663 ctx->pReadDev = physDev;
1664
1665 if (type == OBJ_MEMDC)
1666 {
1667 ctx->do_escape = TRUE;
1668 pglDrawBuffer(GL_FRONT_LEFT);
1669 }
1670 else
1671 {
1672 sync_current_drawable(FALSE);
1673 }
1674 }
1675 }
1676 wine_tsx11_unlock();
1677 TRACE(" returning %s\n", (ret ? "True" : "False"));
1678 return ret;
1679 }
1680
1681 /**
1682 * X11DRV_wglMakeContextCurrentARB
1683 *
1684 * For OpenGL32 wglMakeContextCurrentARB
1685 */
1686 BOOL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* pDrawDev, X11DRV_PDEVICE* pReadDev, HGLRC hglrc)
1687 {
1688 BOOL ret;
1689 TRACE("(%p,%p,%p)\n", pDrawDev, pReadDev, hglrc);
1690
1691 if (!has_opengl()) {
1692 ERR("No libGL on this box - disabling OpenGL support !\n");
1693 return 0;
1694 }
1695
1696 wine_tsx11_lock();
1697 if (hglrc == NULL) {
1698 ret = pglXMakeCurrent(gdi_display, None, NULL);
1699 NtCurrentTeb()->glContext = NULL;
1700 } else {
1701 if (NULL == pglXMakeContextCurrent) {
1702 ret = FALSE;
1703 } else {
1704 Wine_GLContext *ctx = (Wine_GLContext *) hglrc;
1705 Drawable d_draw = get_glxdrawable(pDrawDev);
1706 Drawable d_read = get_glxdrawable(pReadDev);
1707
1708 if (ctx->ctx == NULL) {
1709 ctx->ctx = pglXCreateContext(gdi_display, ctx->vis, NULL, GetObjectType(pDrawDev->hdc) == OBJ_MEMDC ? False : True);
1710 TRACE(" created a delayed OpenGL context (%p)\n", ctx->ctx);
1711 }
1712 ctx->hdc = pDrawDev->hdc;
1713 ctx->physDev = pDrawDev;
1714 ctx->pReadDev = pReadDev;
1715 ret = pglXMakeContextCurrent(gdi_display, d_draw, d_read, ctx->ctx);
1716 NtCurrentTeb()->glContext = ctx;
1717 }
1718 }
1719 wine_tsx11_unlock();
1720
1721 TRACE(" returning %s\n", (ret ? "True" : "False"));
1722 return ret;
1723 }
1724
1725 /**
1726 * X11DRV_wglShareLists
1727 *
1728 * For OpenGL32 wglShaderLists.
1729 */
1730 BOOL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
1731 Wine_GLContext *org = (Wine_GLContext *) hglrc1;
1732 Wine_GLContext *dest = (Wine_GLContext *) hglrc2;
1733
1734 TRACE("(%p, %p)\n", org, dest);
1735
1736 if (!has_opengl()) {
1737 ERR("No libGL on this box - disabling OpenGL support !\n");
1738 return 0;
1739 }
1740
1741 if (NULL != dest && dest->ctx != NULL) {
1742 ERR("Could not share display lists, context already created !\n");
1743 return FALSE;
1744 } else {
1745 if (org->ctx == NULL) {
1746 wine_tsx11_lock();
1747 describeContext(org);
1748
1749 if(org->vis)
1750 org->ctx = pglXCreateContext(gdi_display, org->vis, NULL, GetObjectType(org->hdc) == OBJ_MEMDC ? False : True);
1751 else /* Create a GLX Context for a pbuffer */
1752 org->ctx = pglXCreateNewContext(gdi_display, org->fmt->fbconfig, org->fmt->render_type, NULL, True);
1753 wine_tsx11_unlock();
1754 TRACE(" created a delayed OpenGL context (%p) for Wine context %p\n", org->ctx, org);
1755 }
1756 if (NULL != dest) {
1757 wine_tsx11_lock();
1758 describeContext(dest);
1759 /* Create the destination context with display lists shared */
1760 if(dest->vis)
1761 dest->ctx = pglXCreateContext(gdi_display, dest->vis, org->ctx, GetObjectType(org->hdc) == OBJ_MEMDC ? False : True);
1762 else /* Create a GLX Context for a pbuffer */
1763 dest->ctx = pglXCreateNewContext(gdi_display, dest->fmt->fbconfig, dest->fmt->render_type, org->ctx, True);
1764 wine_tsx11_unlock();
1765 TRACE(" created a delayed OpenGL context (%p) for Wine context %p sharing lists with OpenGL ctx %p\n", dest->ctx, dest, org->ctx);
1766 return TRUE;
1767 }
1768 }
1769 return FALSE;
1770 }
1771
1772 static BOOL internal_wglUseFontBitmaps(HDC hdc, DWORD first, DWORD count, DWORD listBase, DWORD (WINAPI *GetGlyphOutline_ptr)(HDC,UINT,UINT,LPGLYPHMETRICS,DWORD,LPVOID,const MAT2*))
1773 {
1774 /* We are running using client-side rendering fonts... */
1775 GLYPHMETRICS gm;
1776 unsigned int glyph;
1777 int size = 0;
1778 void *bitmap = NULL, *gl_bitmap = NULL;
1779 int org_alignment;
1780
1781 wine_tsx11_lock();
1782 pglGetIntegerv(GL_UNPACK_ALIGNMENT, &org_alignment);
1783 pglPixelStorei(GL_UNPACK_ALIGNMENT, 4);
1784 wine_tsx11_unlock();
1785
1786 for (glyph = first; glyph < first + count; glyph++) {
1787 unsigned int needed_size = GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, 0, NULL, NULL);
1788 int height, width_int;
1789
1790 TRACE("Glyph : %3d / List : %d\n", glyph, listBase);
1791 if (needed_size == GDI_ERROR) {
1792 TRACE(" - needed size : %d (GDI_ERROR)\n", needed_size);
1793 goto error;
1794 } else {
1795 TRACE(" - needed size : %d\n", needed_size);
1796 }
1797
1798 if (needed_size > size) {
1799 size = needed_size;
1800 HeapFree(GetProcessHeap(), 0, bitmap);
1801 HeapFree(GetProcessHeap(), 0, gl_bitmap);
1802 bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1803 gl_bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
1804 }
1805 if (GetGlyphOutline_ptr(hdc, glyph, GGO_BITMAP, &gm, size, bitmap, NULL) == GDI_ERROR) goto error;
1806 if (TRACE_ON(opengl)) {
1807 unsigned int height, width, bitmask;
1808 unsigned char *bitmap_ = (unsigned char *) bitmap;
1809
1810 TRACE(" - bbox : %d x %d\n", gm.gmBlackBoxX, gm.gmBlackBoxY);
1811 TRACE(" - origin : (%d , %d)\n", gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
1812 TRACE(" - increment : %d - %d\n", gm.gmCellIncX, gm.gmCellIncY);
1813 if (needed_size != 0) {
1814 TRACE(" - bitmap :\n");
1815 for (height = 0; height < gm.gmBlackBoxY; height++) {
1816 TRACE(" ");
1817 for (width = 0, bitmask = 0x80; width < gm.gmBlackBoxX; width++, bitmask >>= 1) {
1818 if (bitmask == 0) {
1819 bitmap_ += 1;
1820 bitmask = 0x80;
1821 }
1822 if (*bitmap_ & bitmask)
1823 TRACE("*");
1824 else
1825 TRACE(" ");
1826 }
1827 bitmap_ += (4 - ((UINT_PTR)bitmap_ & 0x03));
1828 TRACE("\n");
1829 }
1830 }
1831 }
1832
1833 /* In OpenGL, the bitmap is drawn from the bottom to the top... So we need to invert the
1834 * glyph for it to be drawn properly.
1835 */
1836 if (needed_size != 0) {
1837 width_int = (gm.gmBlackBoxX + 31) / 32;
1838 for (height = 0; height < gm.gmBlackBoxY; height++) {
1839 int width;
1840 for (width = 0; width < width_int; width++) {
1841 ((int *) gl_bitmap)[(gm.gmBlackBoxY - height - 1) * width_int + width] =
1842 ((int *) bitmap)[height * width_int + width];
1843 }
1844 }
1845 }
1846
1847 wine_tsx11_lock();
1848 pglNewList(listBase++, GL_COMPILE);
1849 if (needed_size != 0) {
1850 pglBitmap(gm.gmBlackBoxX, gm.gmBlackBoxY,
1851 0 - (int) gm.gmptGlyphOrigin.x, (int) gm.gmBlackBoxY - (int) gm.gmptGlyphOrigin.y,
1852 gm.gmCellIncX, gm.gmCellIncY,
1853 gl_bitmap);
1854 } else {
1855 /* This is the case of 'empty' glyphs like the space character */
1856 pglBitmap(0, 0, 0, 0, gm.gmCellIncX, gm.gmCellIncY, NULL);
1857 }
1858 pglEndList();
1859 wine_tsx11_unlock();
1860 }
1861
1862 wine_tsx11_lock();
1863 pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
1864 wine_tsx11_unlock();
1865
1866 HeapFree(GetProcessHeap(), 0, bitmap);
1867 HeapFree(GetProcessHeap(), 0, gl_bitmap);
1868 return TRUE;
1869
1870 error:
1871 wine_tsx11_lock();
1872 pglPixelStorei(GL_UNPACK_ALIGNMENT, org_alignment);
1873 wine_tsx11_unlock();
1874
1875 HeapFree(GetProcessHeap(), 0, bitmap);
1876 HeapFree(GetProcessHeap(), 0, gl_bitmap);
1877 return FALSE;
1878 }
1879
1880 /**
1881 * X11DRV_wglUseFontBitmapsA
1882 *
1883 * For OpenGL32 wglUseFontBitmapsA.
1884 */
1885 BOOL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
1886 {
1887 Font fid = physDev->font;
1888
1889 TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
1890
1891 if (!has_opengl()) {
1892 ERR("No libGL on this box - disabling OpenGL support !\n");
1893 return 0;
1894 }
1895
1896 if (fid == 0) {
1897 return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineA);
1898 }
1899
1900 wine_tsx11_lock();
1901 /* I assume that the glyphs are at the same position for X and for Windows */
1902 pglXUseXFont(fid, first, count, listBase);
1903 wine_tsx11_unlock();
1904 return TRUE;
1905 }
1906
1907 /**
1908 * X11DRV_wglUseFontBitmapsW
1909 *
1910 * For OpenGL32 wglUseFontBitmapsW.
1911 */
1912 BOOL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
1913 {
1914 Font fid = physDev->font;
1915
1916 TRACE("(%p, %d, %d, %d) using font %ld\n", physDev->hdc, first, count, listBase, fid);
1917
1918 if (!has_opengl()) {
1919 ERR("No libGL on this box - disabling OpenGL support !\n");
1920 return 0;
1921 }
1922
1923 if (fid == 0) {
1924 return internal_wglUseFontBitmaps(physDev->hdc, first, count, listBase, GetGlyphOutlineW);
1925 }
1926
1927 WARN("Using the glX API for the WCHAR variant - some characters may come out incorrectly !\n");
1928
1929 wine_tsx11_lock();
1930 /* I assume that the glyphs are at the same position for X and for Windows */
1931 pglXUseXFont(fid, first, count, listBase);
1932 wine_tsx11_unlock();
1933 return TRUE;
1934 }
1935
1936 static void WINAPI X11DRV_wglDisable(GLenum cap)
1937 {
1938 if (cap == GL_SCISSOR_TEST)
1939 {
1940 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1941
1942 if (ctx)
1943 ctx->scissor_enabled = FALSE;
1944 }
1945 else
1946 {
1947 wine_tsx11_lock();
1948 pglDisable(cap);
1949 wine_tsx11_unlock();
1950 }
1951 }
1952
1953 static void WINAPI X11DRV_wglEnable(GLenum cap)
1954 {
1955 if (cap == GL_SCISSOR_TEST)
1956 {
1957 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
1958
1959 if (ctx)
1960 ctx->scissor_enabled = TRUE;
1961 }
1962 else
1963 {
1964 wine_tsx11_lock();
1965 pglEnable(cap);
1966 wine_tsx11_unlock();
1967 }
1968 }
1969
1970 /* WGL helper function which handles differences in glGetIntegerv from WGL and GLX */
1971 static void WINAPI X11DRV_wglGetIntegerv(GLenum pname, GLint* params)
1972 {
1973 wine_tsx11_lock();
1974 switch(pname)
1975 {
1976 case GL_DEPTH_BITS:
1977 {
1978 Wine_GLContext *ctx = NtCurrentTeb()->glContext;
1979
1980 pglGetIntegerv(pname, params);
1981 /**
1982 * if we cannot find a Wine Context
1983 * we only have the default wine desktop context,
1984 * so if we have only a 24 depth say we have 32
1985 */
1986 if (!ctx && *params == 24) {
1987 *params = 32;
1988 }
1989 TRACE("returns GL_DEPTH_BITS as '%d'\n", *params);
1990 break;
1991 }
1992 case GL_ALPHA_BITS:
1993 {
1994 Wine_GLContext *ctx = NtCurrentTeb()->glContext;
1995
1996 pglXGetFBConfigAttrib(gdi_display, ctx->fmt->fbconfig, GLX_ALPHA_SIZE, params);
1997 TRACE("returns GL_ALPHA_BITS as '%d'\n", *params);
1998 break;
1999 }
2000 default:
2001 pglGetIntegerv(pname, params);
2002 break;
2003 }
2004 wine_tsx11_unlock();
2005 }
2006
2007 static GLboolean WINAPI X11DRV_wglIsEnabled(GLenum cap)
2008 {
2009 GLboolean enabled = False;
2010
2011 if (cap == GL_SCISSOR_TEST)
2012 {
2013 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
2014
2015 if (ctx)
2016 enabled = ctx->scissor_enabled;
2017 }
2018 else
2019 {
2020 wine_tsx11_lock();
2021 enabled = pglIsEnabled(cap);
2022 wine_tsx11_unlock();
2023 }
2024 return enabled;
2025 }
2026
2027 static void WINAPI X11DRV_wglScissor(GLint x, GLint y, GLsizei width, GLsizei height)
2028 {
2029 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
2030
2031 if (ctx)
2032 {
2033 ctx->scissor.left = x;
2034 ctx->scissor.top = y;
2035 ctx->scissor.right = x + width;
2036 ctx->scissor.bottom = y + height;
2037
2038 sync_current_drawable(TRUE);
2039 }
2040 }
2041
2042 static void WINAPI X11DRV_wglViewport(GLint x, GLint y, GLsizei width, GLsizei height)
2043 {
2044 Wine_GLContext *ctx = (Wine_GLContext *) NtCurrentTeb()->glContext;
2045
2046 if (ctx)
2047 {
2048 ctx->viewport.left = x;
2049 ctx->viewport.top = y;
2050 ctx->viewport.right = x + width;
2051 ctx->viewport.bottom = y + height;
2052
2053 sync_current_drawable(TRUE);
2054 }
2055 }
2056
2057 /**
2058 * X11DRV_wglGetExtensionsStringARB
2059 *
2060 * WGL_ARB_extensions_string: wglGetExtensionsStringARB
2061 */
2062 static const char * WINAPI X11DRV_wglGetExtensionsStringARB(HDC hdc) {
2063 TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
2064 return WineGLInfo.wglExtensions;
2065 }
2066
2067 /**
2068 * X11DRV_wglCreatePbufferARB
2069 *
2070 * WGL_ARB_pbuffer: wglCreatePbufferARB
2071 */
2072 static HPBUFFERARB WINAPI X11DRV_wglCreatePbufferARB(HDC hdc, int iPixelFormat, int iWidth, int iHeight, const int *piAttribList)
2073 {
2074 Wine_GLPBuffer* object = NULL;
2075 WineGLPixelFormat *fmt = NULL;
2076 int nCfgs = 0;
2077 int attribs[256];
2078 int nAttribs = 0;
2079
2080 TRACE("(%p, %d, %d, %d, %p)\n", hdc, iPixelFormat, iWidth, iHeight, piAttribList);
2081
2082 if (0 >= iPixelFormat) {
2083 ERR("(%p): unexpected iPixelFormat(%d) <= 0, returns NULL\n", hdc, iPixelFormat);
2084 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2085 return NULL; /* unexpected error */
2086 }
2087
2088 /* Convert the WGL pixelformat to a GLX format, if it fails then the format is invalid */
2089 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, TRUE /* Offscreen */, &nCfgs);
2090 if(!fmt) {
2091 ERR("(%p): unexpected iPixelFormat(%d) > nFormats(%d), returns NULL\n", hdc, iPixelFormat, nCfgs);
2092 SetLastError(ERROR_INVALID_PIXEL_FORMAT);
2093 goto create_failed; /* unexpected error */
2094 }
2095
2096 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(Wine_GLPBuffer));
2097 if (NULL == object) {
2098 SetLastError(ERROR_NO_SYSTEM_RESOURCES);
2099 goto create_failed; /* unexpected error */
2100 }
2101 object->hdc = hdc;
2102 object->display = gdi_display;
2103 object->width = iWidth;
2104 object->height = iHeight;
2105 object->fmt = fmt;
2106
2107 PUSH2(attribs, GLX_PBUFFER_WIDTH, iWidth);
2108 PUSH2(attribs, GLX_PBUFFER_HEIGHT, iHeight);
2109 while (piAttribList && 0 != *piAttribList) {
2110 int attr_v;
2111 switch (*piAttribList) {
2112 case WGL_PBUFFER_LARGEST_ARB: {
2113 ++piAttribList;
2114 attr_v = *piAttribList;
2115 TRACE("WGL_LARGEST_PBUFFER_ARB = %d\n", attr_v);
2116 PUSH2(attribs, GLX_LARGEST_PBUFFER, attr_v);
2117 break;
2118 }
2119
2120 case WGL_TEXTURE_FORMAT_ARB: {
2121 ++piAttribList;
2122 attr_v = *piAttribList;
2123 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_FORMAT_ARB as %x\n", attr_v);
2124 if (use_render_texture_ati) {
2125 int type = 0;
2126 switch (attr_v) {
2127 case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
2128 case WGL_TEXTURE_RGB_ARB: type = GLX_TEXTURE_RGB_ATI; break ;
2129 case WGL_TEXTURE_RGBA_ARB: type = GLX_TEXTURE_RGBA_ATI; break ;
2130 default:
2131 SetLastError(ERROR_INVALID_DATA);
2132 goto create_failed;
2133 }
2134 object->use_render_texture = 1;
2135 PUSH2(attribs, GLX_TEXTURE_FORMAT_ATI, type);
2136 } else {
2137 if (WGL_NO_TEXTURE_ARB == attr_v) {
2138 object->use_render_texture = 0;
2139 } else {
2140 if (!use_render_texture_emulation) {
2141 SetLastError(ERROR_INVALID_DATA);
2142 goto create_failed;
2143 }
2144 switch (attr_v) {
2145 case WGL_TEXTURE_RGB_ARB:
2146 object->use_render_texture = GL_RGB;
2147 object->texture_bpp = 3;
2148 object->texture_format = GL_RGB;
2149 object->texture_type = GL_UNSIGNED_BYTE;
2150 break;
2151 case WGL_TEXTURE_RGBA_ARB:
2152 object->use_render_texture = GL_RGBA;
2153 object->texture_bpp = 4;
2154 object->texture_format = GL_RGBA;
2155 object->texture_type = GL_UNSIGNED_BYTE;
2156 break;
2157
2158 /* WGL_FLOAT_COMPONENTS_NV */
2159 case WGL_TEXTURE_FLOAT_R_NV:
2160 object->use_render_texture = GL_FLOAT_R_NV;
2161 object->texture_bpp = 4;
2162 object->texture_format = GL_RED;
2163 object->texture_type = GL_FLOAT;
2164 break;
2165 case WGL_TEXTURE_FLOAT_RG_NV:
2166 object->use_render_texture = GL_FLOAT_RG_NV;
2167 object->texture_bpp = 8;
2168 object->texture_format = GL_LUMINANCE_ALPHA;
2169 object->texture_type = GL_FLOAT;
2170 break;
2171 case WGL_TEXTURE_FLOAT_RGB_NV:
2172 object->use_render_texture = GL_FLOAT_RGB_NV;
2173 object->texture_bpp = 12;
2174 object->texture_format = GL_RGB;
2175 object->texture_type = GL_FLOAT;
2176 break;
2177 case WGL_TEXTURE_FLOAT_RGBA_NV:
2178 object->use_render_texture = GL_FLOAT_RGBA_NV;
2179 object->texture_bpp = 16;
2180 object->texture_format = GL_RGBA;
2181 object->texture_type = GL_FLOAT;
2182 break;
2183 default:
2184 ERR("Unknown texture format: %x\n", attr_v);
2185 SetLastError(ERROR_INVALID_DATA);
2186 goto create_failed;
2187 }
2188 }
2189 }
2190 break;
2191 }
2192
2193 case WGL_TEXTURE_TARGET_ARB: {
2194 ++piAttribList;
2195 attr_v = *piAttribList;
2196 TRACE("WGL_render_texture Attribute: WGL_TEXTURE_TARGET_ARB as %x\n", attr_v);
2197 if (use_render_texture_ati) {
2198 int type = 0;
2199 switch (attr_v) {
2200 case WGL_NO_TEXTURE_ARB: type = GLX_NO_TEXTURE_ATI; break ;
2201 case WGL_TEXTURE_CUBE_MAP_ARB: type = GLX_TEXTURE_CUBE_MAP_ATI; break ;
2202 case WGL_TEXTURE_1D_ARB: type = GLX_TEXTURE_1D_ATI; break ;
2203 case WGL_TEXTURE_2D_ARB: type = GLX_TEXTURE_2D_ATI; break ;
2204 default:
2205 SetLastError(ERROR_INVALID_DATA);
2206 goto create_failed;
2207 }
2208 PUSH2(attribs, GLX_TEXTURE_TARGET_ATI, type);
2209 } else {
2210 if (WGL_NO_TEXTURE_ARB == attr_v) {
2211 object->texture_target = 0;
2212 } else {
2213 if (!use_render_texture_emulation) {
2214 SetLastError(ERROR_INVALID_DATA);
2215 goto create_failed;
2216 }
2217 switch (attr_v) {
2218 case WGL_TEXTURE_CUBE_MAP_ARB: {
2219 if (iWidth != iHeight) {
2220 SetLastError(ERROR_INVALID_DATA);
2221 goto create_failed;
2222 }
2223 object->texture_target = GL_TEXTURE_CUBE_MAP;
2224 object->texture_bind_target = GL_TEXTURE_BINDING_CUBE_MAP;
2225 break;
2226 }
2227 case WGL_TEXTURE_1D_ARB: {
2228 if (1 != iHeight) {
2229 SetLastError(ERROR_INVALID_DATA);
2230 goto create_failed;
2231 }
2232 object->texture_target = GL_TEXTURE_1D;
2233 object->texture_bind_target = GL_TEXTURE_BINDING_1D;
2234 break;
2235 }
2236 case WGL_TEXTURE_2D_ARB: {
2237 object->texture_target = GL_TEXTURE_2D;
2238 object->texture_bind_target = GL_TEXTURE_BINDING_2D;
2239 break;
2240 }
2241 case WGL_TEXTURE_RECTANGLE_NV: {
2242 object->texture_target = GL_TEXTURE_RECTANGLE_NV;
2243 object->texture_bind_target = GL_TEXTURE_BINDING_RECTANGLE_NV;
2244 break;
2245 }
2246 default:
2247 ERR("Unknown texture target: %x\n", attr_v);
2248 SetLastError(ERROR_INVALID_DATA);
2249 goto create_failed;
2250 }
2251 }
2252 }
2253 break;
2254 }
2255
2256 case WGL_MIPMAP_TEXTURE_ARB: {
2257 ++piAttribList;
2258 attr_v = *piAttribList;
2259 TRACE("WGL_render_texture Attribute: WGL_MIPMAP_TEXTURE_ARB as %x\n", attr_v);
2260 if (use_render_texture_ati) {
2261 PUSH2(attribs, GLX_MIPMAP_TEXTURE_ATI, attr_v);
2262 } else {
2263 if (!use_render_texture_emulation) {
2264 SetLastError(ERROR_INVALID_DATA);
2265 goto create_failed;
2266 }
2267 }
2268 break;
2269 }
2270 }
2271 ++piAttribList;
2272 }
2273
2274 PUSH1(attribs, None);
2275 object->drawable = pglXCreatePbuffer(gdi_display, fmt->fbconfig, attribs);
2276 TRACE("new Pbuffer drawable as %p\n", (void*) object->drawable);
2277 if (!object->drawable) {
2278 SetLastError(ERROR_NO_SYSTEM_RESOURCES);
2279 goto create_failed; /* unexpected error */
2280 }
2281 TRACE("->(%p)\n", object);
2282 return (HPBUFFERARB) object;
2283
2284 create_failed:
2285 HeapFree(GetProcessHeap(), 0, object);
2286 TRACE("->(FAILED)\n");
2287 return (HPBUFFERARB) NULL;
2288 }
2289
2290 /**
2291 * X11DRV_wglDestroyPbufferARB
2292 *
2293 * WGL_ARB_pbuffer: wglDestroyPbufferARB
2294 */
2295 static GLboolean WINAPI X11DRV_wglDestroyPbufferARB(HPBUFFERARB hPbuffer)
2296 {
2297 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2298 TRACE("(%p)\n", hPbuffer);
2299 if (NULL == object) {
2300 SetLastError(ERROR_INVALID_HANDLE);
2301 return GL_FALSE;
2302 }
2303 pglXDestroyPbuffer(object->display, object->drawable);
2304 HeapFree(GetProcessHeap(), 0, object);
2305 return GL_TRUE;
2306 }
2307
2308 /**
2309 * X11DRV_wglGetPbufferDCARB
2310 *
2311 * WGL_ARB_pbuffer: wglGetPbufferDCARB
2312 * The function wglGetPbufferDCARB returns a device context for a pbuffer.
2313 * Gdi32 implements the part of this function which creates a device context.
2314 * This part associates the physDev with the X drawable of the pbuffer.
2315 */
2316 HDC X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *physDev, HPBUFFERARB hPbuffer)
2317 {
2318 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2319 if (NULL == object) {
2320 SetLastError(ERROR_INVALID_HANDLE);
2321 return NULL;
2322 }
2323
2324 /* The function wglGetPbufferDCARB returns a DC to which the pbuffer can be connected.
2325 * All formats in our pixelformat list are compatible with each other and the main drawable. */
2326 physDev->current_pf = object->fmt->iPixelFormat;
2327 physDev->drawable = object->drawable;
2328 SetRect( &physDev->drawable_rect, 0, 0, object->width, object->height );
2329 physDev->dc_rect = physDev->drawable_rect;
2330
2331 TRACE("(%p)->(%p)\n", hPbuffer, physDev->hdc);
2332 return physDev->hdc;
2333 }
2334
2335 /**
2336 * X11DRV_wglQueryPbufferARB
2337 *
2338 * WGL_ARB_pbuffer: wglQueryPbufferARB
2339 */
2340 static GLboolean WINAPI X11DRV_wglQueryPbufferARB(HPBUFFERARB hPbuffer, int iAttribute, int *piValue)
2341 {
2342 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2343 TRACE("(%p, 0x%x, %p)\n", hPbuffer, iAttribute, piValue);
2344 if (NULL == object) {
2345 SetLastError(ERROR_INVALID_HANDLE);
2346 return GL_FALSE;
2347 }
2348 switch (iAttribute) {
2349 case WGL_PBUFFER_WIDTH_ARB:
2350 pglXQueryDrawable(object->display, object->drawable, GLX_WIDTH, (unsigned int*) piValue);
2351 break;
2352 case WGL_PBUFFER_HEIGHT_ARB:
2353 pglXQueryDrawable(object->display, object->drawable, GLX_HEIGHT, (unsigned int*) piValue);
2354 break;
2355
2356 case WGL_PBUFFER_LOST_ARB:
2357 /* GLX Pbuffers cannot be lost by default. We can support this by
2358 * setting GLX_PRESERVED_CONTENTS to False and using glXSelectEvent
2359 * to receive pixel buffer clobber events, however that may or may
2360 * not give any benefit */
2361 *piValue = GL_FALSE;
2362 break;
2363
2364 case WGL_TEXTURE_FORMAT_ARB:
2365 if (use_render_texture_ati) {
2366 unsigned int tmp;
2367 int type = WGL_NO_TEXTURE_ARB;
2368 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_FORMAT_ATI, &tmp);
2369 switch (tmp) {
2370 case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2371 case GLX_TEXTURE_RGB_ATI: type = WGL_TEXTURE_RGB_ARB; break ;
2372 case GLX_TEXTURE_RGBA_ATI: type = WGL_TEXTURE_RGBA_ARB; break ;
2373 }
2374 *piValue = type;
2375 } else {
2376 if (!object->use_render_texture) {
2377 *piValue = WGL_NO_TEXTURE_ARB;
2378 } else {
2379 if (!use_render_texture_emulation) {
2380 SetLastError(ERROR_INVALID_HANDLE);
2381 return GL_FALSE;
2382 }
2383 switch(object->use_render_texture) {
2384 case GL_RGB:
2385 *piValue = WGL_TEXTURE_RGB_ARB;
2386 break;
2387 case GL_RGBA:
2388 *piValue = WGL_TEXTURE_RGBA_ARB;
2389 break;
2390 /* WGL_FLOAT_COMPONENTS_NV */
2391 case GL_FLOAT_R_NV:
2392 *piValue = WGL_TEXTURE_FLOAT_R_NV;
2393 break;
2394 case GL_FLOAT_RG_NV:
2395 *piValue = WGL_TEXTURE_FLOAT_RG_NV;
2396 break;
2397 case GL_FLOAT_RGB_NV:
2398 *piValue = WGL_TEXTURE_FLOAT_RGB_NV;
2399 break;
2400 case GL_FLOAT_RGBA_NV:
2401 *piValue = WGL_TEXTURE_FLOAT_RGBA_NV;
2402 break;
2403 default:
2404 ERR("Unknown texture format: %x\n", object->use_render_texture);
2405 }
2406 }
2407 }
2408 break;
2409
2410 case WGL_TEXTURE_TARGET_ARB:
2411 if (use_render_texture_ati) {
2412 unsigned int tmp;
2413 int type = WGL_NO_TEXTURE_ARB;
2414 pglXQueryDrawable(object->display, object->drawable, GLX_TEXTURE_TARGET_ATI, &tmp);
2415 switch (tmp) {
2416 case GLX_NO_TEXTURE_ATI: type = WGL_NO_TEXTURE_ARB; break ;
2417 case GLX_TEXTURE_CUBE_MAP_ATI: type = WGL_TEXTURE_CUBE_MAP_ARB; break ;
2418 case GLX_TEXTURE_1D_ATI: type = WGL_TEXTURE_1D_ARB; break ;
2419 case GLX_TEXTURE_2D_ATI: type = WGL_TEXTURE_2D_ARB; break ;
2420 }
2421 *piValue = type;
2422 } else {
2423 if (!object->texture_target) {
2424 *piValue = WGL_NO_TEXTURE_ARB;
2425 } else {
2426 if (!use_render_texture_emulation) {
2427 SetLastError(ERROR_INVALID_DATA);
2428 return GL_FALSE;
2429 }
2430 switch (object->texture_target) {
2431 case GL_TEXTURE_1D: *piValue = WGL_TEXTURE_1D_ARB; break;
2432 case GL_TEXTURE_2D: *piValue = WGL_TEXTURE_2D_ARB; break;
2433 case GL_TEXTURE_CUBE_MAP: *piValue = WGL_TEXTURE_CUBE_MAP_ARB; break;
2434 case GL_TEXTURE_RECTANGLE_NV: *piValue = WGL_TEXTURE_RECTANGLE_NV; break;
2435 }
2436 }
2437 }
2438 break;
2439
2440 case WGL_MIPMAP_TEXTURE_ARB:
2441 if (use_render_texture_ati) {
2442 pglXQueryDrawable(object->display, object->drawable, GLX_MIPMAP_TEXTURE_ATI, (unsigned int*) piValue);
2443 } else {
2444 *piValue = GL_FALSE; /** don't support that */
2445 FIXME("unsupported WGL_ARB_render_texture attribute query for 0x%x\n", iAttribute);
2446 }
2447 break;
2448
2449 default:
2450 FIXME("unexpected attribute %x\n", iAttribute);
2451 break;
2452 }
2453
2454 return GL_TRUE;
2455 }
2456
2457 /**
2458 * X11DRV_wglReleasePbufferDCARB
2459 *
2460 * WGL_ARB_pbuffer: wglReleasePbufferDCARB
2461 */
2462 static int WINAPI X11DRV_wglReleasePbufferDCARB(HPBUFFERARB hPbuffer, HDC hdc)
2463 {
2464 TRACE("(%p, %p)\n", hPbuffer, hdc);
2465 DeleteDC(hdc);
2466 return 0;
2467 }
2468
2469 /**
2470 * X11DRV_wglSetPbufferAttribARB
2471 *
2472 * WGL_ARB_pbuffer: wglSetPbufferAttribARB
2473 */
2474 static GLboolean WINAPI X11DRV_wglSetPbufferAttribARB(HPBUFFERARB hPbuffer, const int *piAttribList)
2475 {
2476 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2477 WARN("(%p, %p): alpha-testing, report any problem\n", hPbuffer, piAttribList);
2478 if (NULL == object) {
2479 SetLastError(ERROR_INVALID_HANDLE);
2480 return GL_FALSE;
2481 }
2482 if (!object->use_render_texture) {
2483 SetLastError(ERROR_INVALID_HANDLE);
2484 return GL_FALSE;
2485 }
2486 if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2487 return GL_TRUE;
2488 }
2489 if (NULL != pglXDrawableAttribATI) {
2490 if (use_render_texture_ati) {
2491 FIXME("Need conversion for GLX_ATI_render_texture\n");
2492 }
2493 return pglXDrawableAttribATI(object->display, object->drawable, piAttribList);
2494 }
2495 return GL_FALSE;
2496 }
2497
2498 /**
2499 * X11DRV_wglChoosePixelFormatARB
2500 *
2501 * WGL_ARB_pixel_format: wglChoosePixelFormatARB
2502 */
2503 static GLboolean WINAPI X11DRV_wglChoosePixelFormatARB(HDC hdc, const int *piAttribIList, const FLOAT *pfAttribFList, UINT nMaxFormats, int *piFormats, UINT *nNumFormats)
2504 {
2505 int gl_test = 0;
2506 int attribs[256];
2507 int nAttribs = 0;
2508 GLXFBConfig* cfgs = NULL;
2509 int nCfgs = 0;
2510 UINT it;
2511 int fmt_id;
2512 WineGLPixelFormat *fmt;
2513 int pfmt_it = 0;
2514 int run;
2515
2516 TRACE("(%p, %p, %p, %d, %p, %p): hackish\n", hdc, piAttribIList, pfAttribFList, nMaxFormats, piFormats, nNumFormats);
2517 if (NULL != pfAttribFList) {
2518 FIXME("unused pfAttribFList\n");
2519 }
2520
2521 nAttribs = ConvertAttribWGLtoGLX(piAttribIList, attribs, NULL);
2522 if (-1 == nAttribs) {
2523 WARN("Cannot convert WGL to GLX attributes\n");
2524 return GL_FALSE;
2525 }
2526 PUSH1(attribs, None);
2527
2528 /* Search for FB configurations matching the requirements in attribs */
2529 cfgs = pglXChooseFBConfig(gdi_display, DefaultScreen(gdi_display), attribs, &nCfgs);
2530 if (NULL == cfgs) {
2531 WARN("Compatible Pixel Format not found\n");
2532 return GL_FALSE;
2533 }
2534
2535 /* Loop through all matching formats and check if they are suitable.
2536 * Note that this function should at max return nMaxFormats different formats */
2537 for(run=0; run < 2; run++)
2538 {
2539 for (it = 0; it < nCfgs; ++it) {
2540 gl_test = pglXGetFBConfigAttrib(gdi_display, cfgs[it], GLX_FBCONFIG_ID, &fmt_id);
2541 if (gl_test) {
2542 ERR("Failed to retrieve FBCONFIG_ID from GLXFBConfig, expect problems.\n");
2543 continue;
2544 }
2545
2546 /* Search for the format in our list of compatible formats */
2547 fmt = ConvertPixelFormatGLXtoWGL(gdi_display, fmt_id);
2548 if(!fmt)
2549 continue;
2550
2551 /* During the first run we only want onscreen formats and during the second only offscreen 'XOR' */
2552 if( ((run == 0) && fmt->offscreenOnly) || ((run == 1) && !fmt->offscreenOnly) )
2553 continue;
2554
2555 if(pfmt_it < nMaxFormats) {
2556 piFormats[pfmt_it] = fmt->iPixelFormat;
2557 TRACE("at %d/%d found FBCONFIG_ID 0x%x (%d)\n", it + 1, nCfgs, fmt_id, piFormats[pfmt_it]);
2558 }
2559 pfmt_it++;
2560 }
2561 }
2562
2563 *nNumFormats = pfmt_it;
2564 /** free list */
2565 XFree(cfgs);
2566 return GL_TRUE;
2567 }
2568
2569 /**
2570 * X11DRV_wglGetPixelFormatAttribivARB
2571 *
2572 * WGL_ARB_pixel_format: wglGetPixelFormatAttribivARB
2573 */
2574 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribivARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, int *piValues)
2575 {
2576 UINT i;
2577 WineGLPixelFormat *fmt = NULL;
2578 int hTest;
2579 int tmp;
2580 int curGLXAttr = 0;
2581 int nWGLFormats = 0;
2582
2583 TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, piValues);
2584
2585 if (0 < iLayerPlane) {
2586 FIXME("unsupported iLayerPlane(%d) > 0, returns FALSE\n", iLayerPlane);
2587 return GL_FALSE;
2588 }
2589
2590 /* Convert the WGL pixelformat to a GLX one, if this fails then most likely the iPixelFormat isn't supoprted.
2591 * We don't have to fail yet as a program can specify an invaled iPixelFormat (lets say 0) if it wants to query
2592 * the number of supported WGL formats. Whether the iPixelFormat is valid is handled in the for-loop below. */
2593 fmt = ConvertPixelFormatWGLtoGLX(gdi_display, iPixelFormat, TRUE /* Offscreen */, &nWGLFormats);
2594 if(!fmt) {
2595 WARN("Unable to convert iPixelFormat %d to a GLX one!\n", iPixelFormat);
2596 }
2597
2598 for (i = 0; i < nAttributes; ++i) {
2599 const int curWGLAttr = piAttributes[i];
2600 TRACE("pAttr[%d] = %x\n", i, curWGLAttr);
2601
2602 switch (curWGLAttr) {
2603 case WGL_NUMBER_PIXEL_FORMATS_ARB:
2604 piValues[i] = nWGLFormats;
2605 continue;
2606
2607 case WGL_SUPPORT_OPENGL_ARB:
2608 piValues[i] = GL_TRUE;
2609 continue;
2610
2611 case WGL_ACCELERATION_ARB:
2612 curGLXAttr = GLX_CONFIG_CAVEAT;
2613 if (!fmt) goto pix_error;
2614 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2615 if (hTest) goto get_error;
2616 switch (tmp) {
2617 case GLX_NONE: piValues[i] = WGL_FULL_ACCELERATION_ARB; break;
2618 case GLX_SLOW_CONFIG: piValues[i] = WGL_GENERIC_ACCELERATION_ARB; break;
2619 case GLX_NON_CONFORMANT_CONFIG: piValues[i] = WGL_FULL_ACCELERATION_ARB; break;
2620 default:
2621 ERR("unexpected Config Caveat(%x)\n", tmp);
2622 piValues[i] = WGL_NO_ACCELERATION_ARB;
2623 }
2624 continue;
2625
2626 case WGL_TRANSPARENT_ARB:
2627 curGLXAttr = GLX_TRANSPARENT_TYPE;
2628 if (!fmt) goto pix_error;
2629 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2630 if (hTest) goto get_error;
2631 piValues[i] = GL_FALSE;
2632 if (GLX_NONE != tmp) piValues[i] = GL_TRUE;
2633 continue;
2634
2635 case WGL_PIXEL_TYPE_ARB:
2636 curGLXAttr = GLX_RENDER_TYPE;
2637 if (!fmt) goto pix_error;
2638 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2639 if (hTest) goto get_error;
2640 TRACE("WGL_PIXEL_TYPE_ARB: GLX_RENDER_TYPE = 0x%x\n", tmp);
2641 if (tmp & GLX_RGBA_BIT) { piValues[i] = WGL_TYPE_RGBA_ARB; }
2642 else if (tmp & GLX_COLOR_INDEX_BIT) { piValues[i] = WGL_TYPE_COLORINDEX_ARB; }
2643 else if (tmp & GLX_RGBA_FLOAT_BIT) { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
2644 else if (tmp & GLX_RGBA_FLOAT_ATI_BIT) { piValues[i] = WGL_TYPE_RGBA_FLOAT_ATI; }
2645 else {
2646 ERR("unexpected RenderType(%x)\n", tmp);
2647 piValues[i] = WGL_TYPE_RGBA_ARB;
2648 }
2649 continue;
2650
2651 case WGL_COLOR_BITS_ARB:
2652 curGLXAttr = GLX_BUFFER_SIZE;
2653 break;
2654
2655 case WGL_BIND_TO_TEXTURE_RGB_ARB:
2656 if (use_render_texture_ati) {
2657 curGLXAttr = GLX_BIND_TO_TEXTURE_RGB_ATI;
2658 break;
2659 }
2660 case WGL_BIND_TO_TEXTURE_RGBA_ARB:
2661 if (use_render_texture_ati) {
2662 curGLXAttr = GLX_BIND_TO_TEXTURE_RGBA_ATI;
2663 break;
2664 }
2665 if (!use_render_texture_emulation) {
2666 piValues[i] = GL_FALSE;
2667 continue;
2668 }
2669 curGLXAttr = GLX_RENDER_TYPE;
2670 if (!fmt) goto pix_error;
2671 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, &tmp);
2672 if (hTest) goto get_error;
2673 if (GLX_COLOR_INDEX_BIT == tmp) {
2674 piValues[i] = GL_FALSE;
2675 continue;
2676 }
2677 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
2678 if (hTest) goto get_error;
2679 piValues[i] = (tmp & GLX_PBUFFER_BIT) ? GL_TRUE : GL_FALSE;
2680 continue;
2681
2682 case WGL_BLUE_BITS_ARB:
2683 curGLXAttr = GLX_BLUE_SIZE;
2684 break;
2685 case WGL_RED_BITS_ARB:
2686 curGLXAttr = GLX_RED_SIZE;
2687 break;
2688 case WGL_GREEN_BITS_ARB:
2689 curGLXAttr = GLX_GREEN_SIZE;
2690 break;
2691 case WGL_ALPHA_BITS_ARB:
2692 curGLXAttr = GLX_ALPHA_SIZE;
2693 break;
2694 case WGL_DEPTH_BITS_ARB:
2695 curGLXAttr = GLX_DEPTH_SIZE;
2696 break;
2697 case WGL_STENCIL_BITS_ARB:
2698 curGLXAttr = GLX_STENCIL_SIZE;
2699 break;
2700 case WGL_DOUBLE_BUFFER_ARB:
2701 curGLXAttr = GLX_DOUBLEBUFFER;
2702 break;
2703 case WGL_STEREO_ARB:
2704 curGLXAttr = GLX_STEREO;
2705 break;
2706 case WGL_AUX_BUFFERS_ARB:
2707 curGLXAttr = GLX_AUX_BUFFERS;
2708 break;
2709
2710 case WGL_SUPPORT_GDI_ARB:
2711 if (!fmt) goto pix_error;
2712 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DOUBLEBUFFER, &tmp);
2713 if (hTest) goto get_error;
2714 if(tmp) {
2715 piValues[i] = GL_FALSE;
2716 continue;
2717 }
2718 curGLXAttr = GLX_X_RENDERABLE;
2719 break;
2720
2721 case WGL_DRAW_TO_WINDOW_ARB:
2722 case WGL_DRAW_TO_BITMAP_ARB:
2723 case WGL_DRAW_TO_PBUFFER_ARB:
2724 if (!fmt) goto pix_error;
2725 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_DRAWABLE_TYPE, &tmp);
2726 if (hTest) goto get_error;
2727 if((curWGLAttr == WGL_DRAW_TO_WINDOW_ARB && (tmp&GLX_WINDOW_BIT)) ||
2728 (curWGLAttr == WGL_DRAW_TO_BITMAP_ARB && (tmp&GLX_PIXMAP_BIT)) ||
2729 (curWGLAttr == WGL_DRAW_TO_PBUFFER_ARB && (tmp&GLX_PBUFFER_BIT)))
2730 piValues[i] = GL_TRUE;
2731 else
2732 piValues[i] = GL_FALSE;
2733 continue;
2734
2735 case WGL_PBUFFER_LARGEST_ARB:
2736 curGLXAttr = GLX_LARGEST_PBUFFER;
2737 break;
2738
2739 case WGL_SAMPLE_BUFFERS_ARB:
2740 curGLXAttr = GLX_SAMPLE_BUFFERS_ARB;
2741 break;
2742
2743 case WGL_SAMPLES_ARB:
2744 curGLXAttr = GLX_SAMPLES_ARB;
2745 break;
2746
2747 case WGL_FLOAT_COMPONENTS_NV:
2748 curGLXAttr = GLX_FLOAT_COMPONENTS_NV;
2749 break;
2750
2751 case WGL_ACCUM_RED_BITS_ARB:
2752 curGLXAttr = GLX_ACCUM_RED_SIZE;
2753 break;
2754 case WGL_ACCUM_GREEN_BITS_ARB:
2755 curGLXAttr = GLX_ACCUM_GREEN_SIZE;
2756 break;
2757 case WGL_ACCUM_BLUE_BITS_ARB:
2758 curGLXAttr = GLX_ACCUM_BLUE_SIZE;
2759 break;
2760 case WGL_ACCUM_ALPHA_BITS_ARB:
2761 curGLXAttr = GLX_ACCUM_ALPHA_SIZE;
2762 break;
2763 case WGL_ACCUM_BITS_ARB:
2764 if (!fmt) goto pix_error;
2765 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_RED_SIZE, &tmp);
2766 if (hTest) goto get_error;
2767 piValues[i] = tmp;
2768 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_GREEN_SIZE, &tmp);
2769 if (hTest) goto get_error;
2770 piValues[i] += tmp;
2771 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_BLUE_SIZE, &tmp);
2772 if (hTest) goto get_error;
2773 piValues[i] += tmp;
2774 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, GLX_ACCUM_ALPHA_SIZE, &tmp);
2775 if (hTest) goto get_error;
2776 piValues[i] += tmp;
2777 continue;
2778
2779 default:
2780 FIXME("unsupported %x WGL Attribute\n", curWGLAttr);
2781 }
2782
2783 /* Retrieve a GLX FBConfigAttrib when the attribute to query is valid and
2784 * iPixelFormat != 0. When iPixelFormat is 0 the only value which makes
2785 * sense to query is WGL_NUMBER_PIXEL_FORMATS_ARB.
2786 *
2787 * TODO: properly test the behavior of wglGetPixelFormatAttrib*v on Windows
2788 * and check which options can work using iPixelFormat=0 and which not.
2789 * A problem would be that this function is an extension. This would
2790 * mean that the behavior could differ between different vendors (ATI, Nvidia, ..).
2791 */
2792 if (0 != curGLXAttr && iPixelFormat != 0) {
2793 if (!fmt) goto pix_error;
2794 hTest = pglXGetFBConfigAttrib(gdi_display, fmt->fbconfig, curGLXAttr, piValues + i);
2795 if (hTest) goto get_error;
2796 curGLXAttr = 0;
2797 } else {
2798 piValues[i] = GL_FALSE;
2799 }
2800 }
2801 return GL_TRUE;
2802
2803 get_error:
2804 ERR("(%p): unexpected failure on GetFBConfigAttrib(%x) returns FALSE\n", hdc, curGLXAttr);
2805 return GL_FALSE;
2806
2807 pix_error:
2808 ERR("(%p): unexpected iPixelFormat(%d) vs nFormats(%d), returns FALSE\n", hdc, iPixelFormat, nWGLFormats);
2809 return GL_FALSE;
2810 }
2811
2812 /**
2813 * X11DRV_wglGetPixelFormatAttribfvARB
2814 *
2815 * WGL_ARB_pixel_format: wglGetPixelFormatAttribfvARB
2816 */
2817 static GLboolean WINAPI X11DRV_wglGetPixelFormatAttribfvARB(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, const int *piAttributes, FLOAT *pfValues)
2818 {
2819 int *attr;
2820 int ret;
2821 int i;
2822
2823 TRACE("(%p, %d, %d, %d, %p, %p)\n", hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, pfValues);
2824
2825 /* Allocate a temporary array to store integer values */
2826 attr = HeapAlloc(GetProcessHeap(), 0, nAttributes * sizeof(int));
2827 if (!attr) {
2828 ERR("couldn't allocate %d array\n", nAttributes);
2829 return GL_FALSE;
2830 }
2831
2832 /* Piggy-back on wglGetPixelFormatAttribivARB */
2833 ret = X11DRV_wglGetPixelFormatAttribivARB(hdc, iPixelFormat, iLayerPlane, nAttributes, piAttributes, attr);
2834 if (ret) {
2835 /* Convert integer values to float. Should also check for attributes
2836 that can give decimal values here */
2837 for (i=0; i<nAttributes;i++) {
2838 pfValues[i] = attr[i];
2839 }
2840 }
2841
2842 HeapFree(GetProcessHeap(), 0, attr);
2843 return ret;
2844 }
2845
2846 /**
2847 * X11DRV_wglBindTexImageARB
2848 *
2849 * WGL_ARB_render_texture: wglBindTexImageARB
2850 */
2851 static GLboolean WINAPI X11DRV_wglBindTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
2852 {
2853 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2854 TRACE("(%p, %d)\n", hPbuffer, iBuffer);
2855 if (NULL == object) {
2856 SetLastError(ERROR_INVALID_HANDLE);
2857 return GL_FALSE;
2858 }
2859 if (!object->use_render_texture) {
2860 SetLastError(ERROR_INVALID_HANDLE);
2861 return GL_FALSE;
2862 }
2863
2864 if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2865 static int init = 0;
2866 int prev_binded_texture = 0;
2867 GLXContext prev_context = pglXGetCurrentContext();
2868 Drawable prev_drawable = pglXGetCurrentDrawable();
2869 GLXContext tmp_context;
2870
2871 /* Our render_texture emulation is basic and lacks some features (1D/Cube support).
2872 This is mostly due to lack of demos/games using them. Further the use of glReadPixels
2873 isn't ideal performance wise but I wasn't able to get other ways working.
2874 */
2875 if(!init) {
2876 init = 1; /* Only show the FIXME once for performance reasons */
2877 FIXME("partial stub!\n");
2878 }
2879
2880 TRACE("drawable=%p, context=%p\n", (void*)object->drawable, prev_context);
2881 tmp_context = pglXCreateNewContext(gdi_display, object->fmt->fbconfig, object->fmt->render_type, prev_context, True);
2882
2883 pglGetIntegerv(object->texture_bind_target, &prev_binded_texture);
2884
2885 /* Switch to our pbuffer */
2886 pglXMakeCurrent(gdi_display, object->drawable, tmp_context);
2887
2888 /* Make sure that the prev_binded_texture is set as the current texture state isn't shared between contexts.
2889 * After that upload the pbuffer texture data. */
2890 pglBindTexture(object->texture_target, prev_binded_texture);
2891 pglCopyTexImage2D(object->texture_target, 0, object->use_render_texture, 0, 0, object->width, object->height, 0);
2892
2893 /* Switch back to the original drawable and upload the pbuffer-texture */
2894 pglXMakeCurrent(object->display, prev_drawable, prev_context);
2895 pglXDestroyContext(gdi_display, tmp_context);
2896 return GL_TRUE;
2897 }
2898
2899 if (NULL != pglXBindTexImageATI) {
2900 int buffer;
2901
2902 switch(iBuffer)
2903 {
2904 case WGL_FRONT_LEFT_ARB:
2905 buffer = GLX_FRONT_LEFT_ATI;
2906 break;
2907 case WGL_FRONT_RIGHT_ARB:
2908 buffer = GLX_FRONT_RIGHT_ATI;
2909 break;
2910 case WGL_BACK_LEFT_ARB:
2911 buffer = GLX_BACK_LEFT_ATI;
2912 break;
2913 case WGL_BACK_RIGHT_ARB:
2914 buffer = GLX_BACK_RIGHT_ATI;
2915 break;
2916 default:
2917 ERR("Unknown iBuffer=%#x\n", iBuffer);
2918 return FALSE;
2919 }
2920
2921 /* In the sample 'ogl_offscreen_rendering_3' from codesampler.net I get garbage on the screen.
2922 * I'm not sure if that's a bug in the ATI extension or in the program. I think that the program
2923 * expected a single buffering format since it didn't ask for double buffering. A buffer swap
2924 * fixed the program. I don't know what the correct behavior is. On the other hand that demo
2925 * works fine using our pbuffer emulation path.
2926 */
2927 return pglXBindTexImageATI(object->display, object->drawable, buffer);
2928 }
2929 return GL_FALSE;
2930 }
2931
2932 /**
2933 * X11DRV_wglReleaseTexImageARB
2934 *
2935 * WGL_ARB_render_texture: wglReleaseTexImageARB
2936 */
2937 static GLboolean WINAPI X11DRV_wglReleaseTexImageARB(HPBUFFERARB hPbuffer, int iBuffer)
2938 {
2939 Wine_GLPBuffer* object = (Wine_GLPBuffer*) hPbuffer;
2940 TRACE("(%p, %d)\n", hPbuffer, iBuffer);
2941 if (NULL == object) {
2942 SetLastError(ERROR_INVALID_HANDLE);
2943 return GL_FALSE;
2944 }
2945 if (!object->use_render_texture) {
2946 SetLastError(ERROR_INVALID_HANDLE);
2947 return GL_FALSE;
2948 }
2949 if (!use_render_texture_ati && 1 == use_render_texture_emulation) {
2950 return GL_TRUE;
2951 }
2952 if (NULL != pglXReleaseTexImageATI) {
2953 int buffer;
2954
2955 switch(iBuffer)
2956 {
2957 case WGL_FRONT_LEFT_ARB:
2958 buffer = GLX_FRONT_LEFT_ATI;
2959 break;
2960 case WGL_FRONT_RIGHT_ARB:
2961 buffer = GLX_FRONT_RIGHT_ATI;
2962 break;
2963 case WGL_BACK_LEFT_ARB:
2964 buffer = GLX_BACK_LEFT_ATI;
2965 break;
2966 case WGL_BACK_RIGHT_ARB:
2967 buffer = GLX_BACK_RIGHT_ATI;
2968 break;
2969 default:
2970 ERR("Unknown iBuffer=%#x\n", iBuffer);
2971 return FALSE;
2972 }
2973 return pglXReleaseTexImageATI(object->display, object->drawable, buffer);
2974 }
2975 return GL_FALSE;
2976 }
2977
2978 /**
2979 * X11DRV_wglGetExtensionsStringEXT
2980 *
2981 * WGL_EXT_extensions_string: wglGetExtensionsStringEXT
2982 */
2983 static const char * WINAPI X11DRV_wglGetExtensionsStringEXT(void) {
2984 TRACE("() returning \"%s\"\n", WineGLInfo.wglExtensions);
2985 return WineGLInfo.wglExtensions;
2986 }
2987
2988 /**
2989 * X11DRV_wglGetSwapIntervalEXT
2990 *
2991 * WGL_EXT_swap_control: wglGetSwapIntervalEXT
2992 */
2993 static int WINAPI X11DRV_wglGetSwapIntervalEXT(VOID) {
2994 FIXME("(),stub!\n");
2995 return swap_interval;
2996 }
2997
2998 /**
2999 * X11DRV_wglSwapIntervalEXT
3000 *
3001 * WGL_EXT_swap_control: wglSwapIntervalEXT
3002 */
3003 static BOOL WINAPI X11DRV_wglSwapIntervalEXT(int interval) {
3004 TRACE("(%d)\n", interval);
3005 swap_interval = interval;
3006 if (NULL != pglXSwapIntervalSGI) {
3007 return 0 == pglXSwapIntervalSGI(interval);
3008 }
3009 WARN("(): GLX_SGI_swap_control extension seems not supported\n");
3010 return TRUE;
3011 }
3012
3013 /**
3014 * X11DRV_wglAllocateMemoryNV
3015 *
3016 * WGL_NV_vertex_array_range: wglAllocateMemoryNV
3017 */
3018 static void* WINAPI X11DRV_wglAllocateMemoryNV(GLsizei size, GLfloat readfreq, GLfloat writefreq, GLfloat priority) {
3019 TRACE("(%d, %f, %f, %f)\n", size, readfreq, writefreq, priority );
3020 if (pglXAllocateMemoryNV == NULL)
3021 return NULL;
3022
3023 return pglXAllocateMemoryNV(size, readfreq, writefreq, priority);
3024 }
3025
3026 /**
3027 * X11DRV_wglFreeMemoryNV
3028 *
3029 * WGL_NV_vertex_array_range: wglFreeMemoryNV
3030 */
3031 static void WINAPI X11DRV_wglFreeMemoryNV(GLvoid* pointer) {
3032 TRACE("(%p)\n", pointer);
3033 if (pglXFreeMemoryNV == NULL)
3034 return;
3035
3036 pglXFreeMemoryNV(pointer);
3037 }
3038
3039 /**
3040 * glxRequireVersion (internal)
3041 *
3042 * Check if the supported GLX version matches requiredVersion.
3043 */
3044 static BOOL glxRequireVersion(int requiredVersion)
3045 {
3046 /* Both requiredVersion and glXVersion[1] contains the minor GLX version */
3047 if(requiredVersion <= WineGLInfo.glxVersion[1])
3048 return TRUE;
3049
3050 return FALSE;
3051 }
3052
3053 static BOOL glxRequireExtension(const char *requiredExtension)
3054 {
3055 if (strstr(WineGLInfo.glxExtensions, requiredExtension) == NULL) {
3056 return FALSE;
3057 }
3058
3059 return TRUE;
3060 }
3061
3062 static void register_extension_string(const char *ext)
3063 {
3064 if (WineGLInfo.wglExtensions[0])
3065 strcat(WineGLInfo.wglExtensions, " ");
3066 strcat(WineGLInfo.wglExtensions, ext);
3067
3068 TRACE("'%s'\n", ext);
3069 }
3070
3071 static BOOL register_extension(const WineGLExtension * ext)
3072 {
3073 int i;
3074
3075 assert( WineGLExtensionListSize < MAX_EXTENSIONS );
3076 WineGLExtensionList[WineGLExtensionListSize++] = ext;
3077
3078 register_extension_string(ext->extName);
3079
3080 for (i = 0; ext->extEntryPoints[i].funcName; ++i)
3081 TRACE(" - '%s'\n", ext->extEntryPoints[i].funcName);
3082
3083 return TRUE;
3084 }
3085
3086 static const WineGLExtension WGL_internal_functions =
3087 {
3088 "",
3089 {
3090 { "wglDisable", X11DRV_wglDisable },
3091 { "wglEnable", X11DRV_wglEnable },
3092 { "wglGetIntegerv", X11DRV_wglGetIntegerv },
3093 { "wglIsEnabled", X11DRV_wglIsEnabled },
3094 { "wglScissor", X11DRV_wglScissor },
3095 { "wglViewport", X11DRV_wglViewport },
3096 }
3097 };
3098
3099
3100 static const WineGLExtension WGL_ARB_extensions_string =
3101 {
3102 "WGL_ARB_extensions_string",
3103 {
3104 { "wglGetExtensionsStringARB", X11DRV_wglGetExtensionsStringARB },
3105 }
3106 };
3107
3108 static const WineGLExtension WGL_ARB_make_current_read =
3109 {
3110 "WGL_ARB_make_current_read",
3111 {
3112 { "wglGetCurrentReadDCARB", X11DRV_wglGetCurrentReadDCARB },
3113 { "wglMakeContextCurrentARB", X11DRV_wglMakeContextCurrentARB },
3114 }
3115 };
3116
3117 static const WineGLExtension WGL_ARB_multisample =
3118 {
3119 "WGL_ARB_multisample",
3120 };
3121
3122 static const WineGLExtension WGL_ARB_pbuffer =
3123 {
3124 "WGL_ARB_pbuffer",
3125 {
3126 { "wglCreatePbufferARB", X11DRV_wglCreatePbufferARB },
3127 { "wglDestroyPbufferARB", X11DRV_wglDestroyPbufferARB },
3128 { "wglGetPbufferDCARB", X11DRV_wglGetPbufferDCARB },
3129 { "wglQueryPbufferARB", X11DRV_wglQueryPbufferARB },
3130 { "wglReleasePbufferDCARB", X11DRV_wglReleasePbufferDCARB },
3131 { "wglSetPbufferAttribARB", X11DRV_wglSetPbufferAttribARB },
3132 }
3133 };
3134
3135 static const WineGLExtension WGL_ARB_pixel_format =
3136 {
3137 "WGL_ARB_pixel_format",
3138 {
3139 { "wglChoosePixelFormatARB", X11DRV_wglChoosePixelFormatARB },
3140 { "wglGetPixelFormatAttribfvARB", X11DRV_wglGetPixelFormatAttribfvARB },
3141 { "wglGetPixelFormatAttribivARB", X11DRV_wglGetPixelFormatAttribivARB },
3142 }
3143 };
3144
3145 static const WineGLExtension WGL_ARB_render_texture =
3146 {
3147 "WGL_ARB_render_texture",
3148 {
3149 { "wglBindTexImageARB", X11DRV_wglBindTexImageARB },
3150 { "wglReleaseTexImageARB", X11DRV_wglReleaseTexImageARB },
3151 }
3152 };
3153
3154 static const WineGLExtension WGL_EXT_extensions_string =
3155 {
3156 "WGL_EXT_extensions_string",
3157 {
3158 { "wglGetExtensionsStringEXT", X11DRV_wglGetExtensionsStringEXT },
3159 }
3160 };
3161
3162 static const WineGLExtension WGL_EXT_swap_control =
3163 {
3164 "WGL_EXT_swap_control",
3165 {
3166 { "wglSwapIntervalEXT", X11DRV_wglSwapIntervalEXT },
3167 { "wglGetSwapIntervalEXT", X11DRV_wglGetSwapIntervalEXT },
3168 }
3169 };
3170
3171 static const WineGLExtension WGL_NV_vertex_array_range =
3172 {
3173 "WGL_NV_vertex_array_range",
3174 {
3175 { "wglAllocateMemoryNV", X11DRV_wglAllocateMemoryNV },
3176 { "wglFreeMemoryNV", X11DRV_wglFreeMemoryNV },
3177 }
3178 };
3179
3180 /**
3181 * X11DRV_WineGL_LoadExtensions
3182 */
3183 static void X11DRV_WineGL_LoadExtensions(void)
3184 {
3185 WineGLInfo.wglExtensions[0] = 0;
3186
3187 /* Load Wine internal functions */
3188 register_extension(&WGL_internal_functions);
3189
3190 /* ARB Extensions */
3191
3192 if(glxRequireExtension("GLX_ARB_fbconfig_float"))
3193 {
3194 register_extension_string("WGL_ARB_pixel_format_float");
3195 register_extension_string("WGL_ATI_pixel_format_float");
3196 }
3197
3198 register_extension(&WGL_ARB_extensions_string);
3199
3200 if (glxRequireVersion(3))
3201 register_extension(&WGL_ARB_make_current_read);
3202
3203 if (glxRequireExtension("GLX_ARB_multisample"))
3204 register_extension(&WGL_ARB_multisample);
3205
3206 /* In general pbuffer functionality requires support in the X-server. The functionality is
3207 * available either when the GLX_SGIX_pbuffer is present or when the GLX server version is 1.3.
3208 * All display drivers except for Nvidia's use the GLX module from Xfree86/Xorg which only
3209 * supports GLX 1.2. The endresult is that only Nvidia's drivers support pbuffers.
3210 *
3211 * The only other drive which has pbuffer support is Ati's FGLRX driver. They provide clientside GLX 1.3 support
3212 * without support in the X-server (which other Mesa based drivers require).
3213 *
3214 * Support pbuffers when the GLX version is 1.3 and GLX_SGIX_pbuffer is available. Further pbuffers can
3215 * also be supported when GLX_ATI_render_texture is available. This extension depends on pbuffers, so when it
3216 * is available pbuffers must be available too. */
3217 if ( (glxRequireVersion(3) && glxRequireExtension("GLX_SGIX_pbuffer")) || glxRequireExtension("GLX_ATI_render_texture"))
3218 register_extension(&WGL_ARB_pbuffer);
3219
3220 register_extension(&WGL_ARB_pixel_format);
3221
3222 /* Support WGL_ARB_render_texture when there's support or pbuffer based emulation */
3223 if (glxRequireExtension("GLX_ATI_render_texture") ||
3224 glxRequireExtension("GLX_ARB_render_texture") ||
3225 (glxRequireVersion(3) && glxRequireExtension("GLX_SGIX_pbuffer") && use_render_texture_emulation))
3226 {
3227 register_extension(&WGL_ARB_render_texture);
3228
3229 /* The WGL version of GLX_NV_float_buffer requires render_texture */
3230 if(glxRequireExtension("GLX_NV_float_buffer"))
3231 register_extension_string("WGL_NV_float_buffer");
3232
3233 /* Again there's no GLX equivalent for this extension, so depend on the required GL extension */
3234 if(strstr(WineGLInfo.glExtensions, "GL_NV_texture_rectangle") != NULL)
3235 register_extension_string("WGL_NV_texture_rectangle");
3236 }
3237
3238 /* EXT Extensions */
3239
3240 register_extension(&WGL_EXT_extensions_string);
3241
3242 /* Load this extension even when it isn't backed by a GLX extension because it is has been around for ages.
3243 * Games like Call of Duty and K.O.T.O.R. rely on it. Further our emulation is good enough. */
3244 register_extension(&WGL_EXT_swap_control);
3245
3246 /* The OpenGL extension GL_NV_vertex_array_range adds wgl/glX functions which aren't exported as 'real' wgl/glX extensions. */
3247 if(strstr(WineGLInfo.glExtensions, "GL_NV_vertex_array_range") != NULL)
3248 register_extension(&WGL_NV_vertex_array_range);
3249 }
3250
3251
3252 static XID create_glxpixmap(X11DRV_PDEVICE *physDev)
3253 {
3254 GLXPixmap ret;
3255 XVisualInfo *vis;
3256 XVisualInfo template;
3257 int num;
3258
3259 wine_tsx11_lock();
3260
3261 /* Retrieve the visualid from our main visual which is the only visual we can use */
3262 template.visualid = XVisualIDFromVisual(visual);
3263 vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
3264
3265 ret = pglXCreateGLXPixmap(gdi_display, vis, physDev->bitmap->pixmap);
3266 XFree(vis);
3267 wine_tsx11_unlock();
3268 TRACE("return %lx\n", ret);
3269 return ret;
3270 }
3271
3272 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
3273 {
3274 Drawable ret;
3275
3276 if(physDev->bitmap)
3277 {
3278 if (physDev->bitmap->hbitmap == BITMAP_stock_phys_bitmap.hbitmap)
3279 ret = physDev->drawable; /* PBuffer */
3280 else
3281 {
3282 if(!physDev->bitmap->glxpixmap)
3283 physDev->bitmap->glxpixmap = create_glxpixmap(physDev);
3284 ret = physDev->bitmap->glxpixmap;
3285 }
3286 }
3287 else
3288 ret = physDev->drawable;
3289 return ret;
3290 }
3291
3292 BOOL destroy_glxpixmap(XID glxpixmap)
3293 {
3294 wine_tsx11_lock();
3295 pglXDestroyGLXPixmap(gdi_display, glxpixmap);
3296 wine_tsx11_unlock();
3297 return TRUE;
3298 }
3299
3300 /**
3301 * X11DRV_SwapBuffers
3302 *
3303 * Swap the buffers of this DC
3304 */
3305 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev)
3306 {
3307 GLXDrawable drawable;
3308 if (!has_opengl()) {
3309 ERR("No libGL on this box - disabling OpenGL support !\n");
3310 return 0;
3311 }
3312
3313 TRACE_(opengl)("(%p)\n", physDev);
3314
3315 drawable = get_glxdrawable(physDev);
3316 wine_tsx11_lock();
3317 pglXSwapBuffers(gdi_display, drawable);
3318 wine_tsx11_unlock();
3319
3320 /* FPS support */
3321 if (TRACE_ON(fps))
3322 {
3323 static long prev_time, frames;
3324
3325 DWORD time = GetTickCount();
3326 frames++;
3327 /* every 1.5 seconds */
3328 if (time - prev_time > 1500) {
3329 TRACE_(fps)("@ approx %.2ffps\n", 1000.0*frames/(time - prev_time));
3330 prev_time = time;
3331 frames = 0;
3332 }
3333 }
3334
3335 return TRUE;
3336 }
3337
3338 /***********************************************************************
3339 * X11DRV_setup_opengl_visual
3340 *
3341 * Setup the default visual used for OpenGL and Direct3D, and the desktop
3342 * window (if it exists). If OpenGL isn't available, the visual is simply
3343 * set to the default visual for the display
3344 */
3345 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
3346 {
3347 XVisualInfo *visual = NULL;
3348 int i;
3349
3350 /* In order to support OpenGL or D3D, we require a double-buffered visual and stencil buffer support,
3351 * D3D and some applications can make use of aux buffers.
3352 */
3353 int visualProperties[][11] = {
3354 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8, GLX_ALPHA_SIZE, 8, GLX_AUX_BUFFERS, 1, None },
3355 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 24, GLX_STENCIL_SIZE, 8, GLX_ALPHA_SIZE, 8, None },
3356 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16, GLX_STENCIL_SIZE, 8, None },
3357 { GLX_RGBA, GLX_DOUBLEBUFFER, GLX_DEPTH_SIZE, 16, None },
3358 };
3359
3360 if (!has_opengl())
3361 return NULL;
3362
3363 wine_tsx11_lock();
3364 for (i = 0; i < sizeof(visualProperties)/sizeof(visualProperties[0]); ++i) {
3365 visual = pglXChooseVisual(display, DefaultScreen(display), visualProperties[i]);
3366 if (visual)
3367 break;
3368 }
3369 wine_tsx11_unlock();
3370
3371 if (visual)
3372 TRACE("Visual ID %lx Chosen\n", visual->visualid);
3373 else
3374 WARN("No suitable visual found\n");
3375
3376 return visual;
3377 }
3378
3379 #else /* no OpenGL includes */
3380
3381 int pixelformat_from_fbconfig_id(XID fbconfig_id)
3382 {
3383 return 0;
3384 }
3385
3386 /***********************************************************************
3387 * ChoosePixelFormat (X11DRV.@)
3388 */
3389 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
3390 const PIXELFORMATDESCRIPTOR *ppfd) {
3391 ERR("No OpenGL support compiled in.\n");
3392
3393 return 0;
3394 }
3395
3396 /***********************************************************************
3397 * DescribePixelFormat (X11DRV.@)
3398 */
3399 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
3400 int iPixelFormat,
3401 UINT nBytes,
3402 PIXELFORMATDESCRIPTOR *ppfd) {
3403 ERR("No OpenGL support compiled in.\n");
3404
3405 return 0;
3406 }
3407
3408 /***********************************************************************
3409 * GetPixelFormat (X11DRV.@)
3410 */
3411 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
3412 ERR("No OpenGL support compiled in.\n");
3413
3414 return 0;
3415 }
3416
3417 /***********************************************************************
3418 * SetPixelFormat (X11DRV.@)
3419 */
3420 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
3421 int iPixelFormat,
3422 const PIXELFORMATDESCRIPTOR *ppfd) {
3423 ERR("No OpenGL support compiled in.\n");
3424
3425 return FALSE;
3426 }
3427
3428 /***********************************************************************
3429 * SwapBuffers (X11DRV.@)
3430 */
3431 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
3432 ERR_(opengl)("No OpenGL support compiled in.\n");
3433
3434 return FALSE;
3435 }
3436
3437 /**
3438 * X11DRV_wglCreateContext
3439 *
3440 * For OpenGL32 wglCreateContext.
3441 */
3442 HGLRC X11DRV_wglCreateContext(X11DRV_PDEVICE *physDev) {
3443 ERR_(opengl)("No OpenGL support compiled in.\n");
3444 return NULL;
3445 }
3446
3447 /**
3448 * X11DRV_wglDeleteContext
3449 *
3450 * For OpenGL32 wglDeleteContext.
3451 */
3452 BOOL X11DRV_wglDeleteContext(HGLRC hglrc) {
3453 ERR_(opengl)("No OpenGL support compiled in.\n");
3454 return FALSE;
3455 }
3456
3457 /**
3458 * X11DRV_wglGetProcAddress
3459 *
3460 * For OpenGL32 wglGetProcAddress.
3461 */
3462 PROC X11DRV_wglGetProcAddress(LPCSTR lpszProc) {
3463 ERR_(opengl)("No OpenGL support compiled in.\n");
3464 return NULL;
3465 }
3466
3467 HDC X11DRV_wglGetPbufferDCARB(X11DRV_PDEVICE *hDevice, void *hPbuffer)
3468 {
3469 ERR_(opengl)("No OpenGL support compiled in.\n");
3470 return NULL;
3471 }
3472
3473 BOOL X11DRV_wglMakeContextCurrentARB(X11DRV_PDEVICE* hDrawDev, X11DRV_PDEVICE* hReadDev, HGLRC hglrc) {
3474 ERR_(opengl)("No OpenGL support compiled in.\n");
3475 return FALSE;
3476 }
3477
3478 /**
3479 * X11DRV_wglMakeCurrent
3480 *
3481 * For OpenGL32 wglMakeCurrent.
3482 */
3483 BOOL X11DRV_wglMakeCurrent(X11DRV_PDEVICE *physDev, HGLRC hglrc) {
3484 ERR_(opengl)("No OpenGL support compiled in.\n");
3485 return FALSE;
3486 }
3487
3488 /**
3489 * X11DRV_wglShareLists
3490 *
3491 * For OpenGL32 wglShaderLists.
3492 */
3493 BOOL X11DRV_wglShareLists(HGLRC hglrc1, HGLRC hglrc2) {
3494 ERR_(opengl)("No OpenGL support compiled in.\n");
3495 return FALSE;
3496 }
3497
3498 /**
3499 * X11DRV_wglUseFontBitmapsA
3500 *
3501 * For OpenGL32 wglUseFontBitmapsA.
3502 */
3503 BOOL X11DRV_wglUseFontBitmapsA(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
3504 {
3505 ERR_(opengl)("No OpenGL support compiled in.\n");
3506 return FALSE;
3507 }
3508
3509 /**
3510 * X11DRV_wglUseFontBitmapsW
3511 *
3512 * For OpenGL32 wglUseFontBitmapsW.
3513 */
3514 BOOL X11DRV_wglUseFontBitmapsW(X11DRV_PDEVICE *physDev, DWORD first, DWORD count, DWORD listBase)
3515 {
3516 ERR_(opengl)("No OpenGL support compiled in.\n");
3517 return FALSE;
3518 }
3519
3520 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
3521 {
3522 return NULL;
3523 }
3524
3525 Drawable get_glxdrawable(X11DRV_PDEVICE *physDev)
3526 {
3527 return 0;
3528 }
3529
3530 BOOL destroy_glxpixmap(XID glxpixmap)
3531 {
3532 return FALSE;
3533 }
3534
3535 #endif /* defined(HAVE_OPENGL) */
Windows API implementation