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