gdi32/tests: Add some StretchDIBits tests.
[wine] / dlls / gdi32 / opengl.c
1 /*
2  * OpenGL function forwarding to the display driver
3  *
4  * Copyright (c) 1999 Lionel Ulmer
5  * Copyright (c) 2005 Raphael Junqueira
6  * Copyright (c) 2006 Roderick Colenbrander
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <stdarg.h>
27 #include <string.h>
28 #include <stdlib.h>
29
30 #include "windef.h"
31 #include "winbase.h"
32 #include "wingdi.h"
33 #include "winerror.h"
34 #include "winternl.h"
35 #include "winnt.h"
36 #include "gdi_private.h"
37 #include "wine/debug.h"
38
39 WINE_DEFAULT_DEBUG_CHANNEL(wgl);
40
41 static HDC default_hdc = 0;
42
43 typedef struct opengl_context
44 {
45     HDC hdc;
46 } *OPENGL_Context;
47
48 /* We route all wgl functions from opengl32.dll through gdi32.dll to
49  * the display driver. Various wgl calls have a hDC as one of their parameters.
50  * Using get_dc_ptr we get access to the functions exported by the driver.
51  * Some functions don't receive a hDC. This function creates a global hdc and
52  * if there's already a global hdc, it returns it.
53  */
54 static DC* OPENGL_GetDefaultDC(void)
55 {
56     if(!default_hdc)
57         default_hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
58
59     return get_dc_ptr(default_hdc);
60 }
61
62 /***********************************************************************
63  *              wglCopyContext (OPENGL32.@)
64  */
65 BOOL WINAPI wglCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
66 {
67     DC *dc;
68     BOOL ret = FALSE;
69     OPENGL_Context ctx = (OPENGL_Context)hglrcSrc;
70
71     TRACE("hglrcSrc: (%p), hglrcDst: (%p), mask: %#x\n", hglrcSrc, hglrcDst, mask);
72     /* If no context is set, this call doesn't have a purpose */
73     if(!hglrcSrc || !hglrcDst)
74         return FALSE;
75
76     /* Retrieve the HDC associated with the context to access the display driver */
77     dc = get_dc_ptr(ctx->hdc);
78     if (dc)
79     {
80         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglCopyContext );
81         ret = physdev->funcs->pwglCopyContext(hglrcSrc, hglrcDst, mask);
82         release_dc_ptr( dc );
83     }
84     return ret;
85 }
86
87 /***********************************************************************
88  *              wglCreateContext (OPENGL32.@)
89  */
90 HGLRC WINAPI wglCreateContext(HDC hdc)
91 {
92     HGLRC ret = 0;
93     DC * dc = get_dc_ptr( hdc );
94
95     TRACE("(%p)\n",hdc);
96
97     if (dc)
98     {
99         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglCreateContext );
100         update_dc( dc );
101         ret = physdev->funcs->pwglCreateContext( physdev );
102         release_dc_ptr( dc );
103     }
104     return ret;
105 }
106
107 /***********************************************************************
108  *      wglCreateContextAttribsARB
109  */
110 static HGLRC WINAPI wglCreateContextAttribsARB(HDC hdc, HGLRC hShareContext, const int *attributeList)
111 {
112     HGLRC ret = 0;
113     DC * dc = get_dc_ptr( hdc );
114
115     TRACE("(%p)\n",hdc);
116
117     if (dc)
118     {
119         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglCreateContextAttribsARB );
120         update_dc( dc );
121         ret = physdev->funcs->pwglCreateContextAttribsARB( physdev, hShareContext, attributeList );
122         release_dc_ptr( dc );
123     }
124     return ret;
125 }
126
127 /***********************************************************************
128  *              wglDeleteContext (OPENGL32.@)
129  */
130 BOOL WINAPI wglDeleteContext(HGLRC hglrc)
131 {
132     DC *dc;
133     BOOL ret = FALSE;
134     OPENGL_Context ctx = (OPENGL_Context)hglrc;
135
136     TRACE("hglrc: (%p)\n", hglrc);
137     if(ctx == NULL)
138     {
139         SetLastError(ERROR_INVALID_HANDLE);
140         return FALSE;
141     }
142
143     /* Retrieve the HDC associated with the context to access the display driver */
144     dc = get_dc_ptr(ctx->hdc);
145     if (dc)
146     {
147         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglDeleteContext );
148         ret = physdev->funcs->pwglDeleteContext( hglrc );
149         release_dc_ptr( dc );
150     }
151     else SetLastError(ERROR_INVALID_HANDLE);
152     return ret;
153 }
154
155 /***********************************************************************
156  *              wglGetCurrentContext (OPENGL32.@)
157  */
158 HGLRC WINAPI wglGetCurrentContext(void)
159 {
160     HGLRC ret = NtCurrentTeb()->glContext;
161     TRACE(" returning %p\n", ret);
162     return ret;
163 }
164
165 /***********************************************************************
166  *              wglGetCurrentDC (OPENGL32.@)
167  */
168 HDC WINAPI wglGetCurrentDC(void)
169 {
170     OPENGL_Context ctx = (OPENGL_Context)wglGetCurrentContext();
171
172     TRACE(" found context: %p\n", ctx);
173     if(ctx == NULL)
174         return NULL;
175
176     /* Retrieve the current DC from the active context */
177     TRACE(" returning hdc: %p\n", ctx->hdc);
178     return ctx->hdc;
179 }
180
181 /***********************************************************************
182  *              wglGetPbufferDCARB
183  */
184 static HDC WINAPI wglGetPbufferDCARB(void *pbuffer)
185 {
186     HDC ret = 0;
187
188     /* Create a device context to associate with the pbuffer */
189     HDC hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
190     DC *dc = get_dc_ptr(hdc);
191
192     TRACE("(%p)\n", pbuffer);
193
194     if (dc)
195     {
196         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglGetPbufferDCARB );
197
198         /* The display driver has to do the rest of the work because
199          * we need access to lowlevel datatypes which we can't access here
200          */
201         ret = physdev->funcs->pwglGetPbufferDCARB( physdev, pbuffer );
202         release_dc_ptr( dc );
203     }
204     TRACE("(%p), hdc=%p\n", pbuffer, ret);
205     if (!ret) DeleteDC( hdc );
206     return ret;
207 }
208
209 /***********************************************************************
210  *              wglMakeCurrent (OPENGL32.@)
211  */
212 BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc)
213 {
214     BOOL ret = FALSE;
215     DC * dc = NULL;
216
217     /* When the context hglrc is NULL, the HDC is ignored and can be NULL.
218      * In that case use the global hDC to get access to the driver.  */
219     if(hglrc == NULL)
220     {
221         if( hdc == NULL && !wglGetCurrentContext() )
222         {
223             WARN( "Current context is NULL\n");
224             SetLastError( ERROR_INVALID_HANDLE );
225             return FALSE;
226         }
227         dc = OPENGL_GetDefaultDC();
228     }
229     else
230         dc = get_dc_ptr( hdc );
231
232     TRACE("hdc: (%p), hglrc: (%p)\n", hdc, hglrc);
233
234     if (dc)
235     {
236         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglMakeCurrent );
237         update_dc( dc );
238         ret = physdev->funcs->pwglMakeCurrent( physdev, hglrc );
239         release_dc_ptr( dc );
240     }
241     return ret;
242 }
243
244 /***********************************************************************
245  *              wglMakeContextCurrentARB
246  */
247 static BOOL WINAPI wglMakeContextCurrentARB(HDC hDrawDC, HDC hReadDC, HGLRC hglrc)
248 {
249     BOOL ret = FALSE;
250     PHYSDEV draw_physdev, read_physdev;
251     DC *DrawDC;
252     DC *ReadDC;
253
254     TRACE("hDrawDC: (%p), hReadDC: (%p) hglrc: (%p)\n", hDrawDC, hReadDC, hglrc);
255
256     /* Both hDrawDC and hReadDC need to be valid */
257     DrawDC = get_dc_ptr( hDrawDC );
258     if (!DrawDC) return FALSE;
259
260     ReadDC = get_dc_ptr( hReadDC );
261     if (!ReadDC) {
262         release_dc_ptr( DrawDC );
263         return FALSE;
264     }
265
266     update_dc( DrawDC );
267     update_dc( ReadDC );
268     draw_physdev = GET_DC_PHYSDEV( DrawDC, pwglMakeContextCurrentARB );
269     read_physdev = GET_DC_PHYSDEV( ReadDC, pwglMakeContextCurrentARB );
270     if (draw_physdev->funcs == read_physdev->funcs)
271         ret = draw_physdev->funcs->pwglMakeContextCurrentARB(draw_physdev, read_physdev, hglrc);
272     release_dc_ptr( DrawDC );
273     release_dc_ptr( ReadDC );
274     return ret;
275 }
276
277 /**************************************************************************************
278  *      WINE-specific wglSetPixelFormat which can set the iPixelFormat multiple times
279  *
280  */
281 static BOOL WINAPI wglSetPixelFormatWINE(HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
282 {
283     INT bRet = FALSE;
284     DC * dc = get_dc_ptr( hdc );
285
286     TRACE("(%p,%d,%p)\n", hdc, iPixelFormat, ppfd);
287
288     if (dc)
289     {
290         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglSetPixelFormatWINE );
291         update_dc( dc );
292         bRet = physdev->funcs->pwglSetPixelFormatWINE( physdev, iPixelFormat, ppfd );
293         release_dc_ptr( dc );
294     }
295     return bRet;
296 }
297
298 /***********************************************************************
299  *              wglShareLists (OPENGL32.@)
300  */
301 BOOL WINAPI wglShareLists(HGLRC hglrc1, HGLRC hglrc2)
302 {
303     DC *dc;
304     BOOL ret = FALSE;
305     OPENGL_Context ctx = (OPENGL_Context)hglrc1;
306
307     TRACE("hglrc1: (%p); hglrc: (%p)\n", hglrc1, hglrc2);
308     if(ctx == NULL || hglrc2 == NULL)
309         return FALSE;
310
311     /* Retrieve the HDC associated with the context to access the display driver */
312     dc = get_dc_ptr(ctx->hdc);
313     if (dc)
314     {
315         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglShareLists );
316         ret = physdev->funcs->pwglShareLists( hglrc1, hglrc2 );
317         release_dc_ptr( dc );
318     }
319     return ret;
320 }
321
322 /***********************************************************************
323  *              wglUseFontBitmapsA (OPENGL32.@)
324  */
325 BOOL WINAPI wglUseFontBitmapsA(HDC hdc, DWORD first, DWORD count, DWORD listBase)
326 {
327     BOOL ret = FALSE;
328     DC * dc = get_dc_ptr( hdc );
329
330     TRACE("(%p, %d, %d, %d)\n", hdc, first, count, listBase);
331
332     if (dc)
333     {
334         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglUseFontBitmapsA );
335         ret = physdev->funcs->pwglUseFontBitmapsA( physdev, first, count, listBase );
336         release_dc_ptr( dc );
337     }
338     return ret;
339 }
340
341 /***********************************************************************
342  *              wglUseFontBitmapsW (OPENGL32.@)
343  */
344 BOOL WINAPI wglUseFontBitmapsW(HDC hdc, DWORD first, DWORD count, DWORD listBase)
345 {
346     BOOL ret = FALSE;
347     DC * dc = get_dc_ptr( hdc );
348
349     TRACE("(%p, %d, %d, %d)\n", hdc, first, count, listBase);
350
351     if (dc)
352     {
353         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglUseFontBitmapsW );
354         ret = physdev->funcs->pwglUseFontBitmapsW( physdev, first, count, listBase );
355         release_dc_ptr( dc );
356     }
357     return ret;
358 }
359
360 /***********************************************************************
361  *              Internal wglGetProcAddress for retrieving WGL extensions
362  */
363 PROC WINAPI wglGetProcAddress(LPCSTR func)
364 {
365     PROC ret = NULL;
366     DC *dc;
367
368     if(!func)
369         return NULL;
370
371     TRACE("func: '%s'\n", func);
372
373     /* Retrieve the global hDC to get access to the driver.  */
374     dc = OPENGL_GetDefaultDC();
375     if (dc)
376     {
377         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pwglGetProcAddress );
378         ret = physdev->funcs->pwglGetProcAddress(func);
379         release_dc_ptr( dc );
380     }
381
382     /* At the moment we implement one WGL extension which requires a HDC. When we
383      * are looking up this call and when the Extension is available (that is the case
384      * when a non-NULL value is returned by wglGetProcAddress), we return the address
385      * of a wrapper function which will handle the HDC->PhysDev conversion.
386      */
387     if(ret && strcmp(func, "wglCreateContextAttribsARB") == 0)
388         return (PROC)wglCreateContextAttribsARB;
389     else if(ret && strcmp(func, "wglMakeContextCurrentARB") == 0)
390         return (PROC)wglMakeContextCurrentARB;
391     else if(ret && strcmp(func, "wglGetPbufferDCARB") == 0)
392         return (PROC)wglGetPbufferDCARB;
393     else if(ret && strcmp(func, "wglSetPixelFormatWINE") == 0)
394         return (PROC)wglSetPixelFormatWINE;
395
396     return ret;
397 }