VirtualBox

source: vbox/trunk/src/VBox/HostServices/SharedOpenGL/gllindrv.cpp@ 13026

Last change on this file since 13026 was 11430, checked in by vboxsync, 16 years ago

some obviously missing \n at end of a Log() string
  • Property svn:eol-style set to native
File size: 20.2 KB
Line 
1/** @file
2 *
3 * VBox OpenGL
4 *
5 * Simple buffered OpenGL functions
6 *
7 * Contributed by: Alexander Eichner
8 */
9
10/*
11 * Copyright (C) 2006-2007 Sun Microsystems, Inc.
12 *
13 * This file is part of VirtualBox Open Source Edition (OSE), as
14 * available from http://www.virtualbox.org. This file is free software;
15 * you can redistribute it and/or modify it under the terms of the GNU
16 * General Public License (GPL) as published by the Free Software
17 * Foundation, in version 2 as it comes in the "COPYING" file of the
18 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20 *
21 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
22 * Clara, CA 95054 USA or visit http://www.sun.com if you need
23 * additional information or have any questions.
24 */
25#define GLX_GLXEXT_PROTOTYPES
26
27#include "vboxgl.h"
28#define LOG_GROUP LOG_GROUP_SHARED_OPENGL
29#include <VBox/log.h>
30#include <string.h>
31#include <stdio.h>
32#include <GL/gl.h>
33#include <GL/glx.h>
34#include <GL/glxext.h>
35
36
37/* X11 server connection for all OpenGL clients.
38 * Neccessary because Mesa and DRI cannot handle more than one
39 * connection per thread (only hardware acceleration, software rendering
40 * runs fine with more than one connection).
41 * Would crash in vboxglDisconnect if on every vboxglConnect
42 * a new Display is created */
43Display *glXDisplay = NULL;
44
45static Bool WaitForNotify( Display *dpy, XEvent *event, XPointer arg ) {
46 return (event->type == MapNotify) && (event->xmap.window == (Window) arg);
47}
48
49/* from http://www.mesa3d.org/brianp/sig97/exten.htm */
50GLboolean vboxglCheckExtension(Display *dpy, int screenNum, const char *extName )
51{
52 /*
53 ** Search for extName in the extensions string. Use of strstr()
54 ** is not sufficient because extension names can be prefixes of
55 ** other extension names. Could use strtok() but the constant
56 ** string returned by glGetString can be in read-only memory.
57 */
58 char *p = (char *) glXQueryExtensionsString(dpy, screenNum);
59 char *end;
60 int extNameLen;
61
62 extNameLen = strlen(extName);
63 end = p + strlen(p);
64
65 while (p < end) {
66 int n = strcspn(p, " ");
67 if ((extNameLen == n) && (strncmp(extName, p, n) == 0)) {
68 return GL_TRUE;
69 }
70 p += (n + 1);
71 }
72 return GL_FALSE;
73}
74
75/**
76 * Global init of VBox OpenGL
77 *
78 * @returns VBox error code
79 */
80int vboxglGlobalInit()
81{
82 Log(("vboxglGlobalInit\n"));
83
84 /*vboxInitOpenGLExtensions();*/
85 return VINF_SUCCESS;
86}
87
88/**
89 * Global deinit of VBox OpenGL
90 *
91 * @returns VBox error code
92 */
93int vboxglGlobalUnload()
94{
95 Log(("vboxglGlobalUnload\n"));
96
97 if (glXDisplay)
98 XCloseDisplay(glXDisplay);
99
100 return VINF_SUCCESS;
101}
102
103/**
104 * Enable OpenGL
105 *
106 * @returns VBox error code
107 * @param pClient Client context
108 */
109int vboxglEnableOpenGL(PVBOXOGLCTX pClient)
110{
111 static int attribs[] = {
112 GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT,
113 GLX_RENDER_TYPE, GLX_RGBA_BIT,
114 GLX_DOUBLEBUFFER, GL_TRUE, /* Request a double-buffered color buffer with */
115 GLX_RED_SIZE, 1, /* the maximum number of bits per component */
116 GLX_GREEN_SIZE, 1,
117 GLX_BLUE_SIZE, 1,
118 None
119 };
120 int screen_num;
121 XSetWindowAttributes attr;
122 unsigned long mask;
123 int returnedFBConfigs;
124
125 /* we have to set up a rendering context to be able to use glGetString
126 * a window is created but is not mapped to screen (so it's not visible')
127 * and a GLXContext is bound to it */
128 screen_num = DefaultScreen(pClient->dpy);
129 pClient->enable.fbConfig = pClient->glxChooseFBConfig(pClient->dpy, screen_num, attribs, &returnedFBConfigs);
130 Log(("vboxglGetString: returned FBConfigs: %d\n", returnedFBConfigs));
131 pClient->enable.visinfo = pClient->glxGetVisualFromFBConfig(pClient->dpy, pClient->enable.fbConfig[0]);
132 /* Create Window */
133 attr.background_pixel = 0;
134 attr.border_pixel = 0;
135 attr.colormap = XCreateColormap(pClient->dpy, RootWindow(pClient->dpy, screen_num), pClient->enable.visinfo->visual, AllocNone);
136 attr.event_mask = StructureNotifyMask | ExposureMask;
137 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
138 pClient->enable.win = XCreateWindow(pClient->dpy, RootWindow(pClient->dpy, screen_num), 0, 0, 100, 100,
139 0, pClient->enable.visinfo->depth, InputOutput,
140 pClient->enable.visinfo->visual, mask, &attr);
141 /* Create Context */
142 pClient->enable.ctx = pClient->glxCreateNewContext(pClient->dpy, pClient->enable.fbConfig[0], GLX_RGBA_TYPE, NULL, GL_TRUE);
143 glXMakeCurrent(pClient->dpy, pClient->enable.win, pClient->enable.ctx);
144
145 return VINF_SUCCESS;
146}
147
148/**
149 * Disable OpenGL
150 *
151 * @returns VBox error code
152 * @param pClient Client context
153 */
154int vboxglDisableOpenGL(PVBOXOGLCTX pClient)
155{
156 /* Free all data */
157 if (pClient->enable.ctx)
158 {
159 glFlush();
160 glXMakeCurrent(pClient->dpy, None, NULL);
161 XDestroyWindow(pClient->dpy, pClient->enable.win);
162 glXDestroyContext(pClient->dpy, pClient->enable.ctx);
163 XFree(pClient->enable.visinfo);
164 XFree(pClient->enable.fbConfig);
165 }
166
167 return VINF_SUCCESS;
168}
169
170/**
171 * Client connect init
172 *
173 * @returns VBox error code
174 * @param pClient Client context
175 */
176int vboxglConnect(PVBOXOGLCTX pClient)
177{
178 int rc = VERR_NOT_IMPLEMENTED;
179 Log(("vboxglConnect\n"));
180
181 pClient->PixelFormatToFBConfigMapper = NULL;
182 pClient->xWindow = 0;
183
184 if (!glXDisplay)
185 glXDisplay = XOpenDisplay(NULL);
186
187 pClient->dpy = glXDisplay;
188
189 if (pClient->dpy) {
190 int screenNum, major, minor;
191
192 screenNum = DefaultScreen(pClient->dpy);
193 glXQueryVersion(pClient->dpy, &major, &minor);
194
195 if ((major == 1) && (minor >= 3)) {
196 Log(("Server GLX 1.3 supported\n"));
197 pClient->glxChooseFBConfig = (PFNGLXCHOOSEFBCONFIGSGIXPROC) glXGetProcAddressARB(
198 (GLubyte *) "glXChooseFBConfig");
199 pClient->glxGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) glXGetProcAddressARB(
200 (GLubyte *) "glXGetVisualFromFBConfig");
201 pClient->glxCreateNewContext = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) glXGetProcAddressARB(
202 (GLubyte *) "glXCreateNewContext");
203 } else if (vboxglCheckExtension(pClient->dpy, screenNum, "GLX_SGIX_fbconfig")) {
204 Log(("GLX_SGIX_fbconfig extension supported\n"));
205 pClient->glxChooseFBConfig = (PFNGLXCHOOSEFBCONFIGSGIXPROC) glXGetProcAddressARB(
206 (GLubyte *) "glXChooseFBConfigSGIX");
207 pClient->glxGetVisualFromFBConfig = (PFNGLXGETVISUALFROMFBCONFIGSGIXPROC) glXGetProcAddressARB(
208 (GLubyte *) "glXGetVisualFromFBConfigSGIX");
209 pClient->glxCreateNewContext = (PFNGLXCREATECONTEXTWITHCONFIGSGIXPROC) glXGetProcAddressARB(
210 (GLubyte *) "glXCreateContextWithConfigSGIX");
211 } else {
212 Log(("Error no FBConfig supported\n"));
213 rc = VERR_NOT_IMPLEMENTED;
214 }
215 if (pClient->glxChooseFBConfig && pClient->glxGetVisualFromFBConfig && pClient->glxCreateNewContext)
216 rc = VINF_SUCCESS;
217 }
218
219 return rc;
220}
221
222/**
223 * Client disconnect cleanup
224 *
225 * @returns VBox error code
226 * @param pClient Client context
227 */
228int vboxglDisconnect(PVBOXOGLCTX pClient)
229{
230 Log(("vboxglDisconnect\n"));
231
232#ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT
233 if (pClient->xWindow != 0) {
234 XUnmapWindow(pClient->dpy, pClient->xWindow);
235 XDestroyWindow(pClient->dpy, pClient->xWindow);
236 }
237 if (pClient->PixelFormatToFBConfigMapper) {
238 XFree(pClient->PixelFormatToFBConfigMapper);
239 }
240
241 pClient->dpy = NULL;
242 pClient->xWindow = 0;
243 pClient->actFBConfig = NULL;
244#endif
245 return VINF_SUCCESS;
246}
247
248/* Driver functions */
249void vboxglDrvCreateContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
250{
251 XSetWindowAttributes attr;
252 XVisualInfo *visinfo = NULL;
253 unsigned long mask;
254 GLXFBConfig fbConfig;
255 GLXContextID glrc;
256 int screen_num;
257 XEvent event;
258 OGL_CMD(DrvCreateContext, 1);
259 OGL_PARAM(HDC, hdc);
260
261 Log(("DrvCreateContext %x\n", hdc));
262#ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT
263
264 screen_num = DefaultScreen(pClient->dpy);
265 fbConfig = pClient->actFBConfig;
266
267 visinfo = pClient->glxGetVisualFromFBConfig(pClient->dpy, fbConfig);
268
269 if (pClient->xWindow == 0) {
270
271 /* window attributes */
272 attr.background_pixel = 0;
273 attr.border_pixel = 0;
274 attr.colormap = XCreateColormap(pClient->dpy, RootWindow(pClient->dpy, screen_num ), visinfo->visual, AllocNone);
275 attr.event_mask = StructureNotifyMask | ExposureMask;
276 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
277 pClient->xWindow = XCreateWindow(pClient->dpy,
278 RootWindow(pClient->dpy, screen_num),
279 0, 0, pClient->winWidth, pClient->winHeight, 0,
280 visinfo->depth, InputOutput,
281 visinfo->visual, mask, &attr);
282 }
283 XResizeWindow(pClient->dpy, pClient->xWindow, pClient->winWidth, pClient->winHeight);
284 pClient->glxContext = pClient->glxCreateNewContext(pClient->dpy, fbConfig, GLX_RGBA_TYPE, NULL, GL_TRUE);
285
286 XMapWindow(pClient->dpy, pClient->xWindow);
287 XIfEvent(pClient->dpy, &event, WaitForNotify, (XPointer)pClient->xWindow );
288
289 glrc = 1;
290 Assert(glrc);
291#else
292 AssertFailed();
293 glrc = 0;
294#endif
295
296 pClient->lastretval = (uint64_t)glrc;
297 pClient->fHasLastError = true;
298 pClient->ulLastError = glGetError();
299}
300
301void vboxglDrvDeleteContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
302{
303 OGL_CMD(DrvDeleteContext, 1);
304 OGL_PARAM(HGLRC, hglrc);
305 Log(("DrvDeleteContext %x\n", hglrc));
306
307 glXDestroyContext(pClient->dpy, VBOX_OGL_GUEST_TO_HOST_HDC(hglrc));
308 pClient->lastretval = 1;
309 pClient->fHasLastError = true;
310 pClient->ulLastError = glGetError();
311}
312
313void vboxglDrvSetContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
314{
315 OGL_CMD(DrvSetContext, 2);
316 OGL_PARAM(HDC, hdc);
317 OGL_PARAM(HGLRC, hglrc);
318 Log(("DrvSetContext %x %x\n", hdc, hglrc));
319#ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT
320
321 pClient->lastretval = glXMakeCurrent(pClient->dpy, pClient->xWindow,
322 VBOX_OGL_GUEST_TO_HOST_HDC(hglrc));
323 if (!pClient->lastretval)
324 Log(("glXMakeCurrent failed\n"));
325 pClient->fHasLastError = true;
326 pClient->ulLastError = glGetError();
327#else
328 AssertFailed();
329#endif
330}
331
332void vboxglDrvCopyContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
333{
334 OGL_CMD(DrvDeleteContext, 3);
335 OGL_PARAM(HGLRC, hglrcSrc);
336 OGL_PARAM(HGLRC, hglrcDst);
337 OGL_PARAM(UINT, mask);
338 Log(("DrvCopyContext %x %x %x\n", hglrcSrc, hglrcDst, mask));
339
340 glXCopyContext(pClient->dpy, VBOX_OGL_GUEST_TO_HOST_HDC(hglrc), VBOX_OGL_GUEST_TO_HOST_HDC(hglrc), mask);
341 pClient->lastretval = 1;
342 pClient->fHasLastError = true;
343 pClient->ulLastError = glGetError();
344}
345
346void vboxglDrvReleaseContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
347{
348 OGL_CMD(DrvReleaseContext, 1);
349 OGL_PARAM(HGLRC, hglrc);
350 Log(("DrvReleaseContext %x\n", hglrc));
351 /* clear current selection */
352 pClient->lastretval = glXMakeCurrent(pClient->dpy, None, NULL);
353
354 if (!pClient->lastretval)
355 Log(("glXMakeCurrent failed\n"));
356 pClient->fHasLastError = true;
357 pClient->ulLastError = glGetError();
358}
359
360void vboxglDrvCreateLayerContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
361{
362 XSetWindowAttributes attr;
363 XVisualInfo *visinfo = NULL;
364 unsigned long mask;
365 GLXFBConfig fbConfig;
366 GLXContextID glrc;
367 int screen_num;
368 XEvent event;
369 OGL_CMD(DrvCreateLayerContext, 2);
370 OGL_PARAM(HDC, hdc);
371 OGL_PARAM(int, iLayerPlane);
372
373 Log(("DrvCreateLayerContext %x\n", hdc));
374#ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT
375
376 screen_num = DefaultScreen(pClient->dpy);
377 fbConfig = pClient->actFBConfig;
378 visinfo = pClient->glxGetVisualFromFBConfig(pClient->dpy, fbConfig);
379
380 if (pClient->xWindow == 0) {
381
382 /* window attributes */
383 attr.background_pixel = 0;
384 attr.border_pixel = 0;
385 attr.colormap = XCreateColormap(pClient->dpy, RootWindow(pClient->dpy, screen_num ), visinfo->visual, AllocNone);
386 attr.event_mask = StructureNotifyMask | ExposureMask;
387 mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
388 pClient->xWindow = XCreateWindow(pClient->dpy,
389 RootWindow(pClient->dpy, screen_num),
390 0, 0, pClient->winWidth, pClient->winHeight, 0,
391 visinfo->depth, InputOutput,
392 visinfo->visual, mask, &attr);
393 }
394 XResizeWindow(pClient->dpy, pClient->xWindow, pClient->winWidth, pClient->winHeight);
395 pClient->glxContext = pClient->glxCreateNewContext(pClient->dpy, fbConfig, GLX_RGBA_TYPE, NULL, GL_TRUE);
396 XMapWindow(pClient->dpy, pClient->xWindow);
397 XIfEvent(pClient->dpy, &event, WaitForNotify, (XPointer)pClient->xWindow );
398
399 glrc = 1;
400 Assert(glrc);
401
402 pClient->lastretval = glrc;
403 pClient->fHasLastError = true;
404 pClient->ulLastError = glGetError();
405#else
406 AssertFailed();
407#endif
408}
409
410void vboxglDrvShareLists(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
411{
412 OGL_CMD(DrvShareLists, 3);
413 OGL_PARAM(HGLRC, hglrc1);
414 OGL_PARAM(HGLRC, hglrc2);
415 pClient->lastretval = 0; /** @todo */
416 pClient->fHasLastError = true;
417 pClient->ulLastError = glGetError();
418}
419
420
421void vboxglDrvRealizeLayerPalette(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
422{
423 OGL_CMD(DrvRealizeLayerPalette, 3);
424 OGL_PARAM(HDC, hdc);
425 OGL_PARAM(int, iLayerPlane);
426 OGL_PARAM(BOOL, bRealize);
427 pClient->lastretval = 0; /** @todo */
428 pClient->fHasLastError = true;
429 pClient->ulLastError = glGetError();
430}
431
432void vboxglDrvSwapLayerBuffers(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
433{
434 OGL_CMD(DrvSwapLayerBuffers, 2);
435 OGL_PARAM(HDC, hdc);
436 OGL_PARAM(UINT, fuPlanes);
437 pClient->lastretval = 0; /** @todo */
438 pClient->fHasLastError = true;
439 pClient->ulLastError = glGetError();
440}
441
442void vboxglDrvSetPixelFormat(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
443{
444 int screen_num;
445 OGL_CMD(DrvSetPixelFormat, 4);
446 OGL_PARAM(HDC, hdc);
447 OGL_PARAM(int, iPixelFormat);
448 OGL_PARAM(uint32_t, cx);
449 OGL_PARAM(uint32_t, cy);
450
451 Log(("vboxDrvSetPixelFormat %d\n", iPixelFormat));
452
453 /* Get GLXFBConfig based on the given ID */
454 pClient->actFBConfig = pClient->PixelFormatToFBConfigMapper[iPixelFormat-1];
455 screen_num = DefaultScreen(pClient->dpy);
456
457 pClient->winWidth = cx;
458 pClient->winHeight = cy;
459 pClient->lastretval = true;
460 pClient->fHasLastError = true;
461 pClient->ulLastError = glGetError();
462}
463
464void vboxglDrvSwapBuffers(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
465{
466 OGL_CMD(DrvSwapBuffers, 1);
467 OGL_PARAM(HDC, hdc);
468
469 glXSwapBuffers(pClient->dpy, pClient->xWindow);
470 pClient->lastretval = 1;
471 pClient->fHasLastError = true;
472 pClient->ulLastError = glGetError();
473}
474
475void vboxglDrvDescribeLayerPlane(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
476{
477 PLAYERPLANEDESCRIPTOR plpd;
478
479 OGL_CMD(DrvDescribeLayerPlane, 4);
480 OGL_PARAM(HDC, hdc);
481 OGL_PARAM(int, iPixelFormat);
482 OGL_PARAM(int, iLayerPlane);
483 OGL_PARAM(UINT, nBytes);
484 Assert(pClient->cbLastParam == nBytes);
485 plpd = (PLAYERPLANEDESCRIPTOR)pClient->pLastParam;
486
487 pClient->lastretval = 0; /** @todo */
488 pClient->fHasLastError = true;
489 pClient->ulLastError = glGetError();
490}
491
492void vboxglDrvSetLayerPaletteEntries(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
493{
494 OGL_CMD(DrvSetLayerPaletteEntries, 5);
495 OGL_PARAM(HDC, hdc);
496 OGL_PARAM(int, iLayerPlane);
497 OGL_PARAM(int, iStart);
498 OGL_PARAM(int, cEntries);
499 OGL_MEMPARAM(COLORREF, pcr);
500 pClient->lastretval = 0; /** @todo */
501 pClient->fHasLastError = true;
502 pClient->ulLastError = glGetError();
503}
504
505void vboxglDrvGetLayerPaletteEntries(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
506{
507 COLORREF *pcr;
508
509 OGL_CMD(DrvGetLayerPaletteEntries, 4);
510 OGL_PARAM(HDC, hdc);
511 OGL_PARAM(int, iLayerPlane);
512 OGL_PARAM(int, iStart);
513 OGL_PARAM(int, cEntries);
514
515 Assert(pClient->cbLastParam == sizeof(COLORREF)*cEntries);
516 pcr = (COLORREF *)pClient->pLastParam;
517 pClient->lastretval = 0; /** @todo */
518 pClient->fHasLastError = true;
519 pClient->ulLastError = glGetError();
520}
521
522void vboxglDrvDescribePixelFormat(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer)
523{
524 LPPIXELFORMATDESCRIPTOR ppfd;
525 GLXFBConfig *allFBConfigs, matchingFBConfig;
526 int screenNum, glxReturnValue;
527
528 OGL_CMD(DrvDescribePixelFormat, 3);
529 OGL_PARAM(HDC, hdc);
530 OGL_PARAM(int, iPixelFormat);
531 OGL_PARAM(UINT, nBytes);
532 Assert(pClient->cbLastParam == nBytes);
533 ppfd = (LPPIXELFORMATDESCRIPTOR)pClient->pLastParam;
534
535 Log(("iPixelFormat: %d\n", iPixelFormat));
536
537 if (!pClient->PixelFormatToFBConfigMapper) {
538 /* First get number of all visuals for the return value */
539 screenNum = DefaultScreen(pClient->dpy);
540 allFBConfigs = glXGetFBConfigs(pClient->dpy, screenNum,
541 &pClient->numFBConfigs);
542 pClient->PixelFormatToFBConfigMapper = allFBConfigs;
543 }
544
545 if (nBytes == sizeof(PIXELFORMATDESCRIPTOR)) {
546 int redSize, greenSize, blueSize, alphaSize, xVisual, xRenderable;
547 /* Get GLXFBConfig which matches iPixelFormat */
548 matchingFBConfig = pClient->PixelFormatToFBConfigMapper[iPixelFormat-1];
549
550 Log(("Filling values into PIXELFORMATDESCRIPTOR\n"));
551 /* translate all values to theire corresponding Windows ones */
552 ppfd->nSize = sizeof(PIXELFORMATDESCRIPTOR);
553 ppfd->nVersion = 1;
554 ppfd->iLayerType = PFD_MAIN_PLANE;
555 ppfd->dwFlags = 0;
556
557 /* Set cColorBits */
558 glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_RED_SIZE, &redSize);
559 glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_GREEN_SIZE, &greenSize);
560 glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_BLUE_SIZE, &blueSize);
561 glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_ALPHA_SIZE, &alphaSize);
562 ppfd->cColorBits = redSize + greenSize + blueSize;
563 ppfd->cRedBits = redSize;
564 ppfd->cBlueBits = blueSize;
565 ppfd->cGreenBits = greenSize;
566 ppfd->cAlphaBits = alphaSize;
567
568 /* Set dwFlags */
569 if (!glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_DRAWABLE_TYPE, &glxReturnValue)) {
570 glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_VISUAL_ID, &xVisual);
571 glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_X_RENDERABLE, &xRenderable);
572 if ((glxReturnValue & GLX_WINDOW_BIT) && xVisual)
573 ppfd->dwFlags |= (PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL);
574 }
575 if (!glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_DOUBLEBUFFER, &glxReturnValue)) {
576 if (glxReturnValue)
577 ppfd->dwFlags |= PFD_DOUBLEBUFFER;
578 }
579 /* Set iPixelType */
580 if (!glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_RENDER_TYPE, &glxReturnValue)) {
581 if (glxReturnValue & GLX_RGBA_BIT)
582 ppfd->iPixelType = PFD_TYPE_RGBA;
583 else if ((glxReturnValue & GLX_COLOR_INDEX_BIT) & !(glxReturnValue & GLX_RGBA_BIT))
584 ppfd->iPixelType = PFD_TYPE_COLORINDEX;
585 }
586 /* Set cDepthBits */
587 if (!glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_DEPTH_SIZE, &glxReturnValue)) {
588 ppfd->cDepthBits = glxReturnValue;
589 } else {
590 ppfd->cDepthBits = 0;
591 }
592 /* Set cStencilBits */
593 if (!glXGetFBConfigAttrib(pClient->dpy, matchingFBConfig, GLX_STENCIL_SIZE, &glxReturnValue)) {
594 ppfd->cStencilBits = glxReturnValue;
595 } else {
596 ppfd->cStencilBits = 0;
597 }
598 /** @todo Fill in the rest */
599 }
600
601 pClient->lastretval = pClient->numFBConfigs;
602 pClient->fHasLastError = true;
603 pClient->ulLastError = glGetError();
604}
605
606RTUINTPTR vboxDrvIsExtensionAvailable(char *pszExtFunctionName)
607{
608 RTUINTPTR pfnProc = (RTUINTPTR)glXGetProcAddress((const GLubyte *)pszExtFunctionName);
609 Log(("vboxDrvIsExtensionAvailable %s -> %d\n", pszExtFunctionName, !!pfnProc));
610 return pfnProc;
611}
612
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