VirtualBox

source: vbox/trunk/src/VBox/Additions/common/crOpenGL/icd_drv.c@ 68080

Last change on this file since 68080 was 66826, checked in by vboxsync, 8 years ago

Additions: Adjustments for Visual C++ v12 / Visual Studio 2013. New warnings and sal_supp.h conflict.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 10.6 KB
Line 
1/* $Id: icd_drv.c 66826 2017-05-08 16:53:25Z vboxsync $ */
2/** @file
3 * VBox OpenGL windows ICD driver functions
4 */
5
6/*
7 * Copyright (C) 2006-2016 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18#include "cr_error.h"
19#include "icd_drv.h"
20#include "cr_gl.h"
21#include "stub.h"
22#include "cr_mem.h"
23
24#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
25# include <VBoxCrHgsmi.h>
26# include <VBoxUhgsmi.h>
27#endif
28
29#include <iprt/win/windows.h>
30
31//TODO: consider
32/* We can modify chronium dispatch table functions order to match the one required by ICD,
33 * but it'd render us incompatible with other chromium SPUs and require more changes.
34 * In current state, we can use unmodified binary chromium SPUs. Question is do we need it?
35*/
36
37#define GL_FUNC(func) cr_gl##func
38
39static ICDTABLE icdTable = { 336, {
40#define ICD_ENTRY(func) (PROC)GL_FUNC(func),
41#include "VBoxICDList.h"
42#undef ICD_ENTRY
43} };
44
45/* Currently host part will misbehave re-creating context with proper visual bits
46 * if contexts with alternative visual bits is requested.
47 * For now we just report a superset of all visual bits to avoid that.
48 * Better to it on the host side as well?
49 * We could also implement properly multiple pixel formats,
50 * which should be done by implementing offscreen rendering or multiple host contexts.
51 * */
52#define VBOX_CROGL_USE_VBITS_SUPERSET
53
54#ifdef VBOX_CROGL_USE_VBITS_SUPERSET
55static GLuint desiredVisual = CR_RGB_BIT | CR_ALPHA_BIT | CR_DEPTH_BIT | CR_STENCIL_BIT | CR_ACCUM_BIT | CR_DOUBLE_BIT;
56#else
57static GLuint desiredVisual = CR_RGB_BIT;
58#endif
59
60#ifndef VBOX_CROGL_USE_VBITS_SUPERSET
61/**
62 * Compute a mask of CR_*_BIT flags which reflects the attributes of
63 * the pixel format of the given hdc.
64 */
65static GLuint ComputeVisBits( HDC hdc )
66{
67 PIXELFORMATDESCRIPTOR pfd;
68 int iPixelFormat;
69 GLuint b = 0;
70
71 iPixelFormat = GetPixelFormat( hdc );
72
73 DescribePixelFormat( hdc, iPixelFormat, sizeof(pfd), &pfd );
74
75 if (pfd.cDepthBits > 0)
76 b |= CR_DEPTH_BIT;
77 if (pfd.cAccumBits > 0)
78 b |= CR_ACCUM_BIT;
79 if (pfd.cColorBits > 8)
80 b |= CR_RGB_BIT;
81 if (pfd.cStencilBits > 0)
82 b |= CR_STENCIL_BIT;
83 if (pfd.cAlphaBits > 0)
84 b |= CR_ALPHA_BIT;
85 if (pfd.dwFlags & PFD_DOUBLEBUFFER)
86 b |= CR_DOUBLE_BIT;
87 if (pfd.dwFlags & PFD_STEREO)
88 b |= CR_STEREO_BIT;
89
90 return b;
91}
92#endif
93
94void APIENTRY DrvReleaseContext(HGLRC hglrc)
95{
96 CR_DDI_PROLOGUE();
97 /*crDebug( "DrvReleaseContext(0x%x) called", hglrc );*/
98 stubMakeCurrent( NULL, NULL );
99}
100
101BOOL APIENTRY DrvValidateVersion(DWORD version)
102{
103 CR_DDI_PROLOGUE();
104 if (stubInit()) {
105 crDebug("DrvValidateVersion %x -> TRUE\n", version);
106 return TRUE;
107 }
108
109 crDebug("DrvValidateVersion %x -> FALSE, going to use system default opengl32.dll\n", version);
110 return FALSE;
111}
112
113//we're not going to change icdTable at runtime, so callback is unused
114PICDTABLE APIENTRY DrvSetContext(HDC hdc, HGLRC hglrc, void *callback)
115{
116 ContextInfo *pContext;
117 WindowInfo *pWindowInfo;
118 BOOL ret = false;
119
120 CR_DDI_PROLOGUE();
121
122 (void) (callback);
123
124 crHashtableLock(stub.windowTable);
125 crHashtableLock(stub.contextTable);
126
127 pContext = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc);
128 if (pContext)
129 {
130 pWindowInfo = stubGetWindowInfo(hdc);
131 if (pWindowInfo)
132 ret = stubMakeCurrent(pWindowInfo, pContext);
133 else
134 crError("no window info available.");
135 }
136 else
137 crError("No context found.");
138
139 crHashtableUnlock(stub.contextTable);
140 crHashtableUnlock(stub.windowTable);
141
142 return ret ? &icdTable : NULL;
143}
144
145BOOL APIENTRY DrvSetPixelFormat(HDC hdc, int iPixelFormat)
146{
147 CR_DDI_PROLOGUE();
148 crDebug( "DrvSetPixelFormat(0x%x, %i) called.", hdc, iPixelFormat );
149
150 if ( (iPixelFormat<1) || (iPixelFormat>2) ) {
151 crError( "wglSetPixelFormat: iPixelFormat=%d?", iPixelFormat );
152 }
153
154 return 1;
155}
156
157HGLRC APIENTRY DrvCreateContext(HDC hdc)
158{
159 char dpyName[MAX_DPY_NAME];
160 ContextInfo *context;
161#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
162 PVBOXUHGSMI pHgsmi = NULL;
163#endif
164
165 CR_DDI_PROLOGUE();
166
167 crDebug( "DrvCreateContext(0x%x) called.", hdc);
168
169 stubInit();
170
171 CRASSERT(stub.contextTable);
172
173 sprintf(dpyName, "%p", hdc);
174#ifndef VBOX_CROGL_USE_VBITS_SUPERSET
175 if (stub.haveNativeOpenGL)
176 desiredVisual |= ComputeVisBits( hdc );
177#endif
178
179#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
180 pHgsmi = VBoxCrHgsmiCreate();
181#endif
182
183 context = stubNewContext(dpyName, desiredVisual, UNDECIDED, 0
184#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
185 , pHgsmi
186#endif
187 );
188 if (!context)
189 return 0;
190
191 return (HGLRC) context->id;
192}
193
194HGLRC APIENTRY DrvCreateLayerContext(HDC hdc, int iLayerPlane)
195{
196 CR_DDI_PROLOGUE();
197 crDebug( "DrvCreateLayerContext(0x%x, %i) called.", hdc, iLayerPlane);
198 //We don't support more than 1 layers.
199 if (iLayerPlane == 0) {
200 return DrvCreateContext(hdc);
201 } else {
202 crError( "DrvCreateLayerContext (%x,%x): unsupported", hdc, iLayerPlane);
203 return NULL;
204 }
205
206}
207
208BOOL APIENTRY DrvDescribeLayerPlane(HDC hdc,int iPixelFormat,
209 int iLayerPlane, UINT nBytes,
210 LPLAYERPLANEDESCRIPTOR plpd)
211{
212 CR_DDI_PROLOGUE();
213 crWarning( "DrvDescribeLayerPlane: unimplemented" );
214 CRASSERT(false);
215 return 0;
216}
217
218int APIENTRY DrvGetLayerPaletteEntries(HDC hdc, int iLayerPlane,
219 int iStart, int cEntries,
220 COLORREF *pcr)
221{
222 CR_DDI_PROLOGUE();
223 crWarning( "DrvGetLayerPaletteEntries: unsupported" );
224 CRASSERT(false);
225 return 0;
226}
227
228int APIENTRY DrvDescribePixelFormat(HDC hdc, int iPixelFormat, UINT nBytes, LPPIXELFORMATDESCRIPTOR pfd)
229{
230 CR_DDI_PROLOGUE();
231 if ( !pfd ) {
232 return 2;
233 }
234
235 if ( nBytes != sizeof(*pfd) ) {
236 crWarning( "DrvDescribePixelFormat: nBytes=%u?", nBytes );
237 return 2;
238 }
239
240 if (iPixelFormat==1)
241 {
242 crMemZero(pfd, sizeof(*pfd));
243
244 pfd->nSize = sizeof(*pfd);
245 pfd->nVersion = 1;
246 pfd->dwFlags = (PFD_DRAW_TO_WINDOW |
247 PFD_SUPPORT_OPENGL |
248 PFD_DOUBLEBUFFER);
249
250 pfd->dwFlags |= 0x8000; /* <- Needed for VSG Open Inventor to be happy */
251
252 pfd->iPixelType = PFD_TYPE_RGBA;
253 pfd->cColorBits = 32;
254 pfd->cRedBits = 8;
255 pfd->cRedShift = 24;
256 pfd->cGreenBits = 8;
257 pfd->cGreenShift = 16;
258 pfd->cBlueBits = 8;
259 pfd->cBlueShift = 8;
260 pfd->cAlphaBits = 8;
261 pfd->cAlphaShift = 0;
262 pfd->cAccumBits = 0;
263 pfd->cAccumRedBits = 0;
264 pfd->cAccumGreenBits = 0;
265 pfd->cAccumBlueBits = 0;
266 pfd->cAccumAlphaBits = 0;
267 pfd->cDepthBits = 32;
268 pfd->cStencilBits = 8;
269 pfd->cAuxBuffers = 0;
270 pfd->iLayerType = PFD_MAIN_PLANE;
271 pfd->bReserved = 0;
272 pfd->dwLayerMask = 0;
273 pfd->dwVisibleMask = 0;
274 pfd->dwDamageMask = 0;
275 }
276 else
277 {
278 crMemZero(pfd, sizeof(*pfd));
279 pfd->nVersion = 1;
280 pfd->dwFlags = (PFD_DRAW_TO_WINDOW|
281 PFD_SUPPORT_OPENGL);
282
283 pfd->iPixelType = PFD_TYPE_RGBA;
284 pfd->cColorBits = 32;
285 pfd->cRedBits = 8;
286 pfd->cRedShift = 16;
287 pfd->cGreenBits = 8;
288 pfd->cGreenShift = 8;
289 pfd->cBlueBits = 8;
290 pfd->cBlueShift = 0;
291 pfd->cAlphaBits = 0;
292 pfd->cAlphaShift = 0;
293 pfd->cAccumBits = 64;
294 pfd->cAccumRedBits = 16;
295 pfd->cAccumGreenBits = 16;
296 pfd->cAccumBlueBits = 16;
297 pfd->cAccumAlphaBits = 0;
298 pfd->cDepthBits = 16;
299 pfd->cStencilBits = 8;
300 pfd->cAuxBuffers = 0;
301 pfd->iLayerType = PFD_MAIN_PLANE;
302 pfd->bReserved = 0;
303 pfd->dwLayerMask = 0;
304 pfd->dwVisibleMask = 0;
305 pfd->dwDamageMask = 0;
306 }
307
308 /* the max PFD index */
309 return 2;
310}
311
312BOOL APIENTRY DrvDeleteContext(HGLRC hglrc)
313{
314#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
315 ContextInfo *pContext;
316 PVBOXUHGSMI pHgsmi = NULL;
317#endif
318
319 CR_DDI_PROLOGUE();
320 crDebug( "DrvDeleteContext(0x%x) called", hglrc );
321
322#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
323 crHashtableLock(stub.contextTable);
324
325 pContext = (ContextInfo *) crHashtableSearch(stub.contextTable, (unsigned long) hglrc);
326 if (pContext)
327 pHgsmi = pContext->pHgsmi;
328
329 crHashtableUnlock(stub.contextTable);
330#endif
331
332 stubDestroyContext( (unsigned long) hglrc );
333
334#if defined(VBOX_WITH_CRHGSMI) && defined(IN_GUEST)
335 if (pHgsmi)
336 VBoxCrHgsmiDestroy(pHgsmi);
337#endif
338
339 return true;
340}
341
342BOOL APIENTRY DrvCopyContext(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask)
343{
344 CR_DDI_PROLOGUE();
345 crWarning( "DrvCopyContext: unsupported" );
346 return 0;
347}
348
349DECLEXPORT(BOOL) WINAPI wglShareLists_prox( HGLRC hglrc1, HGLRC hglrc2 );
350
351BOOL APIENTRY DrvShareLists(HGLRC hglrc1, HGLRC hglrc2)
352{
353 return wglShareLists_prox(hglrc1, hglrc2);
354}
355
356int APIENTRY DrvSetLayerPaletteEntries(HDC hdc, int iLayerPlane,
357 int iStart, int cEntries,
358 CONST COLORREF *pcr)
359{
360 CR_DDI_PROLOGUE();
361 crWarning( "DrvSetLayerPaletteEntries: unsupported" );
362 return 0;
363}
364
365
366BOOL APIENTRY DrvRealizeLayerPalette(HDC hdc, int iLayerPlane, BOOL bRealize)
367{
368 CR_DDI_PROLOGUE();
369 crWarning( "DrvRealizeLayerPalette: unsupported" );
370 return 0;
371}
372
373BOOL APIENTRY DrvSwapLayerBuffers(HDC hdc, UINT fuPlanes)
374{
375 CR_DDI_PROLOGUE();
376 if (fuPlanes == 1)
377 {
378 return DrvSwapBuffers(hdc);
379 }
380 else
381 {
382 crWarning( "DrvSwapLayerBuffers: unsupported" );
383 CRASSERT(false);
384 return 0;
385 }
386}
387
388BOOL APIENTRY DrvSwapBuffers(HDC hdc)
389{
390 WindowInfo *window;
391
392 CR_DDI_PROLOGUE();
393 /*crDebug( "DrvSwapBuffers(0x%x) called", hdc );*/
394 window = stubGetWindowInfo(hdc);
395 stubSwapBuffers( window, 0 );
396 return 1;
397}
398
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette