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