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) return FALSE;
79
80 if (!dc->funcs->pwglCopyContext) FIXME(" :stub\n");
81 else ret = dc->funcs->pwglCopyContext(hglrcSrc, hglrcDst, mask);
82
83 release_dc_ptr( dc );
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) return 0;
98
99 update_dc( dc );
100 if (!dc->funcs->pwglCreateContext) FIXME(" :stub\n");
101 else ret = dc->funcs->pwglCreateContext(dc->physDev);
102
103 release_dc_ptr( dc );
104 return ret;
105 }
106
107
108 /***********************************************************************
109 * wglDeleteContext (OPENGL32.@)
110 */
111 BOOL WINAPI wglDeleteContext(HGLRC hglrc)
112 {
113 DC *dc;
114 BOOL ret = FALSE;
115 OPENGL_Context ctx = (OPENGL_Context)hglrc;
116
117 TRACE("hglrc: (%p)\n", hglrc);
118 if(ctx == NULL)
119 return FALSE;
120
121 /* Retrieve the HDC associated with the context to access the display driver */
122 dc = get_dc_ptr(ctx->hdc);
123 if (!dc) return FALSE;
124
125 if (!dc->funcs->pwglDeleteContext) FIXME(" :stub\n");
126 else ret = dc->funcs->pwglDeleteContext(hglrc);
127
128 release_dc_ptr( dc );
129 return ret;
130 }
131
132 /***********************************************************************
133 * wglGetCurrentContext (OPENGL32.@)
134 */
135 HGLRC WINAPI wglGetCurrentContext(void)
136 {
137 HGLRC ret = NtCurrentTeb()->glContext;
138 TRACE(" returning %p\n", ret);
139 return ret;
140 }
141
142 /***********************************************************************
143 * wglGetCurrentDC (OPENGL32.@)
144 */
145 HDC WINAPI wglGetCurrentDC(void)
146 {
147 OPENGL_Context ctx = (OPENGL_Context)wglGetCurrentContext();
148
149 TRACE(" found context: %p\n", ctx);
150 if(ctx == NULL)
151 return NULL;
152
153 /* Retrieve the current DC from the active context */
154 TRACE(" returning hdc: %p\n", ctx->hdc);
155 return ctx->hdc;
156 }
157
158 /***********************************************************************
159 * wglGetPbufferDCARB
160 */
161 static HDC WINAPI wglGetPbufferDCARB(void *pbuffer)
162 {
163 HDC ret = 0;
164
165 /* Create a device context to associate with the pbuffer */
166 HDC hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
167 DC *dc = get_dc_ptr(hdc);
168
169 TRACE("(%p)\n", pbuffer);
170
171 if (!dc) return FALSE;
172
173 /* The display driver has to do the rest of the work because
174 * we need access to lowlevel datatypes which we can't access here
175 */
176 if (!dc->funcs->pwglGetPbufferDCARB) FIXME(" :stub\n");
177 else ret = dc->funcs->pwglGetPbufferDCARB(dc->physDev, pbuffer);
178
179 TRACE("(%p), hdc=%p\n", pbuffer, ret);
180
181 release_dc_ptr( dc );
182 return ret;
183 }
184
185 /***********************************************************************
186 * wglMakeCurrent (OPENGL32.@)
187 */
188 BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc)
189 {
190 BOOL ret = FALSE;
191 DC * dc = NULL;
192
193 /* When the context hglrc is NULL, the HDC is ignored and can be NULL.
194 * In that case use the global hDC to get access to the driver. */
195 if(hglrc == NULL)
196 dc = OPENGL_GetDefaultDC();
197 else
198 dc = get_dc_ptr( hdc );
199
200 TRACE("hdc: (%p), hglrc: (%p)\n", hdc, hglrc);
201
202 if (!dc) return FALSE;
203
204 update_dc( dc );
205 if (!dc->funcs->pwglMakeCurrent) FIXME(" :stub\n");
206 else ret = dc->funcs->pwglMakeCurrent(dc->physDev,hglrc);
207
208 release_dc_ptr( dc );
209 return ret;
210 }
211
212 /***********************************************************************
213 * wglMakeContextCurrentARB
214 */
215 static BOOL WINAPI wglMakeContextCurrentARB(HDC hDrawDC, HDC hReadDC, HGLRC hglrc)
216 {
217 BOOL ret = FALSE;
218 DC *DrawDC;
219 DC *ReadDC;
220
221 TRACE("hDrawDC: (%p), hReadDC: (%p) hglrc: (%p)\n", hDrawDC, hReadDC, hglrc);
222
223 /* Both hDrawDC and hReadDC need to be valid */
224 DrawDC = get_dc_ptr( hDrawDC );
225 if (!DrawDC) return FALSE;
226
227 ReadDC = get_dc_ptr( hReadDC );
228 if (!ReadDC) {
229 release_dc_ptr( DrawDC );
230 return FALSE;
231 }
232
233 update_dc( DrawDC );
234 update_dc( ReadDC );
235 if (!DrawDC->funcs->pwglMakeContextCurrentARB) FIXME(" :stub\n");
236 else ret = DrawDC->funcs->pwglMakeContextCurrentARB(DrawDC->physDev, ReadDC->physDev, hglrc);
237
238 release_dc_ptr( DrawDC );
239 release_dc_ptr( ReadDC );
240 return ret;
241 }
242
243 /**************************************************************************************
244 * WINE-specific wglSetPixelFormat which can set the iPixelFormat multiple times
245 *
246 */
247 static BOOL WINAPI wglSetPixelFormatWINE(HDC hdc, int iPixelFormat, const PIXELFORMATDESCRIPTOR *ppfd)
248 {
249 INT bRet = FALSE;
250 DC * dc = get_dc_ptr( hdc );
251
252 TRACE("(%p,%d,%p)\n", hdc, iPixelFormat, ppfd);
253
254 if (!dc) return 0;
255
256 update_dc( dc );
257 if (!dc->funcs->pwglSetPixelFormatWINE) FIXME(" :stub\n");
258 else bRet = dc->funcs->pwglSetPixelFormatWINE(dc->physDev, iPixelFormat, ppfd);
259
260 release_dc_ptr( dc );
261 return bRet;
262 }
263
264 /***********************************************************************
265 * wglShareLists (OPENGL32.@)
266 */
267 BOOL WINAPI wglShareLists(HGLRC hglrc1, HGLRC hglrc2)
268 {
269 DC *dc;
270 BOOL ret = FALSE;
271 OPENGL_Context ctx = (OPENGL_Context)hglrc1;
272
273 TRACE("hglrc1: (%p); hglrc: (%p)\n", hglrc1, hglrc2);
274 if(ctx == NULL)
275 return FALSE;
276
277 /* Retrieve the HDC associated with the context to access the display driver */
278 dc = get_dc_ptr(ctx->hdc);
279 if (!dc) return FALSE;
280
281 if (!dc->funcs->pwglShareLists) FIXME(" :stub\n");
282 else ret = dc->funcs->pwglShareLists(hglrc1, hglrc2);
283
284 release_dc_ptr( dc );
285 return ret;
286 }
287
288 /***********************************************************************
289 * wglUseFontBitmapsA (OPENGL32.@)
290 */
291 BOOL WINAPI wglUseFontBitmapsA(HDC hdc, DWORD first, DWORD count, DWORD listBase)
292 {
293 BOOL ret = FALSE;
294 DC * dc = get_dc_ptr( hdc );
295
296 TRACE("(%p, %d, %d, %d)\n", hdc, first, count, listBase);
297
298 if (!dc) return FALSE;
299
300 if (!dc->funcs->pwglUseFontBitmapsA) FIXME(" :stub\n");
301 else ret = dc->funcs->pwglUseFontBitmapsA(dc->physDev, first, count, listBase);
302
303 release_dc_ptr( dc );
304 return ret;
305 }
306
307 /***********************************************************************
308 * wglUseFontBitmapsW (OPENGL32.@)
309 */
310 BOOL WINAPI wglUseFontBitmapsW(HDC hdc, DWORD first, DWORD count, DWORD listBase)
311 {
312 BOOL ret = FALSE;
313 DC * dc = get_dc_ptr( hdc );
314
315 TRACE("(%p, %d, %d, %d)\n", hdc, first, count, listBase);
316
317 if (!dc) return FALSE;
318
319 if (!dc->funcs->pwglUseFontBitmapsW) FIXME(" :stub\n");
320 else ret = dc->funcs->pwglUseFontBitmapsW(dc->physDev, first, count, listBase);
321
322 release_dc_ptr( dc );
323 return ret;
324 }
325
326 /***********************************************************************
327 * Internal wglGetProcAddress for retrieving WGL extensions
328 */
329 PROC WINAPI wglGetProcAddress(LPCSTR func)
330 {
331 PROC ret = NULL;
332 DC *dc;
333
334 if(!func)
335 return NULL;
336
337 TRACE("func: '%s'\n", func);
338
339 /* Retrieve the global hDC to get access to the driver. */
340 dc = OPENGL_GetDefaultDC();
341 if (!dc) return FALSE;
342
343 if (!dc->funcs->pwglGetProcAddress) FIXME(" :stub\n");
344 else ret = dc->funcs->pwglGetProcAddress(func);
345
346 release_dc_ptr( dc );
347
348 /* At the moment we implement one WGL extension which requires a HDC. When we
349 * are looking up this call and when the Extension is available (that is the case
350 * when a non-NULL value is returned by wglGetProcAddress), we return the address
351 * of a wrapper function which will handle the HDC->PhysDev conversion.
352 */
353 if(ret && strcmp(func, "wglMakeContextCurrentARB") == 0)
354 return (PROC)wglMakeContextCurrentARB;
355 else if(ret && strcmp(func, "wglGetPbufferDCARB") == 0)
356 return (PROC)wglGetPbufferDCARB;
357 else if(ret && strcmp(func, "wglSetPixelFormatWINE") == 0)
358 return (PROC)wglSetPixelFormatWINE;
359
360 return ret;
361 }
362
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.