wgl.c@ 56335

Last change on this file since 56335 was 55622, checked in by vboxsync, 10 years ago
3D: Windows GAs: drop relatively big buffer allocation on stack.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 29.0 KB

Line
1	/* Copyright (c) 2001, Stanford University
2	* All rights reserved
3	*
4	* See the file LICENSE.txt for information on redistributing this software.
5	*/
6
7	#include "cr_error.h"
8	#include "cr_spu.h"
9	#include "cr_environment.h"
10	#include "cr_mem.h"
11	#include "stub.h"
12
13	/* I know most of the parameters are unused, dammit. */
14	#pragma warning( disable: 4100 )
15
16	#define WIN32_LEAN_AND_MEAN
17	#include <windows.h>
18	#include <stdio.h>
19
20	#include <iprt/cdefs.h>
21
22	/* Currently host part will misbehave re-creating context with proper visual bits
23	* if contexts with alternative visual bits is requested.
24	* For now we just report a superset of all visual bits to avoid that.
25	* Better to it on the host side as well?
26	* We could also implement properly multiple pixel formats,
27	* which should be done by implementing offscreen rendering or multiple host contexts.
28	* */
29	#define VBOX_CROGL_USE_VBITS_SUPERSET
30
31	#ifdef VBOX_CROGL_USE_VBITS_SUPERSET
32	static GLuint desiredVisual = CR_RGB_BIT \| CR_ALPHA_BIT \| CR_DEPTH_BIT \| CR_STENCIL_BIT \| CR_ACCUM_BIT \| CR_DOUBLE_BIT;
33	#else
34	static GLuint desiredVisual = CR_RGB_BIT;
35	#endif
36
37	#ifndef VBOX_CROGL_USE_VBITS_SUPERSET
38	/**
39	* Compute a mask of CR_*_BIT flags which reflects the attributes of
40	* the pixel format of the given hdc.
41	*/
42	static GLuint ComputeVisBits( HDC hdc )
43	{
44	PIXELFORMATDESCRIPTOR pfd;
45	int iPixelFormat;
46	GLuint b = 0;
47
48	iPixelFormat = GetPixelFormat( hdc );
49
50	DescribePixelFormat( hdc, iPixelFormat, sizeof(pfd), &pfd );
51
52	if (pfd.cDepthBits > 0)
53	b \|= CR_DEPTH_BIT;
54	if (pfd.cAccumBits > 0)
55	b \|= CR_ACCUM_BIT;
56	if (pfd.cColorBits > 8)
57	b \|= CR_RGB_BIT;
58	if (pfd.cStencilBits > 0)
59	b \|= CR_STENCIL_BIT;
60	if (pfd.cAlphaBits > 0)
61	b \|= CR_ALPHA_BIT;
62	if (pfd.dwFlags & PFD_DOUBLEBUFFER)
63	b \|= CR_DOUBLE_BIT;
64	if (pfd.dwFlags & PFD_STEREO)
65	b \|= CR_STEREO_BIT;
66
67	return b;
68	}
69	#endif
70
71	DECLEXPORT(int) WINAPI wglChoosePixelFormat_prox( HDC hdc, CONST PIXELFORMATDESCRIPTOR *pfd )
72	{
73	DWORD okayFlags;
74
75	CR_DDI_PROLOGUE();
76
77	stubInit();
78
79	/*
80	* NOTE!!!
81	* Here we're telling the renderspu not to use the GDI
82	* equivalent's of ChoosePixelFormat/DescribePixelFormat etc
83	* There are subtle differences in the use of these calls.
84	*/
85	crSetenv("CR_WGL_DO_NOT_USE_GDI", "yes");
86
87	if ( pfd->nSize != sizeof(*pfd) \|\| pfd->nVersion != 1 ) {
88	crError( "wglChoosePixelFormat: bad pfd\n" );
89	return 0;
90	}
91
92	okayFlags = ( PFD_DRAW_TO_WINDOW \|
93	PFD_SUPPORT_GDI \|
94	PFD_SUPPORT_OPENGL \|
95	PFD_DOUBLEBUFFER \|
96	PFD_DOUBLEBUFFER_DONTCARE \|
97	PFD_SWAP_EXCHANGE \|
98	PFD_SWAP_COPY \|
99	/* @todo: this is disabled due to VSG Open Inventor interop issues
100	* it does not make any sense actually since reporting this
101	* as well as choosing a pixel format with this cap would not do anything
102	* since ICD stuff has its own pixelformat state var */
103	// PFD_STEREO \|
104	PFD_STEREO_DONTCARE \|
105	PFD_DEPTH_DONTCARE );
106	if ( pfd->dwFlags & ~okayFlags ) {
107	crWarning( "wglChoosePixelFormat: only support flags=0x%x, but you gave me flags=0x%x", okayFlags, pfd->dwFlags );
108	return 0;
109	}
110
111	if ( pfd->iPixelType != PFD_TYPE_RGBA ) {
112	crError( "wglChoosePixelFormat: only support RGBA\n" );
113	}
114
115	if ( pfd->cColorBits > 32 \|\|
116	pfd->cRedBits > 8 \|\|
117	pfd->cGreenBits > 8 \|\|
118	pfd->cBlueBits > 8 \|\|
119	pfd->cAlphaBits > 8 ) {
120	crWarning( "wglChoosePixelFormat: too much color precision requested\n" );
121	}
122
123	if ( pfd->dwFlags & PFD_DOUBLEBUFFER )
124	desiredVisual \|= CR_DOUBLE_BIT;
125
126	if ( pfd->dwFlags & PFD_STEREO )
127	desiredVisual \|= CR_STEREO_BIT;
128
129	if ( pfd->cColorBits > 8)
130	desiredVisual \|= CR_RGB_BIT;
131
132	if ( pfd->cAccumBits > 0 \|\|
133	pfd->cAccumRedBits > 0 \|\|
134	pfd->cAccumGreenBits > 0 \|\|
135	pfd->cAccumBlueBits > 0 \|\|
136	pfd->cAccumAlphaBits > 0 ) {
137	crWarning( "wglChoosePixelFormat: asked for accumulation buffer, ignoring\n" );
138	}
139
140	if ( pfd->cAccumBits > 0 )
141	desiredVisual \|= CR_ACCUM_BIT;
142
143	if ( pfd->cDepthBits > 32 ) {
144	crError( "wglChoosePixelFormat; asked for too many depth bits\n" );
145	}
146
147	if ( pfd->cDepthBits > 0 )
148	desiredVisual \|= CR_DEPTH_BIT;
149
150	if ( pfd->cStencilBits > 8 ) {
151	crError( "wglChoosePixelFormat: asked for too many stencil bits\n" );
152	}
153
154	if ( pfd->cStencilBits > 0 )
155	desiredVisual \|= CR_STENCIL_BIT;
156
157	if ( pfd->cAuxBuffers > 0 ) {
158	crError( "wglChoosePixelFormat: asked for aux buffers\n" );
159	}
160
161	if ( pfd->iLayerType != PFD_MAIN_PLANE ) {
162	crError( "wglChoosePixelFormat: asked for a strange layer\n" );
163	}
164
165	return 1;
166	}
167
168	DECLEXPORT(BOOL) WINAPI wglSetPixelFormat_prox( HDC hdc, int pixelFormat,
169	CONST PIXELFORMATDESCRIPTOR *pdf )
170	{
171	CR_DDI_PROLOGUE();
172
173	if ( pixelFormat != 1 ) {
174	crError( "wglSetPixelFormat: pixelFormat=%d?\n", pixelFormat );
175	}
176
177	return 1;
178	}
179
180	DECLEXPORT(BOOL) WINAPI wglDeleteContext_prox( HGLRC hglrc )
181	{
182	CR_DDI_PROLOGUE();
183	stubDestroyContext( (unsigned long) hglrc );
184	return 1;
185	}
186
187	DECLEXPORT(BOOL) WINAPI wglMakeCurrent_prox( HDC hdc, HGLRC hglrc )
188	{
189	ContextInfo *context;
190	WindowInfo *window;
191	BOOL ret;
192
193	CR_DDI_PROLOGUE();
194
195	crHashtableLock(stub.windowTable);
196	crHashtableLock(stub.contextTable);
197
198	context = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc);
199	window = stubGetWindowInfo(hdc);
200
201	if (hglrc!=0 && !context)
202	{
203	crWarning("wglMakeCurrent got unexpected hglrc 0x%x", hglrc);
204	}
205
206	ret = stubMakeCurrent( window, context );
207
208	crHashtableUnlock(stub.contextTable);
209	crHashtableUnlock(stub.windowTable);
210
211	return ret;
212	}
213
214	DECLEXPORT(HGLRC) WINAPI wglGetCurrentContext_prox( void )
215	{
216	ContextInfo *context = stubGetCurrentContext();
217	CR_DDI_PROLOGUE();
218	return (HGLRC) (context ? context->id : 0);
219	}
220
221	DECLEXPORT(HDC) WINAPI wglGetCurrentDC_prox( void )
222	{
223	ContextInfo *context = stubGetCurrentContext();
224	CR_DDI_PROLOGUE();
225	if (context && context->currentDrawable)
226	return (HDC) context->currentDrawable->drawable;
227	else
228	return (HDC) NULL;
229	}
230
231	DECLEXPORT(int) WINAPI wglGetPixelFormat_prox( HDC hdc )
232	{
233	CR_DDI_PROLOGUE();
234	/* this is what we call our generic pixelformat, regardless of the HDC */
235	return 1;
236	}
237
238	DECLEXPORT(int) WINAPI wglDescribePixelFormat_prox( HDC hdc, int pixelFormat, UINT nBytes,
239	LPPIXELFORMATDESCRIPTOR pfd )
240	{
241	CR_DDI_PROLOGUE();
242
243	/* if ( pixelFormat != 1 ) {
244	* crError( "wglDescribePixelFormat: pixelFormat=%d?\n", pixelFormat );
245	* return 0;
246	* } */
247
248	if ( !pfd ) {
249	crWarning( "wglDescribePixelFormat: pfd=NULL\n" );
250	return 1; /* There's only one, baby */
251	}
252
253	if ( nBytes != sizeof(*pfd) ) {
254	crWarning( "wglDescribePixelFormat: nBytes=%u?\n", nBytes );
255	return 1; /* There's only one, baby */
256	}
257
258	pfd->nSize = sizeof(*pfd);
259	pfd->nVersion = 1;
260	pfd->dwFlags = ( PFD_DRAW_TO_WINDOW \|
261	PFD_SUPPORT_GDI \|
262	PFD_SUPPORT_OPENGL \|
263	PFD_DOUBLEBUFFER );
264	pfd->iPixelType = PFD_TYPE_RGBA;
265	pfd->cColorBits = 32;
266	pfd->cRedBits = 8;
267	pfd->cRedShift = 24;
268	pfd->cGreenBits = 8;
269	pfd->cGreenShift = 16;
270	pfd->cBlueBits = 8;
271	pfd->cBlueShift = 8;
272	pfd->cAlphaBits = 8;
273	pfd->cAlphaShift = 0;
274	pfd->cAccumBits = 0;
275	pfd->cAccumRedBits = 0;
276	pfd->cAccumGreenBits = 0;
277	pfd->cAccumBlueBits = 0;
278	pfd->cAccumAlphaBits = 0;
279	pfd->cDepthBits = 32;
280	pfd->cStencilBits = 8;
281	pfd->cAuxBuffers = 0;
282	pfd->iLayerType = PFD_MAIN_PLANE;
283	pfd->bReserved = 0;
284	pfd->dwLayerMask = 0;
285	pfd->dwVisibleMask = 0;
286	pfd->dwDamageMask = 0;
287
288	/* the max PFD index */
289	return 1;
290	}
291
292	DECLEXPORT(void) WINAPI VBoxCtxChromiumParameteriCR(HGLRC hglrc, GLenum param, GLint value)
293	{
294	ContextInfo *context;
295
296	CR_DDI_PROLOGUE();
297
298	// crHashtableLock(stub.windowTable);
299	crHashtableLock(stub.contextTable);
300
301	context = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc);
302
303	if (context)
304	{
305	stubCtxCheckCreate(context);
306	stubConChromiumParameteriCR(CR_CTX_CON(context), param, value);
307	}
308	else
309	crWarning("invalid context %#x", hglrc);
310
311	crHashtableUnlock(stub.contextTable);
312	// crHashtableUnlock(stub.windowTable);
313	}
314
315	DECLEXPORT(BOOL) WINAPI wglShareLists_prox( HGLRC hglrc1, HGLRC hglrc2 )
316	{
317	ContextInfo context1, context2;
318	GLint aSpuContexts[2];
319
320	CR_DDI_PROLOGUE();
321
322	// crHashtableLock(stub.windowTable);
323	crHashtableLock(stub.contextTable);
324
325	context1 = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc1);
326
327	if (!context1)
328	{
329	WARN(("invalid hglrc1"));
330	return FALSE;
331	}
332
333	stubCtxCheckCreate(context1);
334
335	context2 = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc2);
336
337	if (!context2)
338	{
339	WARN(("invalid hglrc2"));
340	return FALSE;
341	}
342
343	stubCtxCheckCreate(context2);
344
345	aSpuContexts[0] = context1->spuContext;
346	aSpuContexts[1] = context2->spuContext;
347
348	stubConChromiumParametervCR(CR_CTX_CON(context2), GL_SHARE_LISTS_CR, GL_INT, 2, aSpuContexts);
349
350	crHashtableUnlock(stub.contextTable);
351
352	return TRUE;
353	}
354
355	DECLEXPORT(HGLRC) WINAPI VBoxCreateContext( HDC hdc, struct VBOXUHGSMI *pHgsmi )
356	{
357	char *dpyName;
358	ContextInfo *context;
359
360	CR_DDI_PROLOGUE();
361
362	stubInit();
363
364	CRASSERT(stub.contextTable);
365
366	dpyName = crCalloc(MAX_DPY_NAME);
367	if (dpyName)
368	{
369	crMemset(dpyName, 0, MAX_DPY_NAME);
370	sprintf(dpyName, "%d", hdc);
371	}
372	#ifndef VBOX_CROGL_USE_VBITS_SUPERSET
373	if (stub.haveNativeOpenGL)
374	desiredVisual \|= ComputeVisBits( hdc );
375	#endif
376
377	context = stubNewContext(dpyName, desiredVisual, UNDECIDED, 0
378	#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
379	, pHgsmi
380	#else
381	, NULL
382	#endif
383	);
384	/* Not needed any more. */
385	crFree(dpyName);
386
387	if (!context)
388	return 0;
389
390	return (HGLRC) context->id;
391	}
392
393	DECLEXPORT(GLint) WINAPI VBoxGetWindowId( HDC hdc )
394	{
395	WindowInfo *window;
396	GLint winid = 0;
397
398	CR_DDI_PROLOGUE();
399
400	crHashtableLock(stub.windowTable);
401
402	window = stubGetWindowInfo(hdc);
403	if (!window)
404	{
405	crWarning("stubGetWindowInfo: window not found!");
406	goto end;
407	}
408	if (!window->spuWindow)
409	{
410	crWarning("stubGetWindowInfo: window is null!");
411	goto end;
412	}
413
414	winid = window->spuWindow;
415
416	end:
417	crHashtableUnlock(stub.windowTable);
418	return winid;
419	}
420
421	DECLEXPORT(GLint) WINAPI VBoxGetContextId( HGLRC hglrc )
422	{
423	ContextInfo *context;
424	GLint ctxid = 0;
425
426	CR_DDI_PROLOGUE();
427
428	// crHashtableLock(stub.windowTable);
429	crHashtableLock(stub.contextTable);
430
431	context = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc);
432	if (!context)
433	{
434	crWarning("crHashtableSearch: context not found!");
435	goto end;
436	}
437
438	if (context->type != CHROMIUM)
439	{
440	crWarning("unexpected context type %d", context->type);
441	goto end;
442	}
443
444	if (context->spuContext <= 0)
445	{
446	crWarning("no spuSontext defined");
447	goto end;
448	}
449
450	ctxid = context->spuContext;
451
452	end:
453	crHashtableUnlock(stub.contextTable);
454	return ctxid;
455	}
456
457
458	DECLEXPORT(HGLRC) WINAPI wglCreateContext_prox( HDC hdc )
459	{
460	return VBoxCreateContext(hdc, NULL);
461	}
462
463	DECLEXPORT(void) WINAPI VBoxFlushToHost ( HGLRC hglrc )
464	{
465	ContextInfo *context;
466
467	CR_DDI_PROLOGUE();
468
469	// crHashtableLock(stub.windowTable);
470	crHashtableLock(stub.contextTable);
471
472	context = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc);
473
474	if (context)
475	stubConFlush(CR_CTX_CON(context));
476	else
477	crWarning("invalid context %#x", hglrc);
478
479	crHashtableUnlock(stub.contextTable);
480	// crHashtableUnlock(stub.windowTable);
481	}
482
483	DECLEXPORT(BOOL) WINAPI
484	wglSwapBuffers_prox( HDC hdc )
485	{
486	WindowInfo *window = stubGetWindowInfo(hdc);
487	CR_DDI_PROLOGUE();
488	stubSwapBuffers( window, 0 );
489	return 1;
490	}
491
492	DECLEXPORT(BOOL) WINAPI wglCopyContext_prox( HGLRC src, HGLRC dst, UINT mask )
493	{
494	CR_DDI_PROLOGUE();
495	crWarning( "wglCopyContext: unsupported" );
496	return 0;
497	}
498
499	DECLEXPORT(HGLRC) WINAPI wglCreateLayerContext_prox( HDC hdc, int layerPlane )
500	{
501	CR_DDI_PROLOGUE();
502	stubInit();
503	crWarning( "wglCreateLayerContext: unsupported" );
504	return 0;
505	}
506
507	DECLEXPORT(PROC) WINAPI wglGetProcAddress_prox( LPCSTR name )
508	{
509	CR_DDI_PROLOGUE();
510	return (PROC) crGetProcAddress( name );
511	}
512
513	DECLEXPORT(BOOL) WINAPI wglUseFontBitmapsA_prox( HDC hdc, DWORD first, DWORD count, DWORD listBase )
514	{
515	CR_DDI_PROLOGUE();
516	crWarning( "wglUseFontBitmapsA: unsupported" );
517	return 0;
518	}
519
520	DECLEXPORT(BOOL) WINAPI wglUseFontBitmapsW_prox( HDC hdc, DWORD first, DWORD count, DWORD listBase )
521	{
522	CR_DDI_PROLOGUE();
523	crWarning( "wglUseFontBitmapsW: unsupported" );
524	return 0;
525	}
526
527	DECLEXPORT(BOOL) WINAPI wglDescribeLayerPlane_prox( HDC hdc, int pixelFormat, int layerPlane,
528	UINT nBytes, LPLAYERPLANEDESCRIPTOR lpd )
529	{
530	CR_DDI_PROLOGUE();
531	crWarning( "wglDescribeLayerPlane: unimplemented" );
532	return 0;
533	}
534
535	DECLEXPORT(int) WINAPI wglSetLayerPaletteEntries_prox( HDC hdc, int layerPlane, int start,
536	int entries, CONST COLORREF *cr )
537	{
538	CR_DDI_PROLOGUE();
539	crWarning( "wglSetLayerPaletteEntries: unsupported" );
540	return 0;
541	}
542
543	DECLEXPORT(int) WINAPI wglGetLayerPaletteEntries_prox( HDC hdc, int layerPlane, int start,
544	int entries, COLORREF *cr )
545	{
546	CR_DDI_PROLOGUE();
547	crWarning( "wglGetLayerPaletteEntries: unsupported" );
548	return 0;
549	}
550
551	DECLEXPORT(BOOL) WINAPI wglRealizeLayerPalette_prox( HDC hdc, int layerPlane, BOOL realize )
552	{
553	CR_DDI_PROLOGUE();
554	crWarning( "wglRealizeLayerPalette: unsupported" );
555	return 0;
556	}
557
558	DECLEXPORT(DWORD) WINAPI wglSwapMultipleBuffers_prox( UINT a, CONST void *b )
559	{
560	CR_DDI_PROLOGUE();
561	crWarning( "wglSwapMultipleBuffer: unsupported" );
562	return 0;
563	}
564
565	DECLEXPORT(BOOL) WINAPI wglUseFontOutlinesA_prox( HDC hdc, DWORD first, DWORD count, DWORD listBase,
566	FLOAT deviation, FLOAT extrusion, int format,
567	LPGLYPHMETRICSFLOAT gmf )
568	{
569	CR_DDI_PROLOGUE();
570	crWarning( "wglUseFontOutlinesA: unsupported" );
571	return 0;
572	}
573
574	DECLEXPORT(BOOL) WINAPI wglUseFontOutlinesW_prox( HDC hdc, DWORD first, DWORD count, DWORD listBase,
575	FLOAT deviation, FLOAT extrusion, int format,
576	LPGLYPHMETRICSFLOAT gmf )
577	{
578	CR_DDI_PROLOGUE();
579	crWarning( "wglUseFontOutlinesW: unsupported" );
580	return 0;
581	}
582
583	DECLEXPORT(BOOL) WINAPI wglSwapLayerBuffers_prox( HDC hdc, UINT planes )
584	{
585	CR_DDI_PROLOGUE();
586	if (planes == WGL_SWAP_MAIN_PLANE)
587	{
588	return wglSwapBuffers_prox(hdc);
589	}
590	else
591	{
592	crWarning( "wglSwapLayerBuffers: unsupported" );
593	return 0;
594	}
595	}
596
597	DECLEXPORT(BOOL) WINAPI wglChoosePixelFormatEXT_prox
598	(HDC hdc, const int piAttributes, const FLOAT pfAttributes, UINT nMaxFormats, int piFormats, UINT nNumFormats)
599	{
600	int *pi;
601	int wants_rgb = 0;
602
603	CR_DDI_PROLOGUE();
604
605	stubInit();
606
607	/* TODO : Need to check pfAttributes too ! */
608
609	for ( pi = (int )piAttributes; pi != 0; pi++ )
610	{
611	switch ( *pi )
612	{
613	case WGL_COLOR_BITS_EXT:
614	if (pi[1] > 8)
615	wants_rgb = 1;
616	pi++;
617	break;
618
619	case WGL_RED_BITS_EXT:
620	case WGL_GREEN_BITS_EXT:
621	case WGL_BLUE_BITS_EXT:
622	if (pi[1] > 3)
623	wants_rgb = 1;
624	pi++;
625	break;
626
627	case WGL_ACCUM_ALPHA_BITS_EXT:
628	case WGL_ALPHA_BITS_EXT:
629	if (pi[1] > 0)
630	desiredVisual \|= CR_ALPHA_BIT;
631	pi++;
632	break;
633
634	case WGL_DOUBLE_BUFFER_EXT:
635	if (pi[1] > 0)
636	desiredVisual \|= CR_DOUBLE_BIT;
637	pi++;
638	break;
639
640	case WGL_STEREO_EXT:
641	if (pi[1] > 0)
642	{
643	/* @todo: this is disabled due to VSG Open Inventor interop issues
644	* it does not make any sense actually since reporting this
645	* as well as choosing a pixel format with this cap would not do anything
646	* since ICD stuff has its own pixelformat state var */
647	crWarning("WGL_STEREO_EXT not supporteed!");
648	return 0;
649	// desiredVisual \|= CR_STEREO_BIT;
650	}
651	pi++;
652	break;
653
654	case WGL_DEPTH_BITS_EXT:
655	if (pi[1] > 0)
656	desiredVisual \|= CR_DEPTH_BIT;
657	pi++;
658	break;
659
660	case WGL_STENCIL_BITS_EXT:
661	if (pi[1] > 0)
662	desiredVisual \|= CR_STENCIL_BIT;
663	pi++;
664	break;
665
666	case WGL_ACCUM_RED_BITS_EXT:
667	case WGL_ACCUM_GREEN_BITS_EXT:
668	case WGL_ACCUM_BLUE_BITS_EXT:
669	if (pi[1] > 0)
670	desiredVisual \|= CR_ACCUM_BIT;
671	pi++;
672	break;
673
674	case WGL_SAMPLE_BUFFERS_EXT:
675	case WGL_SAMPLES_EXT:
676	if (pi[1] > 0)
677	{
678	/* @todo: this is disabled due to VSG Open Inventor interop issues
679	* it does not make any sense actually since reporting this
680	* as well as choosing a pixel format with this cap would not do anything
681	* since ICD stuff has its own pixelformat state var */
682	crWarning("WGL_SAMPLE_BUFFERS_EXT & WGL_SAMPLES_EXT not supporteed!");
683	return 0;
684	// desiredVisual \|= CR_MULTISAMPLE_BIT;
685	}
686	pi++;
687	break;
688
689	case WGL_SUPPORT_OPENGL_ARB:
690	case WGL_DRAW_TO_WINDOW_ARB:
691	case WGL_ACCELERATION_ARB:
692	pi++;
693	break;
694
695	case WGL_PIXEL_TYPE_ARB:
696	if(pi[1]!=WGL_TYPE_RGBA_ARB)
697	{
698	crWarning("WGL_PIXEL_TYPE 0x%x not supported!", pi[1]);
699	return 0;
700	}
701	pi++;
702	break;
703
704	default:
705	crWarning( "wglChoosePixelFormatEXT: bad pi=0x%x", *pi );
706	return 0;
707	}
708	}
709
710	if (nNumFormats) *nNumFormats = 1;
711	if (nMaxFormats>0 && piFormats)
712	{
713	piFormats[0] = 1;
714	}
715
716	return 1;
717	}
718
719	DECLEXPORT(BOOL) WINAPI wglGetPixelFormatAttribivEXT_prox
720	(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int piAttributes, int pValues)
721	{
722	UINT i;
723
724	CR_DDI_PROLOGUE();
725
726	if (!pValues \|\| !piAttributes) return 0;
727
728	if ((nAttributes!=1) \|\| (piAttributes && piAttributes[0]!=WGL_NUMBER_PIXEL_FORMATS_ARB))
729	{
730	if (iPixelFormat!=1)
731	{
732	crDebug("wglGetPixelFormatAttribivARB: bad pf:%i", iPixelFormat);
733	return 0;
734	}
735	}
736
737	for (i=0; i<nAttributes; ++i)
738	{
739	switch (piAttributes[i])
740	{
741	case WGL_NUMBER_PIXEL_FORMATS_ARB:
742	pValues[i] = 1;
743	break;
744	case WGL_DRAW_TO_WINDOW_ARB:
745	case WGL_SUPPORT_OPENGL_ARB:
746	case WGL_DOUBLE_BUFFER_ARB:
747	pValues[i] = 1;
748	break;
749	case WGL_STEREO_ARB:
750	/* @todo: this is disabled due to VSG Open Inventor interop issues
751	* it does not make any sense actually since reporting this
752	* as well as choosing a pixel format with this cap would not do anything
753	* since ICD stuff has its own pixelformat state var */
754	pValues[i] = 0;
755	break;
756	case WGL_DRAW_TO_BITMAP_ARB:
757	case WGL_NEED_PALETTE_ARB:
758	case WGL_NEED_SYSTEM_PALETTE_ARB:
759	case WGL_SWAP_LAYER_BUFFERS_ARB:
760	case WGL_NUMBER_OVERLAYS_ARB:
761	case WGL_NUMBER_UNDERLAYS_ARB:
762	case WGL_TRANSPARENT_ARB:
763	case WGL_TRANSPARENT_RED_VALUE_ARB:
764	case WGL_TRANSPARENT_GREEN_VALUE_ARB:
765	case WGL_TRANSPARENT_BLUE_VALUE_ARB:
766	case WGL_TRANSPARENT_ALPHA_VALUE_ARB:
767	case WGL_TRANSPARENT_INDEX_VALUE_ARB:
768	case WGL_SHARE_DEPTH_ARB:
769	case WGL_SHARE_STENCIL_ARB:
770	case WGL_SHARE_ACCUM_ARB:
771	case WGL_SUPPORT_GDI_ARB:
772	pValues[i] = 0;
773	break;
774	case WGL_ACCELERATION_ARB:
775	pValues[i] = WGL_FULL_ACCELERATION_ARB;
776	break;
777	case WGL_SWAP_METHOD_ARB:
778	pValues[i] = WGL_SWAP_UNDEFINED_ARB;
779	break;
780	case WGL_PIXEL_TYPE_ARB:
781	pValues[i] = WGL_TYPE_RGBA_ARB;
782	break;
783	case WGL_COLOR_BITS_ARB:
784	pValues[i] = 32;
785	break;
786	case WGL_RED_BITS_ARB:
787	case WGL_GREEN_BITS_ARB:
788	case WGL_BLUE_BITS_ARB:
789	case WGL_ALPHA_BITS_ARB:
790	pValues[i] = 8;
791	break;
792	case WGL_RED_SHIFT_ARB:
793	pValues[i] = 24;
794	break;
795	case WGL_GREEN_SHIFT_ARB:
796	pValues[i] = 16;
797	break;
798	case WGL_BLUE_SHIFT_ARB:
799	pValues[i] = 8;
800	break;
801	case WGL_ALPHA_SHIFT_ARB:
802	pValues[i] = 0;
803	break;
804	case WGL_ACCUM_BITS_ARB:
805	pValues[i] = 0;
806	break;
807	case WGL_ACCUM_RED_BITS_ARB:
808	pValues[i] = 0;
809	break;
810	case WGL_ACCUM_GREEN_BITS_ARB:
811	pValues[i] = 0;
812	break;
813	case WGL_ACCUM_BLUE_BITS_ARB:
814	pValues[i] = 0;
815	break;
816	case WGL_ACCUM_ALPHA_BITS_ARB:
817	pValues[i] = 0;
818	break;
819	case WGL_DEPTH_BITS_ARB:
820	pValues[i] = 32;
821	break;
822	case WGL_STENCIL_BITS_ARB:
823	pValues[i] = 8;
824	break;
825	case WGL_AUX_BUFFERS_ARB:
826	pValues[i] = 0;
827	break;
828	case WGL_SAMPLE_BUFFERS_EXT:
829	/* @todo: this is disabled due to VSG Open Inventor interop issues
830	* it does not make any sense actually since reporting this
831	* as well as choosing a pixel format with this cap would not do anything
832	* since ICD stuff has its own pixelformat state var */
833	pValues[i] = 0;
834	break;
835	case WGL_SAMPLES_EXT:
836	/* @todo: this is disabled due to VSG Open Inventor interop issues
837	* it does not make any sense actually since reporting this
838	* as well as choosing a pixel format with this cap would not do anything
839	* since ICD stuff has its own pixelformat state var */
840	pValues[i] = 0;
841	break;
842	case 0x202d: /* <- WGL_DRAW_TO_PBUFFER_ARB this is to make VSG Open Inventor happy */
843	pValues[i] = 0;
844	break;
845	default:
846	crWarning("wglGetPixelFormatAttribivARB: bad attrib=0x%x", piAttributes[i]);
847	return 0;
848	}
849	}
850
851	return 1;
852	}
853
854	DECLEXPORT(BOOL) WINAPI wglGetPixelFormatAttribfvEXT_prox
855	(HDC hdc, int iPixelFormat, int iLayerPlane, UINT nAttributes, int piAttributes, float pValues)
856	{
857	UINT i;
858
859	CR_DDI_PROLOGUE();
860
861	if (!pValues \|\| !piAttributes) return 0;
862
863	if ((nAttributes!=1) \|\| (piAttributes && piAttributes[0]!=WGL_NUMBER_PIXEL_FORMATS_ARB))
864	{
865	if (iPixelFormat!=1)
866	{
867	crDebug("wglGetPixelFormatAttribivARB: bad pf:%i", iPixelFormat);
868	return 0;
869	}
870	}
871
872	for (i=0; i<nAttributes; ++i)
873	{
874	switch (piAttributes[i])
875	{
876	case WGL_NUMBER_PIXEL_FORMATS_ARB:
877	pValues[i] = 1.f;
878	break;
879	case WGL_DRAW_TO_WINDOW_ARB:
880	case WGL_SUPPORT_OPENGL_ARB:
881	case WGL_DOUBLE_BUFFER_ARB:
882	pValues[i] = 1.f;
883	break;
884	case WGL_STEREO_ARB:
885	/* @todo: this is disabled due to VSG Open Inventor interop issues
886	* it does not make any sense actually since reporting this
887	* as well as choosing a pixel format with this cap would not do anything
888	* since ICD stuff has its own pixelformat state var */
889	pValues[i] = 0.f;
890	break;
891	case WGL_DRAW_TO_BITMAP_ARB:
892	case WGL_NEED_PALETTE_ARB:
893	case WGL_NEED_SYSTEM_PALETTE_ARB:
894	case WGL_SWAP_LAYER_BUFFERS_ARB:
895	case WGL_NUMBER_OVERLAYS_ARB:
896	case WGL_NUMBER_UNDERLAYS_ARB:
897	case WGL_TRANSPARENT_ARB:
898	case WGL_TRANSPARENT_RED_VALUE_ARB:
899	case WGL_TRANSPARENT_GREEN_VALUE_ARB:
900	case WGL_TRANSPARENT_BLUE_VALUE_ARB:
901	case WGL_TRANSPARENT_ALPHA_VALUE_ARB:
902	case WGL_TRANSPARENT_INDEX_VALUE_ARB:
903	case WGL_SHARE_DEPTH_ARB:
904	case WGL_SHARE_STENCIL_ARB:
905	case WGL_SHARE_ACCUM_ARB:
906	case WGL_SUPPORT_GDI_ARB:
907	pValues[i] = 0.f;
908	break;
909	case WGL_ACCELERATION_ARB:
910	pValues[i] = WGL_FULL_ACCELERATION_ARB;
911	break;
912	case WGL_SWAP_METHOD_ARB:
913	pValues[i] = WGL_SWAP_UNDEFINED_ARB;
914	break;
915	case WGL_PIXEL_TYPE_ARB:
916	pValues[i] = WGL_TYPE_RGBA_ARB;
917	break;
918	case WGL_COLOR_BITS_ARB:
919	pValues[i] = 32.f;
920	break;
921	case WGL_RED_BITS_ARB:
922	case WGL_GREEN_BITS_ARB:
923	case WGL_BLUE_BITS_ARB:
924	case WGL_ALPHA_BITS_ARB:
925	pValues[i] = 8.f;
926	break;
927	case WGL_RED_SHIFT_ARB:
928	pValues[i] = 24.f;
929	break;
930	case WGL_GREEN_SHIFT_ARB:
931	pValues[i] = 16.f;
932	break;
933	case WGL_BLUE_SHIFT_ARB:
934	pValues[i] = 8.f;
935	break;
936	case WGL_ALPHA_SHIFT_ARB:
937	pValues[i] = 0.f;
938	break;
939	case WGL_ACCUM_BITS_ARB:
940	pValues[i] = 0.f;
941	break;
942	case WGL_ACCUM_RED_BITS_ARB:
943	pValues[i] = 0.f;
944	break;
945	case WGL_ACCUM_GREEN_BITS_ARB:
946	pValues[i] = 0.f;
947	break;
948	case WGL_ACCUM_BLUE_BITS_ARB:
949	pValues[i] = 0.f;
950	break;
951	case WGL_ACCUM_ALPHA_BITS_ARB:
952	pValues[i] = 0.f;
953	break;
954	case WGL_DEPTH_BITS_ARB:
955	pValues[i] = 32.f;
956	break;
957	case WGL_STENCIL_BITS_ARB:
958	pValues[i] = 8.f;
959	break;
960	case WGL_AUX_BUFFERS_ARB:
961	pValues[i] = 0.f;
962	break;
963	case WGL_SAMPLE_BUFFERS_EXT:
964	/* @todo: this is disabled due to VSG Open Inventor interop issues
965	* it does not make any sense actually since reporting this
966	* as well as choosing a pixel format with this cap would not do anything
967	* since ICD stuff has its own pixelformat state var */
968	pValues[i] = 0.f;
969	break;
970	case WGL_SAMPLES_EXT:
971	/* @todo: this is disabled due to VSG Open Inventor interop issues
972	* it does not make any sense actually since reporting this
973	* as well as choosing a pixel format with this cap would not do anything
974	* since ICD stuff has its own pixelformat state var */
975	pValues[i] = 0.f;
976	break;
977	case 0x202d: /* <- WGL_DRAW_TO_PBUFFER_ARB this is to make VSG Open Inventor happy */
978	pValues[i] = 0.f;
979	break;
980	default:
981	crWarning("wglGetPixelFormatAttribivARB: bad attrib=0x%x", piAttributes[i]);
982	return 0;
983	}
984	}
985
986	return 1;
987	}
988
989	DECLEXPORT(BOOL) WINAPI wglSwapIntervalEXT_prox(int interval)
990	{
991	CR_DDI_PROLOGUE();
992	return TRUE;
993	}
994
995	DECLEXPORT(int) WINAPI wglGetSwapIntervalEXT_prox()
996	{
997	CR_DDI_PROLOGUE();
998	return 1;
999	}
1000
1001	static GLubyte *gsz_wgl_extensions = "WGL_EXT_pixel_format WGL_ARB_pixel_format WGL_ARB_multisample";
1002
1003	DECLEXPORT(const GLubyte *) WINAPI wglGetExtensionsStringEXT_prox()
1004	{
1005	CR_DDI_PROLOGUE();
1006	return gsz_wgl_extensions;
1007	}
1008
1009	DECLEXPORT(const GLubyte *) WINAPI wglGetExtensionsStringARB_prox(HDC hdc)
1010	{
1011	CR_DDI_PROLOGUE();
1012	(void) hdc;
1013
1014	return gsz_wgl_extensions;
1015	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Additions/common/crOpenGL/wgl.c@ 56335

Download in other formats: