Fonts with an incomplete character set could cause a fault.
[wine] / graphics / 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
23 #include "ts_xlib.h"
24
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "wine/debug.h"
29 #include "gdi.h"
30 #include "x11drv.h"
31 #include "wine_gl.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(opengl);
34
35 #ifdef HAVE_OPENGL
36
37 static void dump_PIXELFORMATDESCRIPTOR(PIXELFORMATDESCRIPTOR *ppfd) {
38   DPRINTF("  - size / version : %d / %d\n", ppfd->nSize, ppfd->nVersion);
39   DPRINTF("  - dwFlags : ");
40 #define TEST_AND_DUMP(t,tv) if ((t) & (tv)) DPRINTF(#tv " ")
41   TEST_AND_DUMP(ppfd->dwFlags, PFD_DEPTH_DONTCARE);
42   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER);
43   TEST_AND_DUMP(ppfd->dwFlags, PFD_DOUBLEBUFFER_DONTCARE);
44   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_WINDOW);
45   TEST_AND_DUMP(ppfd->dwFlags, PFD_DRAW_TO_BITMAP);
46   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_ACCELERATED);
47   TEST_AND_DUMP(ppfd->dwFlags, PFD_GENERIC_FORMAT);
48   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_PALETTE);
49   TEST_AND_DUMP(ppfd->dwFlags, PFD_NEED_SYSTEM_PALETTE);
50   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO);
51   TEST_AND_DUMP(ppfd->dwFlags, PFD_STEREO_DONTCARE);
52   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_GDI);
53   TEST_AND_DUMP(ppfd->dwFlags, PFD_SUPPORT_OPENGL);
54   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_COPY);
55   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_EXCHANGE);
56   TEST_AND_DUMP(ppfd->dwFlags, PFD_SWAP_LAYER_BUFFERS);
57 #undef TEST_AND_DUMP
58   DPRINTF("\n");
59
60   DPRINTF("  - iPixelType : ");
61   switch (ppfd->iPixelType) {
62   case PFD_TYPE_RGBA: DPRINTF("PFD_TYPE_RGBA"); break;
63   case PFD_TYPE_COLORINDEX: DPRINTF("PFD_TYPE_COLORINDEX"); break;
64   }
65   DPRINTF("\n");
66
67   DPRINTF("  - Color   : %d\n", ppfd->cColorBits);
68   DPRINTF("  - Alpha   : %d\n", ppfd->cAlphaBits);
69   DPRINTF("  - Accum   : %d\n", ppfd->cAccumBits);
70   DPRINTF("  - Depth   : %d\n", ppfd->cDepthBits);
71   DPRINTF("  - Stencil : %d\n", ppfd->cStencilBits);
72   DPRINTF("  - Aux     : %d\n", ppfd->cAuxBuffers);
73
74   DPRINTF("  - iLayerType : ");
75   switch (ppfd->iLayerType) {
76   case PFD_MAIN_PLANE: DPRINTF("PFD_MAIN_PLANE"); break;
77   case PFD_OVERLAY_PLANE: DPRINTF("PFD_OVERLAY_PLANE"); break;
78   case PFD_UNDERLAY_PLANE: DPRINTF("PFD_UNDERLAY_PLANE"); break;
79   }
80   DPRINTF("\n");
81 }
82
83 /* X11DRV_ChoosePixelFormat
84
85      Equivalent of glXChooseVisual
86 */
87 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
88                              const PIXELFORMATDESCRIPTOR *ppfd) {
89 #define TEST_AND_ADD1(t,a) if (t) att_list[att_pos++] = a
90 #define TEST_AND_ADD2(t,a,b) if (t) { att_list[att_pos++] = a; att_list[att_pos++] = b; }
91 #define NULL_TEST_AND_ADD2(tv,a,b) att_list[att_pos++] = a; att_list[att_pos++] = ((tv) == 0 ? 0 : b)
92 #define ADD2(a,b) att_list[att_pos++] = a; att_list[att_pos++] = b
93
94   int att_list[64];
95   int att_pos = 0;
96   XVisualInfo *vis;
97   int i;
98
99   if (TRACE_ON(opengl)) {
100     TRACE("(%p,%p)\n", physDev, ppfd);
101
102     dump_PIXELFORMATDESCRIPTOR((PIXELFORMATDESCRIPTOR *) ppfd);
103   }
104
105   if (ppfd->dwFlags & PFD_DRAW_TO_BITMAP) {
106     ERR("Flag not supported !\n");
107     /* Should SetError here... */
108     return 0;
109   }
110
111   /* Now, build the request to GLX */
112   TEST_AND_ADD1(ppfd->dwFlags & PFD_DOUBLEBUFFER, GLX_DOUBLEBUFFER);
113   TEST_AND_ADD1(ppfd->dwFlags & PFD_STEREO, GLX_STEREO);
114   TEST_AND_ADD1(ppfd->iPixelType == PFD_TYPE_RGBA, GLX_RGBA);
115   TEST_AND_ADD2(ppfd->iPixelType == PFD_TYPE_COLORINDEX, GLX_BUFFER_SIZE, ppfd->cColorBits);
116
117   NULL_TEST_AND_ADD2(ppfd->cDepthBits, GLX_DEPTH_SIZE, 8);
118   /* These flags are not supported yet...
119
120      NULL_TEST_AND_ADD2(ppfd->cAlphaBits, GLX_ALPHA_SIZE, 8);
121      ADD2(GLX_ACCUM_SIZE, ppfd->cAccumBits); */
122   ADD2(GLX_STENCIL_SIZE, ppfd->cStencilBits); /* now suported */
123   /*   ADD2(GLX_AUX_BUFFERS, ppfd->cAuxBuffers); */
124   att_list[att_pos] = None;
125
126   ENTER_GL(); {
127     /*
128        This command cannot be used as we need to use the default visual...
129        Let's hope it at least contains some OpenGL functionnalities
130
131        vis = glXChooseVisual(gdi_display, DefaultScreen(gdi_display), att_list);
132     */
133     int num;
134     XVisualInfo template;
135
136     template.visualid = XVisualIDFromVisual(visual);
137     vis = XGetVisualInfo(gdi_display, VisualIDMask, &template, &num);
138
139     TRACE("Found visual : %p - returns %d\n", vis, physDev->used_visuals + 1);
140   }
141   LEAVE_GL();
142
143   if (vis == NULL) {
144     ERR("No visual found !\n");
145     /* Should SetError here... */
146     return 0;
147   }
148   /* try to find the visualid in the already created visuals */
149   for( i=0; i<physDev->used_visuals; i++ ) {
150     if ( vis->visualid == physDev->visuals[i]->visualid ) {
151       XFree(vis);
152       return i+1;
153     }
154   }
155   /* now give up, if the maximum is reached */
156   if (physDev->used_visuals == MAX_PIXELFORMATS) {
157     ERR("Maximum number of visuals reached !\n");
158     /* Should SetError here... */
159     return 0;
160   }
161   physDev->visuals[physDev->used_visuals++] = vis;
162
163   return physDev->used_visuals;
164 }
165
166 /* X11DRV_DescribePixelFormat
167
168      Get the pixel-format descriptor associated to the given id
169 */
170 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
171                                int iPixelFormat,
172                                UINT nBytes,
173                                PIXELFORMATDESCRIPTOR *ppfd) {
174   XVisualInfo *vis;
175   int value;
176   int rb,gb,bb,ab;
177
178   TRACE("(%p,%d,%d,%p)\n", physDev, iPixelFormat, nBytes, ppfd);
179
180   if (ppfd == NULL) {
181     /* The application is only querying the number of visuals */
182     return MAX_PIXELFORMATS;
183   }
184
185   if (nBytes < sizeof(PIXELFORMATDESCRIPTOR)) {
186     ERR("Wrong structure size !\n");
187     /* Should set error */
188     return 0;
189   }
190   if ((iPixelFormat > MAX_PIXELFORMATS) ||
191       (iPixelFormat > physDev->used_visuals + 1) ||
192       (iPixelFormat <= 0)) {
193     ERR("Wrong pixel format !\n");
194     /* Should set error */
195     return 0;
196   }
197
198   if (iPixelFormat == physDev->used_visuals + 1) {
199     int dblBuf[]={GLX_RGBA,GLX_DEPTH_SIZE,16,GLX_DOUBLEBUFFER,None};
200
201     /* Create a 'standard' X Visual */
202     ENTER_GL();
203     vis = glXChooseVisual(gdi_display, DefaultScreen(gdi_display), dblBuf);
204     LEAVE_GL();
205
206     WARN("Uninitialized Visual. Creating standard (%p) !\n", vis);
207
208     if (vis == NULL) {
209       ERR("Could not create standard visual !\n");
210       /* Should set error */
211       return 0;
212     }
213
214     physDev->visuals[physDev->used_visuals++] = vis;
215   }
216   vis = physDev->visuals[iPixelFormat - 1];
217
218   memset(ppfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
219   ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
220   ppfd->nVersion = 1;
221
222   /* These flags are always the same... */
223   ppfd->dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_GENERIC_ACCELERATED;
224   /* Now the flags extraced from the Visual */
225   ENTER_GL();
226   glXGetConfig(gdi_display, vis, GLX_DOUBLEBUFFER, &value); if (value) ppfd->dwFlags |= PFD_DOUBLEBUFFER;
227   glXGetConfig(gdi_display, vis, GLX_STEREO, &value); if (value) ppfd->dwFlags |= PFD_STEREO;
228
229   /* Pixel type */
230   glXGetConfig(gdi_display, vis, GLX_RGBA, &value);
231   if (value)
232     ppfd->iPixelType = PFD_TYPE_RGBA;
233   else
234     ppfd->iPixelType = PFD_TYPE_COLORINDEX;
235
236   /* Color bits */
237   glXGetConfig(gdi_display, vis, GLX_BUFFER_SIZE, &value);
238   ppfd->cColorBits = value;
239
240   /* Red, green, blue and alpha bits / shifts */
241   if (ppfd->iPixelType == PFD_TYPE_RGBA) {
242     glXGetConfig(gdi_display, vis, GLX_RED_SIZE, &rb);
243     glXGetConfig(gdi_display, vis, GLX_GREEN_SIZE, &gb);
244     glXGetConfig(gdi_display, vis, GLX_BLUE_SIZE, &bb);
245     glXGetConfig(gdi_display, vis, GLX_ALPHA_SIZE, &ab);
246
247     ppfd->cRedBits = rb;
248     ppfd->cRedShift = gb + bb + ab;
249     ppfd->cBlueBits = bb;
250     ppfd->cBlueShift = ab;
251     ppfd->cGreenBits = gb;
252     ppfd->cGreenShift = bb + ab;
253     ppfd->cAlphaBits = ab;
254     ppfd->cAlphaShift = 0;
255   } else {
256     ppfd->cRedBits = 0;
257     ppfd->cRedShift = 0;
258     ppfd->cBlueBits = 0;
259     ppfd->cBlueShift = 0;
260     ppfd->cGreenBits = 0;
261     ppfd->cGreenShift = 0;
262     ppfd->cAlphaBits = 0;
263     ppfd->cAlphaShift = 0;
264   }
265   /* Accums : to do ... */
266
267   /* Depth bits */
268   glXGetConfig(gdi_display, vis, GLX_DEPTH_SIZE, &value);
269   ppfd->cDepthBits = value;
270
271   /* stencil bits */
272   glXGetConfig( gdi_display, vis, GLX_STENCIL_SIZE, &value );
273   ppfd->cStencilBits = value;
274
275   LEAVE_GL();
276
277   /* Aux : to do ... */
278
279   ppfd->iLayerType = PFD_MAIN_PLANE;
280
281   if (TRACE_ON(opengl)) {
282     dump_PIXELFORMATDESCRIPTOR(ppfd);
283   }
284
285   return MAX_PIXELFORMATS;
286 }
287
288 /* X11DRV_GetPixelFormat
289
290      Get the pixel-format id used by this DC
291 */
292 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
293   TRACE("(%p): returns %d\n", physDev, physDev->current_pf);
294
295   return physDev->current_pf;
296 }
297
298 /* X11DRV_SetPixelFormat
299
300      Set the pixel-format id used by this DC
301 */
302 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
303                            int iPixelFormat,
304                            const PIXELFORMATDESCRIPTOR *ppfd) {
305   TRACE("(%p,%d,%p)\n", physDev, iPixelFormat, ppfd);
306
307   physDev->current_pf = iPixelFormat;
308
309   return TRUE;
310 }
311
312 /* X11DRV_SwapBuffers
313
314      Swap the buffers of this DC
315 */
316 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
317   TRACE("(%p)\n", physDev);
318
319   ENTER_GL();
320   glXSwapBuffers(gdi_display, physDev->drawable);
321   LEAVE_GL();
322
323   return TRUE;
324 }
325
326 #else  /* defined(HAVE_OPENGL) */
327
328 int X11DRV_ChoosePixelFormat(X11DRV_PDEVICE *physDev,
329                              const PIXELFORMATDESCRIPTOR *ppfd) {
330   ERR("No OpenGL support compiled in.\n");
331
332   return 0;
333 }
334
335 int X11DRV_DescribePixelFormat(X11DRV_PDEVICE *physDev,
336                                int iPixelFormat,
337                                UINT nBytes,
338                                PIXELFORMATDESCRIPTOR *ppfd) {
339   ERR("No OpenGL support compiled in.\n");
340
341   return 0;
342 }
343
344 int X11DRV_GetPixelFormat(X11DRV_PDEVICE *physDev) {
345   ERR("No OpenGL support compiled in.\n");
346
347   return 0;
348 }
349
350 BOOL X11DRV_SetPixelFormat(X11DRV_PDEVICE *physDev,
351                            int iPixelFormat,
352                            const PIXELFORMATDESCRIPTOR *ppfd) {
353   ERR("No OpenGL support compiled in.\n");
354
355   return FALSE;
356 }
357
358 BOOL X11DRV_SwapBuffers(X11DRV_PDEVICE *physDev) {
359   ERR("No OpenGL support compiled in.\n");
360
361   return FALSE;
362 }
363
364 #endif /* defined(HAVE_OPENGL) */