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 * 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) return 0;
118
119 update_dc( dc );
120 if (!dc->funcs->pwglCreateContextAttribsARB) FIXME(" :stub\n");
121 else ret = dc->funcs->pwglCreateContextAttribsARB(dc->physDev, hShareContext, attributeList);
122
123 release_dc_ptr( dc );
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 SetLastError(ERROR_INVALID_HANDLE);
148 return FALSE;
149 }
150
151 if (!dc->funcs->pwglDeleteContext) FIXME(" :stub\n");
152 else ret = dc->funcs->pwglDeleteContext(hglrc);
153
154 release_dc_ptr( dc );
155 return ret;
156 }
157
158 /***********************************************************************
159 * wglGetCurrentContext (OPENGL32.@)
160 */
161 HGLRC WINAPI wglGetCurrentContext(void)
162 {
163 HGLRC ret = NtCurrentTeb()->glContext;
164 TRACE(" returning %p\n", ret);
165 return ret;
166 }
167
168 /***********************************************************************
169 * wglGetCurrentDC (OPENGL32.@)
170 */
171 HDC WINAPI wglGetCurrentDC(void)
172 {
173 OPENGL_Context ctx = (OPENGL_Context)wglGetCurrentContext();
174
175 TRACE(" found context: %p\n", ctx);
176 if(ctx == NULL)
177 return NULL;
178
179 /* Retrieve the current DC from the active context */
180 TRACE(" returning hdc: %p\n", ctx->hdc);
181 return ctx->hdc;
182 }
183
184 /***********************************************************************
185 * wglGetPbufferDCARB
186 */
187 static HDC WINAPI wglGetPbufferDCARB(void *pbuffer)
188 {
189 HDC ret = 0;
190
191 /* Create a device context to associate with the pbuffer */
192 HDC hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
193 DC *dc = get_dc_ptr(hdc);
194
195 TRACE("(%p)\n", pbuffer);
196
197 if (!dc) return 0;
198
199 /* The display driver has to do the rest of the work because
200 * we need access to lowlevel datatypes which we can't access here
201 */
202 if (!dc->funcs->pwglGetPbufferDCARB) FIXME(" :stub\n");
203 else ret = dc->funcs->pwglGetPbufferDCARB(dc->physDev, pbuffer);
204
205 TRACE("(%p), hdc=%p\n", pbuffer, ret);
206
207 release_dc_ptr( dc );
208 return ret;
209 }
210
211 /***********************************************************************
212 * wglMakeCurrent (OPENGL32.@)
213 */
214 BOOL WINAPI wglMakeCurrent(HDC hdc, HGLRC hglrc)
215 {
216 BOOL ret = FALSE;
217 DC * dc = NULL;
218
219 /* When the context hglrc is NULL, the HDC is ignored and can be NULL.
220 * In that case use the global hDC to get access to the driver. */
221 if(hglrc == NULL)
222 {
223 if( hdc == NULL && !wglGetCurrentContext() )
224 {
225 WARN( "Current context is NULL\n");
226 SetLastError( ERROR_INVALID_HANDLE );
227 return FALSE;
228 }
229 dc = OPENGL_GetDefaultDC();
230 }
231 else
232 dc = get_dc_ptr( hdc );
233
234 TRACE("hdc: (%p), hglrc: (%p)\n", hdc, hglrc);
235
236 if (!dc) return FALSE;
237
238 update_dc( dc );
239 if (!dc->funcs->pwglMakeCurrent) FIXME(" :stub\n");
240 else ret = dc->funcs->pwglMakeCurrent(dc->physDev,hglrc);
241
242 release_dc_ptr( dc );
243 return ret;
244 }
245
246 /***********************************************************************
247 * wglMakeContextCurrentARB
248 */
249 static BOOL WINAPI wglMakeContextCurrentARB(HDC hDrawDC, HDC hReadDC, HGLRC hglrc)
250 {
251 BOOL ret = FALSE;
252 DC *DrawDC;
253 DC *ReadDC;
254
255 TRACE("hDrawDC: (%p), hReadDC: (%p) hglrc: (%p)\n", hDrawDC, hReadDC, hglrc);
256
257 /* Both hDrawDC and hReadDC need to be valid */
258 DrawDC = get_dc_ptr( hDrawDC );
259 if (!DrawDC) return FALSE;
260
261 ReadDC = get_dc_ptr( hReadDC );
262 if (!ReadDC) {
263 release_dc_ptr( DrawDC );
264 return FALSE;
265 }
266
267 update_dc( DrawDC );
268 update_dc( ReadDC );
269 if (!DrawDC->funcs->pwglMakeContextCurrentARB) FIXME(" :stub\n");
270 else ret = DrawDC->funcs->pwglMakeContextCurrentARB(DrawDC->physDev, ReadDC->physDev, hglrc);
271
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) return 0;
289
290 update_dc( dc );
291 if (!dc->funcs->pwglSetPixelFormatWINE) FIXME(" :stub\n");
292 else bRet = dc->funcs->pwglSetPixelFormatWINE(dc->physDev, iPixelFormat, ppfd);
293
294 release_dc_ptr( dc );
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) return FALSE;
314
315 if (!dc->funcs->pwglShareLists) FIXME(" :stub\n");
316 else ret = dc->funcs->pwglShareLists(hglrc1, hglrc2);
317
318 release_dc_ptr( dc );
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) return FALSE;
333
334 if (!dc->funcs->pwglUseFontBitmapsA) FIXME(" :stub\n");
335 else ret = dc->funcs->pwglUseFontBitmapsA(dc->physDev, first, count, listBase);
336
337 release_dc_ptr( dc );
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) return FALSE;
352
353 if (!dc->funcs->pwglUseFontBitmapsW) FIXME(" :stub\n");
354 else ret = dc->funcs->pwglUseFontBitmapsW(dc->physDev, first, count, listBase);
355
356 release_dc_ptr( dc );
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) return NULL;
376
377 if (!dc->funcs->pwglGetProcAddress) FIXME(" :stub\n");
378 else ret = dc->funcs->pwglGetProcAddress(func);
379
380 release_dc_ptr( dc );
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 }
398
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.