Moved most remaining file functions to dlls/kernel.
[wine] / dlls / x11drv / opengl.c
1 /*
2  * X11DRV OpenGL functions
3  *
4  * Copyright 2000 Lionel Ulmer
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "config.h"
22 #include "wine/port.h"
23
24 #include <stdlib.h>
25 #include <string.h>
26
27 #include "x11drv.h"
28 #include "wine/library.h"
29 #include "wine/debug.h"
30
31 WINE_DEFAULT_DEBUG_CHANNEL(opengl);
32
33 #if defined(HAVE_GL_GL_H) && defined(HAVE_GL_GLX_H)
34
35 #undef APIENTRY
36 #undef CALLBACK
37 #undef WINAPI
38
39 #define XMD_H /* This is to prevent the Xmd.h inclusion bug :-/ */
40 #ifdef HAVE_GL_GL_H
41 # include <GL/gl.h>
42 #endif
43 #ifdef HAVE_GL_GLX_H
44 # include <GL/glx.h>
45 #endif
46 #ifdef HAVE_GL_GLEXT_H
47 # include <GL/glext.h>
48 #endif
49 #undef  XMD_H
50
51 #undef APIENTRY
52 #undef CALLBACK
53 #undef WINAPI
54
55 /* Redefines the constants */
56 #define CALLBACK    __stdcall
57 #define WINAPI      __stdcall
58 #define APIENTRY    WINAPI
59
60
61 static void dump_PIXELFORMATDESCRIPTOR(PIXELFORMATDESCRIPTOR *ppfd) {
62   DPRINTF("  - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
63   DPRINTF("  - dwFlags : ");
64 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) DPRINTF(#tv " ")
65   TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
66   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
67   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
68   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
69   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
70   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
71   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
72   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
73   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
74   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
75   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
76   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
77   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
78   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
79   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
80   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
81 #undef TEST_AND_DUMP
82   DPRINTF("\n");
83
84   DPRINTF("  - iPixelType : ");
85   switch (ppfd->iPixelType) {
86   case PFD_TYPE_RGBA: DPRINTF("PFD_TYPE_RGBA"); break;
87   case PFD_TYPE_COLORINDEX: DPRINTF("PFD_TYPE_COLORINDEX"); break;
88   }
89   DPRINTF("\n");
90
91   DPRINTF("  - Color   : %d\n", ppfd->cColorBits);
92   DPRINTF("  - Alpha   : %d\n", ppfd->cAlphaBits);
93   DPRINTF("  - Accum   : %d\n", ppfd->cAccumBits);
94   DPRINTF("  - Depth   : %d\n", ppfd->cDepthBits);
95   DPRINTF("  - Stencil : %d\n", ppfd->cStencilBits);
96   DPRINTF("  - Aux     : %d\n", ppfd->cAuxBuffers);
97
98   DPRINTF("  - iLayerType : ");
99   switch (ppfd->iLayerType) {
100   case PFD_MAIN_PLANE: DPRINTF("PFD_MAIN_PLANE"); break;
101   case PFD_OVERLAY_PLANE: DPRINTF("PFD_OVERLAY_PLANE"); break;
102   case PFD_UNDERLAY_PLANE: DPRINTF("PFD_UNDERLAY_PLANE"); break;
103   }
104   DPRINTF("\n");
105 }
106
107 /* No need to load any other libraries as according to the ABI, libGL should be self-sufficient and
108    include all dependencies
109 */
110 #ifndef SONAME_LIBGL
111 #define SONAME_LIBGL "libGL.so"
112 #endif
113
114 static void *opengl_handle;
115
116 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
117 MAKE_FUNCPTR(glXChooseVisual)
118 MAKE_FUNCPTR(glXGetConfig)
119 MAKE_FUNCPTR(glXSwapBuffers)
120 MAKE_FUNCPTR(glXQueryExtension)
121 #undef MAKE_FUNCPTR
122
123 void X11DRV_OpenGL_Init(Display *display) {
124     int error_base, event_base;
125
126     opengl_handle = wine_dlopen(SONAME_LIBGL, RTLD_NOW|RTLD_GLOBAL, NULL, 0);
127     if (opengl_handle == NULL) return;
128
129 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(opengl_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
130 LOAD_FUNCPTR(glXChooseVisual)
131 LOAD_FUNCPTR(glXGetConfig)
132 LOAD_FUNCPTR(glXSwapBuffers)
133 LOAD_FUNCPTR(glXQueryExtension)
134 #undef LOAD_FUNCPTR
135
136     wine_tsx11_lock();
137     if (pglXQueryExtension(display, &event_base, &error_base) == True) {
138         TRACE("GLX is up and running error_base = %d\n", error_base);
139     } else {
140         wine_dlclose(opengl_handle, NULL, 0);
141         opengl_handle = NULL;
142     }
143     wine_tsx11_unlock();
144     return;
145
146 sym_not_found:
147     wine_dlclose(opengl_handle, NULL, 0);
148     opengl_handle = NULL;
149 }
150
151 /* X11DRV_ChoosePixelFormat
152
153      Equivalent of glXChooseVisual
154 */
155 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
156                              const PIXELFORMATDESCRIPTOR *ppfd) {
157 #define TEST_AND_ADD1(t,a) if (t) att_list[att_pos++] = a
158 #define TEST_AND_ADD2(t,a,b) if (t) { att_list[att_pos++] = a; att_list[att_pos++] = b; }
159 #define NULL_TEST_AND_ADD2(tv,a,b) att_list[att_pos++] = a; att_list[att_pos++] = ((tv) == 0 ? 0 : b)
160 #define ADD2(a,b) att_list[att_pos++] = a; att_list[att_pos++] = b
161
162   int att_list[64];
163   int att_pos = 0;
164   XVisualInfo *vis;
165   int i;
166
167   if (opengl_handle == NULL) {
168     ERR("No libGL on this box - disabling OpenGL support !\n");
169     return 0;
170   }
171   
172   if (TRACE_ON(opengl)) {
173     TRACE("(%p,%p)\n", physDev, ppfd);
174
175     dump_PIXELFORMATDESCRIPTOR((PIXELFORMATDESCRIPTOR *) ppfd);
176   }
177
178   if (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) {
179     ERR("Flag not supported !\n");
180     /* Should SetError here... */
181     return 0;
182   }
183
184   /* Now, build the request to GLX */
185   TEST_AND_ADD1(ppfd->dwFlags & PFD_DOUBLEBUFFER, GLX_DOUBLEBUFFER);
186   TEST_AND_ADD1(ppfd->dwFlags & PFD_STEREO, GLX_STEREO);
187   TEST_AND_ADD1(ppfd->iPixelType == PFD_TYPE_RGBA, GLX_RGBA);
188   TEST_AND_ADD2(ppfd->iPixelType == PFD_TYPE_COLORINDEX, GLX_BUFFER_SIZE, ppfd->cColorBits);
189
190   NULL_TEST_AND_ADD2(ppfd->cDepthBits, GLX_DEPTH_SIZE, 8);
191   /* These flags are not supported yet...
192
193      NULL_TEST_AND_ADD2(ppfd->cAlphaBits, GLX_ALPHA_SIZE, 8);
194      ADD2(GLX_ACCUM_SIZE, ppfd->cAccumBits); */
195   ADD2(GLX_STENCIL_SIZE, ppfd->cStencilBits); /* now supported */
196   /*   ADD2(GLX_AUX_BUFFERS, ppfd->cAuxBuffers); */
197   att_list[att_pos] = None;
198
199   wine_tsx11_lock(); {
200     /*
201        This command cannot be used as we need to use the default visual...
202        Let's hope it at least contains some OpenGL functionnalities
203
204        vis = glXChooseVisual(gdi_display, DefaultScreen(gdi_display), att_list);
205     */
206     int num;
207     XVisualInfo template;
208
209     template.visualid = XVisualIDFromVisual(visual);
210     vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
211
212     TRACE("Found visual : %p - returns %d\n", vis, physDev->used_visuals + 1);
213   }
214   wine_tsx11_unlock();
215
216   if (vis == NULL) {
217     ERR("No visual found !\n");
218     /* Should SetError here... */
219     return 0;
220   }
221   /* try to find the visualid in the already created visuals */
222   for( i=0; i<physDev->used_visuals; i++ ) {
223     if ( vis->visualid == physDev->visuals[i]->visualid ) {
224       XFree(vis);
225       return i+1;
226     }
227   }
228   /* now give up, if the maximum is reached */
229   if (physDev->used_visuals == MAX_PIXELFORMATS) {
230     ERR("Maximum number of visuals reached !\n");
231     /* Should SetError here... */
232     return 0;
233   }
234   physDev->visuals[physDev->used_visuals++] = vis;
235
236   return physDev->used_visuals;
237 }
238
239 /* X11DRV_DescribePixelFormat
240
241      Get the pixel-format descriptor associated to the given id
242 */
243 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
244                                int iPixelFormat,
245                                UINT nBytes,
246                                PIXELFORMATDESCRIPTOR *ppfd) {
247   XVisualInfo *vis;
248   int value;
249   int rb,gb,bb,ab;
250
251   if (opengl_handle == NULL) {
252     ERR("No libGL on this box - disabling OpenGL support !\n");
253     return 0;
254   }
255   
256   TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
257
258   if (ppfd == NULL) {
259     /* The application is only querying the number of visuals */
260     return MAX_PIXELFORMATS;
261   }
262
263   if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
264     ERR("Wrong structure size !\n");
265     /* Should set error */
266     return 0;
267   }
268   if ((iPixelFormat > MAX_PIXELFORMATS) ||
269       (iPixelFormat > physDev->used_visuals + 1) ||
270       (iPixelFormat <= 0)) {
271     ERR("Wrong pixel format !\n");
272     /* Should set error */
273     return 0;
274   }
275
276   if (iPixelFormat == physDev->used_visuals + 1) {
277     int dblBuf[]={GLX_RGBA,GLX_DEPTH_SIZE,16,GLX_DOUBLEBUFFER,None};
278
279     /* Create a 'standard' X Visual */
280     wine_tsx11_lock();
281     vis = pglXChooseVisual(gdi_display, DefaultScreen(gdi_display), dblBuf);
282     wine_tsx11_unlock();
283
284     WARN("Uninitialized Visual. Creating standard (%p) !\n", vis);
285
286     if (vis == NULL) {
287       ERR("Could not create standard visual !\n");
288       /* Should set error */
289       return 0;
290     }
291
292     physDev->visuals[physDev->used_visuals++] = vis;
293   }
294   vis = physDev->visuals[iPixelFormat - 1];
295
296   memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
297   ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
298   ppfd->nVersion = 1;
299
300   /* These flags are always the same... */
301   ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_GENERIC_ACCELERATED;
302   /* Now the flags extraced from the Visual */
303   wine_tsx11_lock();
304   pglXGetConfig(gdi_display, vis, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
305   pglXGetConfig(gdi_display, vis, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
306
307   /* Pixel type */
308   pglXGetConfig(gdi_display, vis, GLX_RGBA, &value);
309   if (value)
310     ppfd->iPixelType = PFD_TYPE_RGBA;
311   else
312     ppfd->iPixelType = PFD_TYPE_COLORINDEX;
313
314   /* Color bits */
315   pglXGetConfig(gdi_display, vis, GLX_BUFFER_SIZE, &value);
316   ppfd->cColorBits = value;
317
318   /* Red, green, blue and alpha bits / shifts */
319   if (ppfd->iPixelType == PFD_TYPE_RGBA) {
320     pglXGetConfig(gdi_display, vis, GLX_RED_SIZE, &rb);
321     pglXGetConfig(gdi_display, vis, GLX_GREEN_SIZE, &gb);
322     pglXGetConfig(gdi_display, vis, GLX_BLUE_SIZE, &bb);
323     pglXGetConfig(gdi_display, vis, GLX_ALPHA_SIZE, &ab);
324
325     ppfd->cRedBits = rb;
326     ppfd->cRedShift = gb + bb + ab;
327     ppfd->cBlueBits = bb;
328     ppfd->cBlueShift = ab;
329     ppfd->cGreenBits = gb;
330     ppfd->cGreenShift = bb + ab;
331     ppfd->cAlphaBits = ab;
332     ppfd->cAlphaShift = 0;
333   } else {
334     ppfd->cRedBits = 0;
335     ppfd->cRedShift = 0;
336     ppfd->cBlueBits = 0;
337     ppfd->cBlueShift = 0;
338     ppfd->cGreenBits = 0;
339     ppfd->cGreenShift = 0;
340     ppfd->cAlphaBits = 0;
341     ppfd->cAlphaShift = 0;
342   }
343   /* Accums : to do ... */
344
345   /* Depth bits */
346   pglXGetConfig(gdi_display, vis, GLX_DEPTH_SIZE, &value);
347   ppfd->cDepthBits = value;
348
349   /* stencil bits */
350   pglXGetConfig( gdi_display, vis, GLX_STENCIL_SIZE, &value );
351   ppfd->cStencilBits = value;
352
353   wine_tsx11_unlock();
354
355   /* Aux : to do ... */
356
357   ppfd->iLayerType = PFD_MAIN_PLANE;
358
359   if (TRACE_ON(opengl)) {
360     dump_PIXELFORMATDESCRIPTOR(ppfd);
361   }
362
363   return MAX_PIXELFORMATS;
364 }
365
366 /* X11DRV_GetPixelFormat
367
368      Get the pixel-format id used by this DC
369 */
370 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
371   TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
372
373   return physDev->current_pf;
374 }
375
376 /* X11DRV_SetPixelFormat
377
378      Set the pixel-format id used by this DC
379 */
380 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
381                            int iPixelFormat,
382                            const PIXELFORMATDESCRIPTOR *ppfd) {
383   TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
384
385   physDev->current_pf = iPixelFormat;
386
387   return TRUE;
388 }
389
390 /* X11DRV_SwapBuffers
391
392      Swap the buffers of this DC
393 */
394 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
395   if (opengl_handle == NULL) {
396     ERR("No libGL on this box - disabling OpenGL support !\n");
397     return 0;
398   }
399   
400   TRACE("(%p)\n", physDev);
401
402   wine_tsx11_lock();
403   pglXSwapBuffers(gdi_display, physDev->drawable);
404   wine_tsx11_unlock();
405
406   return TRUE;
407 }
408
409 /***********************************************************************
410  *              X11DRV_setup_opengl_visual
411  *
412  * Setup the default visual used for OpenGL and Direct3D, and the desktop
413  * window (if it exists).  If OpenGL isn't available, the visual is simply
414  * set to the default visual for the display
415  */
416 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
417 {
418     XVisualInfo *visual = NULL;
419     int dblBuf[]={GLX_RGBA,GLX_DEPTH_SIZE,16,GLX_DOUBLEBUFFER,None};
420
421     if (opengl_handle == NULL) return NULL;
422     
423     /* In order to support OpenGL or D3D, we require a double-buffered visual */
424     wine_tsx11_lock();
425     visual = pglXChooseVisual(display, DefaultScreen(display), dblBuf);
426     wine_tsx11_unlock();
427     return visual;
428 }
429
430 #else  /* no OpenGL includes */
431
432 void X11DRV_OpenGL_Init(Display *display)
433 {
434 }
435
436 /***********************************************************************
437  *              ChoosePixelFormat (X11DRV.@)
438  */
439 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
440                              const PIXELFORMATDESCRIPTOR *ppfd) {
441   ERR("No OpenGL support compiled in.\n");
442
443   return 0;
444 }
445
446 /***********************************************************************
447  *              DescribePixelFormat (X11DRV.@)
448  */
449 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
450                                int iPixelFormat,
451                                UINT nBytes,
452                                PIXELFORMATDESCRIPTOR *ppfd) {
453   ERR("No OpenGL support compiled in.\n");
454
455   return 0;
456 }
457
458 /***********************************************************************
459  *              GetPixelFormat (X11DRV.@)
460  */
461 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
462   ERR("No OpenGL support compiled in.\n");
463
464   return 0;
465 }
466
467 /***********************************************************************
468  *              SetPixelFormat (X11DRV.@)
469  */
470 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
471                            int iPixelFormat,
472                            const PIXELFORMATDESCRIPTOR *ppfd) {
473   ERR("No OpenGL support compiled in.\n");
474
475   return FALSE;
476 }
477
478 /***********************************************************************
479  *              SwapBuffers (X11DRV.@)
480  */
481 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
482   ERR("No OpenGL support compiled in.\n");
483
484   return FALSE;
485 }
486
487 XVisualInfo *X11DRV_setup_opengl_visual( Display *display )
488 {
489   return NULL;
490 }
491
492 #endif /* defined(HAVE_OPENGL) */