VirtualBox

Changeset 3468

Show
Ignore:
Timestamp:
07/05/07 16:18:32 (2 years ago)
Author:
vboxsync
Message:

Extension detection updates

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/include/VBox/HostServices/VBoxOGLOp.h

    r3453 r3468  
    18551855#endif 
    18561856 
     1857 
     1858#ifdef VBOX_OGL_WITH_EXTENSION_ARRAY 
     1859typedef struct 
     1860{ 
     1861    const char *pszExtName; 
     1862    const char *pszExtFunctionName; 
     1863    RTUINTPTR   pfnFunction; 
     1864    bool        fAvailable; 
     1865} OPENGL_EXT, *POPENGL_EXT; 
     1866 
     1867#ifdef VBOX_OGL_GUEST_SIDE 
     1868#define VBOX_OGL_EXTENSION(a)   a 
     1869#else 
     1870#define VBOX_OGL_EXTENSION(a)   pfn##a 
     1871 
     1872static PFNWGLSWAPINTERVALEXTPROC        pfnwglSwapIntervalEXT       = NULL; 
     1873static PFNWGLGETSWAPINTERVALEXTPROC     pfnwglGetSwapIntervalEXT    = NULL; 
     1874 
     1875#endif 
     1876 
     1877static OPENGL_EXT OpenGLExtensions[] =  
     1878{ 
     1879    {   "WGL_EXT_swap_control",             "wglSwapIntervalEXT",               (RTUINTPTR)VBOX_OGL_EXTENSION(wglSwapIntervalEXT),                      false }, 
     1880    {   "WGL_EXT_swap_control",             "wglGetSwapIntervalEXT",            (RTUINTPTR)VBOX_OGL_EXTENSION(wglGetSwapIntervalEXT),                   false }, 
     1881}; 
     1882#endif /* VBOX_OGL_WITH_EXTENSION_ARRAY */ 
     1883 
    18571884#endif /* __VBOXOGLOP_H__ */ 
    18581885 

  • trunk/src/VBox/Additions/WINNT/Graphics/OpenGL/VBoxOGL.h

    r3462 r3468  
    2626#define WINGDIAPI 
    2727#include "GL/gl.h" 
     28#define WGL_WGLEXT_PROTOTYPES 
     29#include <VBox/HostServices/wglext.h> 
    2830 
    2931#include <iprt/cdefs.h> 

  • trunk/src/VBox/Additions/WINNT/Graphics/OpenGL/glext.cpp

    r3464 r3468  
    2424 */ 
    2525 
     26#define VBOX_OGL_WITH_EXTENSION_ARRAY 
    2627#include "VBoxOGL.h" 
    27 #define WGL_WGLEXT_PROTOTYPES 
    28 #include <VBox/HostServices/wglext.h> 
    29  
    30 typedef struct 
    31 { 
    32     const char *pszExtName; 
    33     const char *pszExtFunctionName; 
    34     RTUINTPTR   pfnFunction; 
    35     bool        fAvailable; 
    36 } OPENGL_EXT, *POPENGL_EXT; 
    37  
    38 static OPENGL_EXT OpenGLExtensions[] =  
    39 { 
    40     {   "WGL_EXT_swap_control",             "wglSwapIntervalEXT",               (RTUINTPTR)wglSwapIntervalEXT,                      false }, 
    41     {   "WGL_EXT_swap_control",             "wglGetSwapIntervalEXT",            (RTUINTPTR)wglGetSwapIntervalEXT,                   false }, 
    42 }; 
    4328 
    4429 
    …… 
    6348PROC APIENTRY DrvGetProcAddress(LPCSTR lpszProc) 
    6449{ 
    65     PROC pfnProc; 
     50    PROC pfnProc = NULL; 
    6651 
    6752    for (int i=0;i<RT_ELEMENTS(OpenGLExtensions);i++) 

  • trunk/src/VBox/HostServices/SharedOpenGL/glext.cpp

    r3454 r3468  
    2424 */ 
    2525 
     26#define VBOX_OGL_WITH_EXTENSION_ARRAY 
    2627#include "vboxgl.h" 
    2728#include <VBox/HostServices/wglext.h> 
    2829 
     30#define LOG_GROUP LOG_GROUP_SHARED_OPENGL 
     31#include <VBox/log.h> 
     32 
     33/** 
     34 * Initialize OpenGL extensions 
     35 * 
     36 * @returns VBox error code 
     37 */ 
     38int vboxInitOpenGLExtensions() 
     39{ 
     40    const GLubyte *pszExtensions = glGetString(GL_EXTENSIONS); 
     41    static bool    fInitialized  = false; 
     42 
     43    if (fInitialized) 
     44        return VINF_SUCCESS; 
     45 
     46    for (int i=0;i<RT_ELEMENTS(OpenGLExtensions);i++) 
     47    { 
     48        if (strstr((char *)pszExtensions, OpenGLExtensions[i].pszExtFunctionName)) 
     49            OpenGLExtensions[i].fAvailable = vboxDrvIsExtensionAvailable((char *)OpenGLExtensions[i].pszExtFunctionName); 
     50    } 
     51    fInitialized = true; 
     52    return VINF_SUCCESS; 
     53} 
     54 
     55/** 
     56 * Check if an opengl extension function is available 
     57 * 
     58 * @returns VBox error code 
     59 * @param   pszFunctionName     OpenGL extension function name 
     60 */ 
     61bool vboxwglGetProcAddress(char *pszFunctionName) 
     62{ 
     63    for (int i=0;i<RT_ELEMENTS(OpenGLExtensions);i++) 
     64    { 
     65        if (    OpenGLExtensions[i].fAvailable 
     66            && !strcmp(OpenGLExtensions[i].pszExtFunctionName, pszFunctionName)) 
     67        { 
     68            return true; 
     69        } 
     70    } 
     71 
     72    return false; 
     73} 
    2974 
    3075void vboxwglSwapIntervalEXT (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    3176{ 
    32      AssertFailed(); 
     77    Assert(pfnwglSwapIntervalEXT); 
     78 
     79    OGL_CMD(wglSwapIntervalEXT, 1); 
     80    OGL_PARAM(int, interval); 
     81    pClient->lastretval = pfnwglSwapIntervalEXT(interval); 
     82    if (!pClient->lastretval) 
     83        Log(("wglSwapIntervalEXT failed with %d\n", GetLastError())); 
     84 
     85    pClient->fHasLastError = true; 
     86    pClient->ulLastError   = GetLastError(); 
    3387} 
    3488 
    3589void vboxwglGetSwapIntervalEXT (VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    3690{ 
    37      AssertFailed(); 
     91    Assert(pfnwglGetSwapIntervalEXT); 
     92 
     93    OGL_CMD(wglGetSwapIntervalEXT, 0); 
     94    pClient->lastretval = pfnwglGetSwapIntervalEXT(); 
     95    if (!pClient->lastretval) 
     96        Log(("wglGetSwapIntervalEXT failed with %d\n", GetLastError())); 
     97 
     98    pClient->fHasLastError = true; 
     99    pClient->ulLastError   = GetLastError(); 
    38100} 

  • trunk/src/VBox/HostServices/SharedOpenGL/gllindrv.cpp

    r3460 r3468  
    3232int vboxglGlobalInit() 
    3333{ 
     34    vboxInitOpenGLExtensions(); 
    3435    return VINF_SUCCESS; 
    3536} 

  • trunk/src/VBox/HostServices/SharedOpenGL/glwindrv.cpp

    r3467 r3468  
    104104#endif 
    105105 
    106     return VINF_SUCCESS; 
    107 } 
    108  
    109 /** 
    110  * Client connect init 
    111  * 
    112  * @returns VBox error code 
    113  * @param   pClient         Client context 
    114  */ 
    115 int vboxglConnect(PVBOXOGLCTX pClient) 
    116 { 
    117     Log(("vboxglConnect\n")); 
    118     return VINF_SUCCESS; 
    119 } 
    120  
    121 /** 
    122  * Client disconnect cleanup 
    123  * 
    124  * @returns VBox error code 
    125  * @param   pClient         Client context 
    126  */ 
    127 int vboxglDisconnect(PVBOXOGLCTX pClient) 
    128 { 
    129     Log(("vboxglDisconnect\n")); 
    130 #ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT 
    131     if (pClient->hwnd) 
    132     { 
    133         if (pClient->hdc) 
    134             ReleaseDC(pClient->hwnd, pClient->hdc); 
    135         PostMessage(pClient->hwnd, WM_CLOSE, 0, 0); 
    136         pClient->hwnd = 0; 
    137     } 
    138 #endif 
    139     return VINF_SUCCESS; 
    140 } 
    141  
    142  
    143 /* Driver functions */ 
    144 void vboxglDrvCreateContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    145 { 
    146     HGLRC glrc = 0; 
    147  
    148     OGL_CMD(DrvCreateContext, 1); 
    149     OGL_PARAM(HDC, hdc); 
    150  
    151     Log(("DrvCreateContext %x\n", hdc)); 
    152     Assert(VBOX_OGL_GUEST_TO_HOST_HDC(hdc)); 
    153     glrc = wglCreateContext(pClient->hdc); 
    154  
    155     pClient->lastretval    = (uint64_t)glrc; 
    156     pClient->fHasLastError = true; 
    157     pClient->ulLastError   = GetLastError(); 
    158 } 
    159  
    160 void vboxglDrvSetContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    161 { 
    162     OGL_CMD(DrvSetContext, 2); 
    163     OGL_PARAM(HDC, hdc); 
    164     OGL_PARAM(HGLRC, hglrc); 
    165  
    166     Log(("DrvSetyContext %x %x\n", hdc, hglrc)); 
    167     pClient->lastretval = wglMakeCurrent(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), hglrc); 
    168     if (!pClient->lastretval) 
    169         Log(("wglMakeCurrent failed with %d\n", GetLastError())); 
    170  
    171     pClient->fHasLastError = true; 
    172     pClient->ulLastError   = GetLastError(); 
    173 } 
    174  
    175 void vboxglDrvCopyContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    176 { 
    177     OGL_CMD(DrvDeleteContext, 3); 
    178     OGL_PARAM(HGLRC, hglrcSrc); 
    179     OGL_PARAM(HGLRC, hglrcDst); 
    180     OGL_PARAM(UINT,  mask); 
    181     Log(("DrvCopyContext %x %x %x\n", hglrcSrc, hglrcDst, mask)); 
    182     pClient->lastretval = wglCopyContext(hglrcSrc, hglrcDst, mask); 
    183     if (!pClient->lastretval) 
    184         Log(("wglCopyContext failed with %d\n", GetLastError())); 
    185  
    186     pClient->fHasLastError = true; 
    187     pClient->ulLastError   = GetLastError(); 
    188 } 
    189  
    190 void vboxglDrvReleaseContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    191 { 
    192     OGL_CMD(DrvReleaseContext, 1); 
    193     OGL_PARAM(HGLRC, hglrc); 
    194  
    195     Log(("DrvReleaseContext %x\n", hglrc)); 
    196     /* clear current selection */ 
    197     pClient->lastretval = wglMakeCurrent(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), NULL); 
    198     if (!pClient->lastretval) 
    199         Log(("wglMakeCurrent failed with %d\n", GetLastError())); 
    200     pClient->fHasLastError = true; 
    201     pClient->ulLastError   = GetLastError(); 
    202 } 
    203  
    204 void vboxglDrvDeleteContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    205 { 
    206     OGL_CMD(DrvDeleteContext, 1); 
    207     OGL_PARAM(HGLRC, hglrc); 
    208  
    209     Log(("DrvDeleteContext %x\n", hglrc)); 
    210     pClient->lastretval = wglDeleteContext(hglrc); 
    211     if (!pClient->lastretval) 
    212         Log(("wglDeleteContext failed with %d\n", GetLastError())); 
    213     pClient->fHasLastError = true; 
    214     pClient->ulLastError   = GetLastError(); 
    215 } 
    216  
    217 void vboxglDrvCreateLayerContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    218 { 
    219     HGLRC glrc = 0; 
    220  
    221     OGL_CMD(DrvCreateLayerContext, 2); 
    222     OGL_PARAM(HDC, hdc); 
    223     OGL_PARAM(int, iLayerPlane); 
    224  
    225     Log(("DrvCreateLayerContext %x %d\n", hdc, iLayerPlane)); 
    226     Assert(VBOX_OGL_GUEST_TO_HOST_HDC(hdc)); 
    227     glrc = wglCreateLayerContext(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane); 
    228  
    229     pClient->lastretval    = (uint64_t)glrc; 
    230     pClient->fHasLastError = true; 
    231     pClient->ulLastError   = GetLastError(); 
    232 } 
    233  
    234 void vboxglDrvShareLists(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    235 { 
    236     OGL_CMD(DrvShareLists, 3); 
    237     OGL_PARAM(HGLRC, hglrc1); 
    238     OGL_PARAM(HGLRC, hglrc2); 
    239  
    240     Log(("DrvShareLists %x %x\n", hglrc1, hglrc2)); 
    241     pClient->lastretval = wglShareLists(hglrc1, hglrc2); 
    242     pClient->fHasLastError = true; 
    243     pClient->ulLastError   = GetLastError(); 
    244 } 
    245  
    246  
    247 void vboxglDrvRealizeLayerPalette(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    248 { 
    249     OGL_CMD(DrvRealizeLayerPalette, 3); 
    250     OGL_PARAM(HDC, hdc); 
    251     OGL_PARAM(int, iLayerPlane); 
    252     OGL_PARAM(BOOL, bRealize); 
    253     Log(("DrvRealizeLayerPalette %x %d %d\n", hdc, iLayerPlane, bRealize)); 
    254     pClient->lastretval = wglRealizeLayerPalette(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane, bRealize); 
    255     pClient->fHasLastError = true; 
    256     pClient->ulLastError   = GetLastError(); 
    257 } 
    258  
    259 void vboxglDrvSwapLayerBuffers(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    260 { 
    261     OGL_CMD(DrvSwapLayerBuffers, 2); 
    262     OGL_PARAM(HDC, hdc); 
    263     OGL_PARAM(UINT, fuPlanes); 
    264     Log(("DrvSwapLayerBuffers %x %d\n", hdc, fuPlanes)); 
    265     pClient->lastretval = wglSwapLayerBuffers(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), fuPlanes); 
    266     pClient->fHasLastError = true; 
    267     pClient->ulLastError   = GetLastError(); 
    268 } 
    269  
    270 void vboxglDrvSetPixelFormat(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    271 { 
    272     int rc; 
    273     PIXELFORMATDESCRIPTOR pfd; 
    274  
    275     OGL_CMD(DrvSetPixelFormat, 4); 
    276     OGL_PARAM(HDC, hdc); 
    277     OGL_PARAM(int, iPixelFormat); 
    278     OGL_PARAM(uint32_t, cx); 
    279     OGL_PARAM(uint32_t, cy); 
    280  
    281 #ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT 
    282     if (!pClient->hwnd) 
    283     { 
    284         RTThreadCreate(NULL, vboxWndThread, pClient, 0, RTTHREADTYPE_DEFAULT, 0, "OpenGLWnd"); 
    285         while (!pClient->hwnd) 
    286             RTThreadSleep(100); 
    287     } 
    288     RECT rect; 
    289     rect.bottom = 0; 
    290     rect.left   = 0; 
    291     rect.right  = cx; 
    292     rect.top    = cy; 
    293     /* Convert client rectangel to window rectangle */ 
    294     AdjustWindowRect(&rect, WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE, FALSE); 
    295     SetWindowPos(pClient->hwnd, NULL, 0, 0, rect.right - rect.left, rect.top - rect.bottom, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER); 
    296  
    297     pClient->hdc = GetDC(pClient->hwnd); 
    298  
    299     rc = DescribePixelFormat(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iPixelFormat, sizeof(pfd), &pfd); 
    300     if (rc) 
    301     { 
    302         pClient->lastretval = SetPixelFormat(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iPixelFormat, &pfd); 
    303     } 
    304     else 
    305     { 
    306         Log(("DescribePixelFormat %d failed with 0 (%d)\n", iPixelFormat, GetLastError())); 
    307         pClient->lastretval = 0; 
    308     } 
    309  
    310 #else 
    311     AssertFailed(); 
    312 #endif 
    313  
    314     Log(("DrvSetPixelFormat %x %d (%d,%d)\n", hdc, iPixelFormat, cx, cy)); 
    315     pClient->fHasLastError = true; 
    316     pClient->ulLastError   = GetLastError(); 
    317 } 
    318  
    319 void vboxglDrvSwapBuffers(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    320 { 
    321     OGL_CMD(DrvSwapBuffers, 1); 
    322     OGL_PARAM(HDC, hdc); 
    323  
    324     Log(("DrvSwapBuffers %x\n", hdc)); 
    325     pClient->lastretval = SwapBuffers(VBOX_OGL_GUEST_TO_HOST_HDC(hdc)); 
    326     if (!pClient->lastretval) 
    327         Log(("SwapBuffers failed with %d\n", GetLastError())); 
    328  
    329     /** @todo sync bitmap/screen contents */ 
    330     pClient->fHasLastError = true; 
    331     pClient->ulLastError   = GetLastError(); 
    332 } 
    333  
    334 void vboxglDrvDescribeLayerPlane(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    335 { 
    336     PLAYERPLANEDESCRIPTOR plpd; 
    337  
    338     OGL_CMD(DrvDescribeLayerPlane, 4); 
    339     OGL_PARAM(HDC, hdc); 
    340     OGL_PARAM(int, iPixelFormat); 
    341     OGL_PARAM(int, iLayerPlane); 
    342     OGL_PARAM(UINT, nBytes); 
    343     Assert(pClient->cbLastParam == nBytes); 
    344     plpd = (PLAYERPLANEDESCRIPTOR)pClient->pLastParam; 
    345  
    346     Log(("DrvDescribeLayerPlane %x %d %d %d %x\n", hdc, iPixelFormat, iLayerPlane, nBytes, plpd)); 
    347     pClient->lastretval = wglDescribeLayerPlane(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iPixelFormat, iLayerPlane, nBytes, plpd); 
    348     if (!pClient->lastretval) 
    349         Log(("wglDescribeLayerPlane failed with %d\n", GetLastError())); 
    350     pClient->fHasLastError = true; 
    351     pClient->ulLastError   = GetLastError(); 
    352 } 
    353  
    354 void vboxglDrvSetLayerPaletteEntries(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    355 { 
    356     OGL_CMD(DrvSetLayerPaletteEntries, 5); 
    357     OGL_PARAM(HDC, hdc); 
    358     OGL_PARAM(int, iLayerPlane); 
    359     OGL_PARAM(int, iStart); 
    360     OGL_PARAM(int, cEntries); 
    361     OGL_MEMPARAM(COLORREF, pcr); 
    362  
    363     Log(("DrvSetLayerPaletteEntries %x %d %d %d %x\n", hdc, iLayerPlane, iStart, cEntries, pcr)); 
    364     pClient->lastretval = wglSetLayerPaletteEntries(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane, iStart, cEntries, pcr); 
    365     if (!pClient->lastretval) 
    366         Log(("wglSetLayerPaletteEntries failed with %d\n", GetLastError())); 
    367     pClient->fHasLastError = true; 
    368     pClient->ulLastError   = GetLastError(); 
    369 } 
    370  
    371 void vboxglDrvGetLayerPaletteEntries(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    372 { 
    373     COLORREF *pcr; 
    374  
    375     OGL_CMD(DrvGetLayerPaletteEntries, 4); 
    376     OGL_PARAM(HDC, hdc); 
    377     OGL_PARAM(int, iLayerPlane); 
    378     OGL_PARAM(int, iStart); 
    379     OGL_PARAM(int, cEntries); 
    380  
    381     Assert(pClient->cbLastParam == sizeof(COLORREF)*cEntries); 
    382     pcr = (COLORREF *)pClient->pLastParam; 
    383  
    384     Log(("DrvGetLayerPaletteEntries %x %d %d %d %x\n", hdc, iLayerPlane, iStart, cEntries, pcr)); 
    385     pClient->lastretval = wglGetLayerPaletteEntries(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane, iStart, cEntries, pcr); 
    386     if (!pClient->lastretval) 
    387         Log(("wglGetLayerPaletteEntries failed with %d\n", GetLastError())); 
    388     pClient->fHasLastError = true; 
    389     pClient->ulLastError   = GetLastError(); 
    390 } 
    391  
    392 void vboxglDrvDescribePixelFormat(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
    393 { 
    394     LPPIXELFORMATDESCRIPTOR ppfd; 
    395  
    396     OGL_CMD(DrvDescribePixelFormat, 3); 
    397     OGL_PARAM(HDC, hdc); 
    398     OGL_PARAM(int, iPixelFormat); 
    399     OGL_PARAM(UINT, nBytes); 
    400     Assert(pClient->cbLastParam == nBytes); 
    401     ppfd = (LPPIXELFORMATDESCRIPTOR)pClient->pLastParam; 
    402  
    403     hdc = VBOX_OGL_GUEST_TO_HOST_HDC(hdc); 
    404     if (!hdc) 
    405         hdc = GetDC(0); 
    406  
    407     Log(("DrvDescribePixelFormat %x %d %d %x\n", hdc, iPixelFormat, nBytes, ppfd)); 
    408     pClient->lastretval = DescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd); 
    409     if (!pClient->lastretval) 
    410         Log(("DescribePixelFormat failed with %d\n", GetLastError())); 
    411  
    412     pClient->fHasLastError = true; 
    413     pClient->ulLastError   = GetLastError(); 
    414  
    415     if (!VBOX_OGL_GUEST_TO_HOST_HDC(hdc)) 
    416         ReleaseDC(0, pClient->hdc); 
    417 } 
    418  
    419 bool vboxDrvIsExtensionAvailable(char *pszExtFunctionName) 
    420 { 
    421106    PIXELFORMATDESCRIPTOR pfd; 
    422107    int iFormat; 
    423108    HDC hdc = GetDC(0); 
    424109 
    425 /** @todo rather expensive -> check all known extensions in one go */ 
    426110    ZeroMemory(&pfd, sizeof(pfd)); 
    427111    pfd.nSize       = sizeof(pfd); 
    …… 
    438122    wglMakeCurrent(hdc, hRC); 
    439123 
    440     bool fAvailable = !!wglGetProcAddress(pszExtFunctionName); 
    441  
    442     Log(("vboxDrvIsExtensionAvailable %s -> %d\n", pszExtFunctionName, fAvailable)); 
     124    vboxInitOpenGLExtensions(); 
    443125 
    444126    wglMakeCurrent(NULL, NULL); 
    …… 
    446128    ReleaseDC(0, hdc); 
    447129 
     130    return VINF_SUCCESS; 
     131} 
     132 
     133/** 
     134 * Client connect init 
     135 * 
     136 * @returns VBox error code 
     137 * @param   pClient         Client context 
     138 */ 
     139int vboxglConnect(PVBOXOGLCTX pClient) 
     140{ 
     141    Log(("vboxglConnect\n")); 
     142    return VINF_SUCCESS; 
     143} 
     144 
     145/** 
     146 * Client disconnect cleanup 
     147 * 
     148 * @returns VBox error code 
     149 * @param   pClient         Client context 
     150 */ 
     151int vboxglDisconnect(PVBOXOGLCTX pClient) 
     152{ 
     153    Log(("vboxglDisconnect\n")); 
     154#ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT 
     155    if (pClient->hwnd) 
     156    { 
     157        if (pClient->hdc) 
     158            ReleaseDC(pClient->hwnd, pClient->hdc); 
     159        PostMessage(pClient->hwnd, WM_CLOSE, 0, 0); 
     160        pClient->hwnd = 0; 
     161    } 
     162#endif 
     163    return VINF_SUCCESS; 
     164} 
     165 
     166 
     167/* Driver functions */ 
     168void vboxglDrvCreateContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     169{ 
     170    HGLRC glrc = 0; 
     171 
     172    OGL_CMD(DrvCreateContext, 1); 
     173    OGL_PARAM(HDC, hdc); 
     174 
     175    Log(("DrvCreateContext %x\n", hdc)); 
     176    Assert(VBOX_OGL_GUEST_TO_HOST_HDC(hdc)); 
     177    glrc = wglCreateContext(pClient->hdc); 
     178 
     179    pClient->lastretval    = (uint64_t)glrc; 
     180    pClient->fHasLastError = true; 
     181    pClient->ulLastError   = GetLastError(); 
     182} 
     183 
     184void vboxglDrvSetContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     185{ 
     186    OGL_CMD(DrvSetContext, 2); 
     187    OGL_PARAM(HDC, hdc); 
     188    OGL_PARAM(HGLRC, hglrc); 
     189 
     190    Log(("DrvSetyContext %x %x\n", hdc, hglrc)); 
     191    pClient->lastretval = wglMakeCurrent(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), hglrc); 
     192    if (!pClient->lastretval) 
     193        Log(("wglMakeCurrent failed with %d\n", GetLastError())); 
     194 
     195    pClient->fHasLastError = true; 
     196    pClient->ulLastError   = GetLastError(); 
     197} 
     198 
     199void vboxglDrvCopyContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     200{ 
     201    OGL_CMD(DrvDeleteContext, 3); 
     202    OGL_PARAM(HGLRC, hglrcSrc); 
     203    OGL_PARAM(HGLRC, hglrcDst); 
     204    OGL_PARAM(UINT,  mask); 
     205    Log(("DrvCopyContext %x %x %x\n", hglrcSrc, hglrcDst, mask)); 
     206    pClient->lastretval = wglCopyContext(hglrcSrc, hglrcDst, mask); 
     207    if (!pClient->lastretval) 
     208        Log(("wglCopyContext failed with %d\n", GetLastError())); 
     209 
     210    pClient->fHasLastError = true; 
     211    pClient->ulLastError   = GetLastError(); 
     212} 
     213 
     214void vboxglDrvReleaseContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     215{ 
     216    OGL_CMD(DrvReleaseContext, 1); 
     217    OGL_PARAM(HGLRC, hglrc); 
     218 
     219    Log(("DrvReleaseContext %x\n", hglrc)); 
     220    /* clear current selection */ 
     221    pClient->lastretval = wglMakeCurrent(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), NULL); 
     222    if (!pClient->lastretval) 
     223        Log(("wglMakeCurrent failed with %d\n", GetLastError())); 
     224    pClient->fHasLastError = true; 
     225    pClient->ulLastError   = GetLastError(); 
     226} 
     227 
     228void vboxglDrvDeleteContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     229{ 
     230    OGL_CMD(DrvDeleteContext, 1); 
     231    OGL_PARAM(HGLRC, hglrc); 
     232 
     233    Log(("DrvDeleteContext %x\n", hglrc)); 
     234    pClient->lastretval = wglDeleteContext(hglrc); 
     235    if (!pClient->lastretval) 
     236        Log(("wglDeleteContext failed with %d\n", GetLastError())); 
     237    pClient->fHasLastError = true; 
     238    pClient->ulLastError   = GetLastError(); 
     239} 
     240 
     241void vboxglDrvCreateLayerContext(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     242{ 
     243    HGLRC glrc = 0; 
     244 
     245    OGL_CMD(DrvCreateLayerContext, 2); 
     246    OGL_PARAM(HDC, hdc); 
     247    OGL_PARAM(int, iLayerPlane); 
     248 
     249    Log(("DrvCreateLayerContext %x %d\n", hdc, iLayerPlane)); 
     250    Assert(VBOX_OGL_GUEST_TO_HOST_HDC(hdc)); 
     251    glrc = wglCreateLayerContext(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane); 
     252 
     253    pClient->lastretval    = (uint64_t)glrc; 
     254    pClient->fHasLastError = true; 
     255    pClient->ulLastError   = GetLastError(); 
     256} 
     257 
     258void vboxglDrvShareLists(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     259{ 
     260    OGL_CMD(DrvShareLists, 3); 
     261    OGL_PARAM(HGLRC, hglrc1); 
     262    OGL_PARAM(HGLRC, hglrc2); 
     263 
     264    Log(("DrvShareLists %x %x\n", hglrc1, hglrc2)); 
     265    pClient->lastretval = wglShareLists(hglrc1, hglrc2); 
     266    pClient->fHasLastError = true; 
     267    pClient->ulLastError   = GetLastError(); 
     268} 
     269 
     270 
     271void vboxglDrvRealizeLayerPalette(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     272{ 
     273    OGL_CMD(DrvRealizeLayerPalette, 3); 
     274    OGL_PARAM(HDC, hdc); 
     275    OGL_PARAM(int, iLayerPlane); 
     276    OGL_PARAM(BOOL, bRealize); 
     277    Log(("DrvRealizeLayerPalette %x %d %d\n", hdc, iLayerPlane, bRealize)); 
     278    pClient->lastretval = wglRealizeLayerPalette(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane, bRealize); 
     279    pClient->fHasLastError = true; 
     280    pClient->ulLastError   = GetLastError(); 
     281} 
     282 
     283void vboxglDrvSwapLayerBuffers(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     284{ 
     285    OGL_CMD(DrvSwapLayerBuffers, 2); 
     286    OGL_PARAM(HDC, hdc); 
     287    OGL_PARAM(UINT, fuPlanes); 
     288    Log(("DrvSwapLayerBuffers %x %d\n", hdc, fuPlanes)); 
     289    pClient->lastretval = wglSwapLayerBuffers(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), fuPlanes); 
     290    pClient->fHasLastError = true; 
     291    pClient->ulLastError   = GetLastError(); 
     292} 
     293 
     294void vboxglDrvSetPixelFormat(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     295{ 
     296    int rc; 
     297    PIXELFORMATDESCRIPTOR pfd; 
     298 
     299    OGL_CMD(DrvSetPixelFormat, 4); 
     300    OGL_PARAM(HDC, hdc); 
     301    OGL_PARAM(int, iPixelFormat); 
     302    OGL_PARAM(uint32_t, cx); 
     303    OGL_PARAM(uint32_t, cy); 
     304 
     305#ifdef VBOX_OGL_DEBUG_WINDOW_OUTPUT 
     306    if (!pClient->hwnd) 
     307    { 
     308        RTThreadCreate(NULL, vboxWndThread, pClient, 0, RTTHREADTYPE_DEFAULT, 0, "OpenGLWnd"); 
     309        while (!pClient->hwnd) 
     310            RTThreadSleep(100); 
     311    } 
     312    RECT rect; 
     313    rect.bottom = 0; 
     314    rect.left   = 0; 
     315    rect.right  = cx; 
     316    rect.top    = cy; 
     317    /* Convert client rectangel to window rectangle */ 
     318    AdjustWindowRect(&rect, WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE, FALSE); 
     319    SetWindowPos(pClient->hwnd, NULL, 0, 0, rect.right - rect.left, rect.top - rect.bottom, SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOOWNERZORDER); 
     320 
     321    pClient->hdc = GetDC(pClient->hwnd); 
     322 
     323    rc = DescribePixelFormat(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iPixelFormat, sizeof(pfd), &pfd); 
     324    if (rc) 
     325    { 
     326        pClient->lastretval = SetPixelFormat(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iPixelFormat, &pfd); 
     327    } 
     328    else 
     329    { 
     330        Log(("DescribePixelFormat %d failed with 0 (%d)\n", iPixelFormat, GetLastError())); 
     331        pClient->lastretval = 0; 
     332    } 
     333 
     334#else 
     335    AssertFailed(); 
     336#endif 
     337 
     338    Log(("DrvSetPixelFormat %x %d (%d,%d)\n", hdc, iPixelFormat, cx, cy)); 
     339    pClient->fHasLastError = true; 
     340    pClient->ulLastError   = GetLastError(); 
     341} 
     342 
     343void vboxglDrvSwapBuffers(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     344{ 
     345    OGL_CMD(DrvSwapBuffers, 1); 
     346    OGL_PARAM(HDC, hdc); 
     347 
     348    Log(("DrvSwapBuffers %x\n", hdc)); 
     349    pClient->lastretval = SwapBuffers(VBOX_OGL_GUEST_TO_HOST_HDC(hdc)); 
     350    if (!pClient->lastretval) 
     351        Log(("SwapBuffers failed with %d\n", GetLastError())); 
     352 
     353    /** @todo sync bitmap/screen contents */ 
     354    pClient->fHasLastError = true; 
     355    pClient->ulLastError   = GetLastError(); 
     356} 
     357 
     358void vboxglDrvDescribeLayerPlane(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     359{ 
     360    PLAYERPLANEDESCRIPTOR plpd; 
     361 
     362    OGL_CMD(DrvDescribeLayerPlane, 4); 
     363    OGL_PARAM(HDC, hdc); 
     364    OGL_PARAM(int, iPixelFormat); 
     365    OGL_PARAM(int, iLayerPlane); 
     366    OGL_PARAM(UINT, nBytes); 
     367    Assert(pClient->cbLastParam == nBytes); 
     368    plpd = (PLAYERPLANEDESCRIPTOR)pClient->pLastParam; 
     369 
     370    Log(("DrvDescribeLayerPlane %x %d %d %d %x\n", hdc, iPixelFormat, iLayerPlane, nBytes, plpd)); 
     371    pClient->lastretval = wglDescribeLayerPlane(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iPixelFormat, iLayerPlane, nBytes, plpd); 
     372    if (!pClient->lastretval) 
     373        Log(("wglDescribeLayerPlane failed with %d\n", GetLastError())); 
     374    pClient->fHasLastError = true; 
     375    pClient->ulLastError   = GetLastError(); 
     376} 
     377 
     378void vboxglDrvSetLayerPaletteEntries(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     379{ 
     380    OGL_CMD(DrvSetLayerPaletteEntries, 5); 
     381    OGL_PARAM(HDC, hdc); 
     382    OGL_PARAM(int, iLayerPlane); 
     383    OGL_PARAM(int, iStart); 
     384    OGL_PARAM(int, cEntries); 
     385    OGL_MEMPARAM(COLORREF, pcr); 
     386 
     387    Log(("DrvSetLayerPaletteEntries %x %d %d %d %x\n", hdc, iLayerPlane, iStart, cEntries, pcr)); 
     388    pClient->lastretval = wglSetLayerPaletteEntries(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane, iStart, cEntries, pcr); 
     389    if (!pClient->lastretval) 
     390        Log(("wglSetLayerPaletteEntries failed with %d\n", GetLastError())); 
     391    pClient->fHasLastError = true; 
     392    pClient->ulLastError   = GetLastError(); 
     393} 
     394 
     395void vboxglDrvGetLayerPaletteEntries(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     396{ 
     397    COLORREF *pcr; 
     398 
     399    OGL_CMD(DrvGetLayerPaletteEntries, 4); 
     400    OGL_PARAM(HDC, hdc); 
     401    OGL_PARAM(int, iLayerPlane); 
     402    OGL_PARAM(int, iStart); 
     403    OGL_PARAM(int, cEntries); 
     404 
     405    Assert(pClient->cbLastParam == sizeof(COLORREF)*cEntries); 
     406    pcr = (COLORREF *)pClient->pLastParam; 
     407 
     408    Log(("DrvGetLayerPaletteEntries %x %d %d %d %x\n", hdc, iLayerPlane, iStart, cEntries, pcr)); 
     409    pClient->lastretval = wglGetLayerPaletteEntries(VBOX_OGL_GUEST_TO_HOST_HDC(hdc), iLayerPlane, iStart, cEntries, pcr); 
     410    if (!pClient->lastretval) 
     411        Log(("wglGetLayerPaletteEntries failed with %d\n", GetLastError())); 
     412    pClient->fHasLastError = true; 
     413    pClient->ulLastError   = GetLastError(); 
     414} 
     415 
     416void vboxglDrvDescribePixelFormat(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer) 
     417{ 
     418    LPPIXELFORMATDESCRIPTOR ppfd; 
     419 
     420    OGL_CMD(DrvDescribePixelFormat, 3); 
     421    OGL_PARAM(HDC, hdc); 
     422    OGL_PARAM(int, iPixelFormat); 
     423    OGL_PARAM(UINT, nBytes); 
     424    Assert(pClient->cbLastParam == nBytes); 
     425    ppfd = (LPPIXELFORMATDESCRIPTOR)pClient->pLastParam; 
     426 
     427    hdc = VBOX_OGL_GUEST_TO_HOST_HDC(hdc); 
     428    if (!hdc) 
     429        hdc = GetDC(0); 
     430 
     431    Log(("DrvDescribePixelFormat %x %d %d %x\n", hdc, iPixelFormat, nBytes, ppfd)); 
     432    pClient->lastretval = DescribePixelFormat(hdc, iPixelFormat, nBytes, ppfd); 
     433    if (!pClient->lastretval) 
     434        Log(("DescribePixelFormat failed with %d\n", GetLastError())); 
     435 
     436    pClient->fHasLastError = true; 
     437    pClient->ulLastError   = GetLastError(); 
     438 
     439    if (!VBOX_OGL_GUEST_TO_HOST_HDC(hdc)) 
     440        ReleaseDC(0, pClient->hdc); 
     441} 
     442 
     443bool vboxDrvIsExtensionAvailable(char *pszExtFunctionName) 
     444{ 
     445    bool fAvailable = !!wglGetProcAddress(pszExtFunctionName); 
     446 
     447    Log(("vboxDrvIsExtensionAvailable %s -> %d\n", pszExtFunctionName, fAvailable)); 
    448448    return fAvailable; 
    449449} 

  • trunk/src/VBox/HostServices/SharedOpenGL/service.cpp

    r3467 r3468  
    288288                { 
    289289                    /* Execute the function. */ 
    290                     if (vboxDrvIsExtensionAvailable(pszExtFnName)) 
     290                    if (vboxwglGetProcAddress(pszExtFnName)) 
    291291                        rc = VINF_SUCCESS; 
    292292                    else 

  • trunk/src/VBox/HostServices/SharedOpenGL/vboxgl.h

    r3454 r3468  
    2929#include <VBox/types.h> 
    3030#include "gldrv.h" 
     31#include <VBox/HostServices/wglext.h> 
    3132 
    3233typedef void (* PFN_VBOXGLWRAPPER)(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer); 
    …… 
    7879 */ 
    7980int vboxglFlushBuffer(VBOXOGLCTX *pClient, uint8_t *pCmdBuffer, uint32_t cbCmdBuffer, uint32_t cCommands, GLenum *pLastError, uint64_t *pLastRetVal); 
     81 
     82 
     83/** 
     84 * Initialize OpenGL extensions 
     85 * 
     86 * @returns VBox error code 
     87 */ 
     88int vboxInitOpenGLExtensions(); 
     89 
     90/** 
     91 * Check if an opengl extension function is available 
     92 * 
     93 * @returns VBox error code 
     94 * @param   pszFunctionName     OpenGL extension function name 
     95 */ 
     96bool vboxwglGetProcAddress(char *pszFunctionName); 
    8097 
    8198 

© 2008 Sun Microsystems, Inc.
Contact – Privacy policy