VirtualBox

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

Last change on this file since 58029 was 56294, checked in by vboxsync, 10 years ago

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