VirtualBox

Changeset 48291 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Sep 5, 2013 7:25:47 AM (11 years ago)
Author:
vboxsync
Message:

crOpenGL: fix OSX win8.1 rendering

Location:
trunk/src/VBox
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/GuestHost/OpenGL/include/cr_blitter.h

    r48275 r48291  
    4545}
    4646
     47DECLINLINE(bool) CrGlslIsInited(const CR_GLSL_CACHE *pCache)
     48{
     49    return !!pCache->pDispatch;
     50}
     51
    4752/* clients should set proper context before calling these funcs */
    4853VBOXBLITTERDECL(bool) CrGlslIsSupported(CR_GLSL_CACHE *pCache);
    … …  
    5257VBOXBLITTERDECL(int) CrGlslProgUseNoAlpha(const CR_GLSL_CACHE *pCache, GLenum enmTexTarget);
    5358VBOXBLITTERDECL(void) CrGlslProgClear(const CR_GLSL_CACHE *pCache);
    54 VBOXBLITTERDECL(bool) CrGlslNeedsCleanup(CR_GLSL_CACHE *pCache);
     59VBOXBLITTERDECL(bool) CrGlslNeedsCleanup(const CR_GLSL_CACHE *pCache);
    5560VBOXBLITTERDECL(void) CrGlslCleanup(CR_GLSL_CACHE *pCache);
    5661VBOXBLITTERDECL(void) CrGlslTerm(CR_GLSL_CACHE *pCache);

  • trunk/src/VBox/GuestHost/OpenGL/util/blitter.cpp

    r48275 r48291  
    841841#define CR_GLSL_STR_V_120 "#version 120\n"
    842842#define CR_GLSL_STR_EXT_TR "#extension GL_ARB_texture_rectangle : enable\n"
    843 #define CR_GLSL_STR_TEX2D "texture2D"
    844 #define CR_GLSL_STR_TEX2DRECT "texture2DRect"
     843#define CR_GLSL_STR_2D "2D"
     844#define CR_GLSL_STR_2DRECT "2DRect"
    845845
    846846#define CR_GLSL_PATTERN_FS_NOALPHA(_ver, _ext, _tex) \
    847847        _ver \
    848848        _ext \
     849        "uniform sampler" _tex " sampler0;\n" \
    849850        "void main()\n" \
    850851        "{\n" \
    851852            "vec2 srcCoord = vec2(gl_TexCoord[0]);\n" \
    852             "gl_FragData[0].xyz = (" _tex "(0, srcCoord).xyz);\n" \
     853            "gl_FragData[0].xyz = (texture" _tex "(sampler0, srcCoord).xyz);\n" \
    853854            "gl_FragData[0].w = 1.0;\n" \
    854855        "}\n"
    … …  
    865866    {
    866867        if (enmTexTarget == GL_TEXTURE_2D)
    867             return CR_GLSL_PATTERN_FS_NOALPHA(CR_GLSL_STR_V_120, "", CR_GLSL_STR_TEX2D);
     868            return CR_GLSL_PATTERN_FS_NOALPHA(CR_GLSL_STR_V_120, "", CR_GLSL_STR_2D);
    868869        else if (enmTexTarget == GL_TEXTURE_RECTANGLE_ARB)
    869             return CR_GLSL_PATTERN_FS_NOALPHA(CR_GLSL_STR_V_120, CR_GLSL_STR_EXT_TR, CR_GLSL_STR_TEX2DRECT);
     870            return CR_GLSL_PATTERN_FS_NOALPHA(CR_GLSL_STR_V_120, CR_GLSL_STR_EXT_TR, CR_GLSL_STR_2DRECT);
    870871
    871872        crWarning("invalid enmTexTarget %#x", enmTexTarget);
    … …  
    875876    {
    876877        if (enmTexTarget == GL_TEXTURE_2D)
    877             return CR_GLSL_PATTERN_FS_NOALPHA("", "", CR_GLSL_STR_TEX2D);
     878            return CR_GLSL_PATTERN_FS_NOALPHA("", "", CR_GLSL_STR_2D);
    878879        else if (enmTexTarget == GL_TEXTURE_RECTANGLE_ARB)
    879             return CR_GLSL_PATTERN_FS_NOALPHA("", CR_GLSL_STR_EXT_TR, CR_GLSL_STR_TEX2DRECT);
     880            return CR_GLSL_PATTERN_FS_NOALPHA("", CR_GLSL_STR_EXT_TR, CR_GLSL_STR_2DRECT);
    880881
    881882        crWarning("invalid enmTexTarget %#x", enmTexTarget);
    … …  
    901902    GLchar * pBuf = NULL;
    902903    GLuint uiProgram = 0;
     904    GLint iUniform = -1;
    903905    GLuint uiShader = pCache->pDispatch->CreateShader(GL_FRAGMENT_SHADER);
    904906    if (!uiShader)
    … …  
    924926#ifdef DEBUG_misha
    925927        if (compiled)
    926             crDebug("compile success:\n-------------------\n%d\n--------\n", pBuf);
     928            crDebug("compile success:\n-------------------\n%s\n--------\n", pBuf);
    927929        else
    928930#endif
    929931        {
    930             crWarning("compile FAILURE:\n-------------------\n%d\n--------\n", pBuf);
     932            Assert(0);
     933            crWarning("compile FAILURE:\n-------------------\n%s\n--------\n", pBuf);
    931934            rc = VERR_NOT_SUPPORTED;
    932935            goto end;
    … …  
    958961#ifdef DEBUG_misha
    959962        if (linked)
    960             crDebug("link success:\n-------------------\n%d\n--------\n", pBuf);
     963            crDebug("link success:\n-------------------\n%s\n--------\n", pBuf);
    961964        else
    962965#endif
    963966        {
    964             crWarning("link FAILURE:\n-------------------\n%d\n--------\n", pBuf);
     967            Assert(0);
     968            crWarning("link FAILURE:\n-------------------\n%s\n--------\n", pBuf);
    965969            rc = VERR_NOT_SUPPORTED;
    966970            goto end;
    … …  
    969973
    970974    Assert(linked);
     975
     976    iUniform = pCache->pDispatch->GetUniformLocation(uiProgram, "sampler0");
     977    if (iUniform == -1)
     978    {
     979        crWarning("GetUniformLocation failed for sampler0");
     980    }
     981    else
     982    {
     983        pCache->pDispatch->Uniform1i(iUniform, 0);
     984    }
    971985
    972986    *puiProgram = uiProgram;
    … …  
    10881102}
    10891103
    1090 VBOXBLITTERDECL(bool) CrGlslNeedsCleanup(CR_GLSL_CACHE *pCache)
     1104VBOXBLITTERDECL(bool) CrGlslNeedsCleanup(const CR_GLSL_CACHE *pCache)
    10911105{
    10921106    return pCache->uNoAlpha2DProg || pCache->uNoAlpha2DRectProg;

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.c

    r48275 r48291  
    298298    if (render_spu.defaultSharedContext == context)
    299299    {
    300         renderspuContextRelease(render_spu.defaultSharedContext);
    301         render_spu.defaultSharedContext = NULL;
     300        renderspuSetDefaultSharedContext(NULL);
    302301    }
    303302
    … …  
    317316}
    318317
    319 
    320 void RENDER_APIENTRY
    321 renderspuMakeCurrent(GLint crWindow, GLint nativeWindow, GLint ctx)
    322 {
    323     WindowInfo *window;
    324     ContextInfo *context;
    325 
    326     /*
    327     crDebug("%s win=%d native=0x%x ctx=%d", __FUNCTION__, crWindow, (int) nativeWindow, ctx);
    328     */
    329 
    330     window = (WindowInfo *) crHashtableSearch(render_spu.windowTable, crWindow);
    331     context = (ContextInfo *) crHashtableSearch(render_spu.contextTable, ctx);
    332 
     318WindowInfo* renderspuGetDummyWindow(GLint visBits)
     319{
     320    WindowInfo *window = (WindowInfo *) crHashtableSearch(render_spu.dummyWindowTable, visBits);
     321    if (!window)
     322    {
     323        window = (WindowInfo *)crAlloc(sizeof (*window));
     324        if (!window)
     325        {
     326            crWarning("crAlloc failed");
     327            return NULL;
     328        }
     329
     330        if (!renderspuWindowInit(window, NULL, visBits, -1))
     331        {
     332            crWarning("renderspuWindowInit failed");
     333            crFree(window);
     334            return NULL;
     335        }
     336
     337        crHashtableAdd(render_spu.dummyWindowTable, visBits, window);
     338    }
     339
     340    return window;
     341}
     342
     343void renderspuPerformMakeCurrent(WindowInfo *window, GLint nativeWindow, ContextInfo *context)
     344{
    333345    if (window && context)
    334346    {
    … …  
    341353        if (!window)
    342354        {
    343             crDebug("Render SPU: MakeCurrent invalid window id: %d", crWindow);
     355            crDebug("Render SPU: MakeCurrent invalid window id: %d", window->BltInfo.Base.id);
    344356            return;
    345357        }
    346358        if (!context)
    347359        {
    348             crDebug("Render SPU: MakeCurrent invalid context id: %d", ctx);
     360            crDebug("Render SPU: MakeCurrent invalid context id: %d", context->BltInfo.Base.id);
    349361            return;
    350362        }
    … …  
    367379            context->everCurrent = GL_TRUE;
    368380        }
    369         if (crWindow == CR_RENDER_DEFAULT_WINDOW_ID && window->mapPending &&
     381        if (window->BltInfo.Base.id == CR_RENDER_DEFAULT_WINDOW_ID && window->mapPending &&
    370382                !render_spu.render_to_app_window && !render_spu.render_to_crut_window) {
    371383            /* Window[CR_RENDER_DEFAULT_CONTEXT_ID] is special, it's the default window and normally hidden.
    … …  
    378390        window->everCurrent = GL_TRUE;
    379391    }
    380     else if (!crWindow && !ctx)
     392    else if (!window && !context)
    381393    {
    382394        renderspu_SystemMakeCurrent( NULL, 0, NULL );
    … …  
    389401    else
    390402    {
    391         crError("renderspuMakeCurrent invalid ids: crWindow(%d), ctx(%d)", crWindow, ctx);
    392     }
    393 }
    394 
    395 GLboolean renderspuWindowInit( WindowInfo *window, VisualInfo *visual, GLboolean showIt, GLint id )
     403        crError("renderspuMakeCurrent invalid ids: crWindow(%d), ctx(%d)",
     404                window ? window->BltInfo.Base.id : 0,
     405                context ? context->BltInfo.Base.id : 0);
     406    }
     407}
     408
     409void RENDER_APIENTRY
     410renderspuMakeCurrent(GLint crWindow, GLint nativeWindow, GLint ctx)
     411{
     412    WindowInfo *window = NULL;
     413    ContextInfo *context = NULL;
     414
     415    /*
     416    crDebug("%s win=%d native=0x%x ctx=%d", __FUNCTION__, crWindow, (int) nativeWindow, ctx);
     417    */
     418
     419    if (crWindow)
     420    {
     421        window = (WindowInfo *) crHashtableSearch(render_spu.windowTable, crWindow);
     422        if (!window)
     423        {
     424            crWarning("invalid window %d specified", crWindow);
     425            return;
     426        }
     427    }
     428
     429    if (ctx)
     430    {
     431        context = (ContextInfo *) crHashtableSearch(render_spu.contextTable, ctx);
     432        if (!context)
     433        {
     434            crWarning("invalid context %d specified", ctx);
     435            return;
     436        }
     437    }
     438
     439    if (!context != !window)
     440    {
     441        crWarning("either window %d or context %d are zero", crWindow, ctx);
     442        return;
     443    }
     444
     445    renderspuPerformMakeCurrent(window, nativeWindow, context);
     446}
     447
     448GLboolean renderspuWindowInitWithVisual( WindowInfo *window, VisualInfo *visual, GLboolean showIt, GLint id )
    396449{
    397450    crMemset(window, 0, sizeof (*window));
    … …  
    449502 * Window functions
    450503 */
    451 
    452 GLint renderspuWindowCreateEx( const char *dpyName, GLint visBits, GLint id )
    453 {
    454     WindowInfo *window;
     504GLboolean renderspuWindowInit(WindowInfo *pWindow, const char *dpyName, GLint visBits, GLint id)
     505{
    455506    VisualInfo *visual;
    456     GLboolean showIt;
    457 
    458     if (id <= 0)
    459     {
    460         id = (GLint)crHashtableAllocKeys(render_spu.windowTable, 1);
    461         if (id <= 0)
    462         {
    463             crWarning("failed to allocate window id");
    464             return -1;
    465         }
    466     }
    467     else
    468     {
    469         if (crHashtableIsKeyUsed(render_spu.windowTable, id))
    470         {
    471             crWarning("the specified window key %d is in use", id);
    472             return -1;
    473         }
    474     }
    475 
     507
     508    crMemset(pWindow, 0, sizeof (*pWindow));
    476509
    477510    if (!dpyName || crStrlen(render_spu.display_string) > 0)
    … …  
    482515    {
    483516        crWarning( "Render SPU: Couldn't create a window, renderspuFindVisual returned NULL" );
    484         return -1;
    485     }
    486 
    487     /* Allocate WindowInfo */
    488     window = (WindowInfo *) crCalloc(sizeof(WindowInfo));
    489     if (!window)
    490     {
    491         crWarning( "Render SPU: Couldn't create a window" );
    492         return -1;
    493     }
    494    
    495     crHashtableAdd(render_spu.windowTable, id, window);
    496 
    497     showIt = 0;
     517        return GL_FALSE;
     518    }
    498519
    499520    /*
    … …  
    501522    */
    502523    /* Have GLX/WGL/AGL create the window */
    503     if (!renderspuWindowInit( window, visual, showIt, id ))
    504     {
     524    if (!renderspuWindowInitWithVisual( pWindow, visual, 0, id ))
     525    {
     526        crWarning( "Render SPU: Couldn't create a window, renderspu_SystemCreateWindow failed" );
     527        return GL_FALSE;
     528    }
     529
     530    return GL_TRUE;
     531}
     532
     533GLint renderspuWindowCreateEx( const char *dpyName, GLint visBits, GLint id )
     534{
     535    WindowInfo *window;
     536
     537    GLboolean showIt;
     538
     539    if (id <= 0)
     540    {
     541        id = (GLint)crHashtableAllocKeys(render_spu.windowTable, 1);
     542        if (id <= 0)
     543        {
     544            crWarning("failed to allocate window id");
     545            return -1;
     546        }
     547    }
     548    else
     549    {
     550        if (crHashtableIsKeyUsed(render_spu.windowTable, id))
     551        {
     552            crWarning("the specified window key %d is in use", id);
     553            return -1;
     554        }
     555    }
     556
     557    /* Allocate WindowInfo */
     558    window = (WindowInfo *) crCalloc(sizeof(WindowInfo));
     559    if (!window)
     560    {
     561        crWarning( "Render SPU: Couldn't create a window" );
     562        return -1;
     563    }
     564   
     565    if (!renderspuWindowInit(window, dpyName, visBits, id))
     566    {
     567        crWarning("renderspuWindowInit failed");
    505568        crFree(window);
    506         crWarning( "Render SPU: Couldn't create a window, renderspu_SystemCreateWindow failed" );
    507569        return -1;
    508570    }
    509    
     571
     572    crHashtableAdd(render_spu.windowTable, id, window);
    510573    return window->BltInfo.Base.id;
    511574}
    … …  
    12601323 * Misc functions
    12611324 */
    1262 
     1325void renderspuSetDefaultSharedContext(ContextInfo *pCtx)
     1326{
     1327    if (pCtx == render_spu.defaultSharedContext)
     1328        return;
     1329
     1330    renderspu_SystemDefaultSharedContextChanged(render_spu.defaultSharedContext, pCtx);
     1331
     1332    if (render_spu.defaultSharedContext)
     1333        renderspuContextRelease(render_spu.defaultSharedContext);
     1334
     1335    renderspuContextRetain(pCtx);
     1336    render_spu.defaultSharedContext = pCtx;
     1337}
    12631338
    12641339
    … …  
    12691344    {
    12701345        case GL_HH_SET_DEFAULT_SHARED_CTX:
    1271             if (render_spu.defaultSharedContext)
    1272             {
    1273                 renderspuContextRelease(render_spu.defaultSharedContext);
    1274                 render_spu.defaultSharedContext = NULL;
    1275             }
    1276 
     1346        {
     1347            ContextInfo * pCtx = NULL;
    12771348            if (value)
    1278             {
    1279                 render_spu.defaultSharedContext = (ContextInfo *) crHashtableSearch(render_spu.contextTable, value);
    1280                 if (render_spu.defaultSharedContext)
    1281                     renderspuContextRetain(render_spu.defaultSharedContext);
    1282                 else
    1283                     crWarning("invalid default shared context id %d", value);
    1284             }
    1285 
     1349                pCtx = (ContextInfo *)crHashtableSearch(render_spu.contextTable, value);
     1350            else
     1351                crWarning("invalid default shared context id %d", value);
     1352
     1353            renderspuSetDefaultSharedContext(pCtx);
    12861354            break;
     1355        }
    12871356        default:
    12881357//            crWarning("Unhandled target in renderspuChromiumParameteriCR()");

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.h

    r48079 r48291  
    259259    CRHashTable *contextTable;
    260260
     261    CRHashTable *dummyWindowTable;
     262
    261263    ContextInfo *defaultSharedContext;
    262264
    … …  
    308310
    309311#ifdef RT_OS_DARWIN
    310 # ifndef VBOX_WITH_COCOA_QT
     312# ifdef VBOX_WITH_COCOA_QT
     313    CR_GLSL_CACHE GlobalShaders;
     314# else
    311315    RgnHandle hRootVisibleRegion;
    312316    RTSEMFASTMUTEX syncMutex;
    … …  
    364368
    365369
    366 
     370extern void renderspuSetDefaultSharedContext(ContextInfo *pCtx);
    367371extern void renderspuSetVBoxConfiguration( RenderSPU *spu );
    368372extern void renderspuMakeVisString( GLbitfield visAttribs, char *s );
    … …  
    379383extern void renderspu_SystemWindowPosition( WindowInfo *window, GLint x, GLint y );
    380384extern void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, const GLint* pRects);
    381 
    382 #ifdef GLX
    383385extern int renderspu_SystemInit();
    384386extern int renderspu_SystemTerm();
    385 #endif
     387extern void renderspu_SystemDefaultSharedContextChanged(ContextInfo *fromContext, ContextInfo *toContext);
    386388extern void renderspu_SystemShowWindow( WindowInfo *window, GLboolean showIt );
    387389extern void renderspu_SystemMakeCurrent( WindowInfo *window, GLint windowInfor, ContextInfo *context );
    … …  
    405407extern PCR_BLITTER renderspuVBoxPresentBlitterEnsureCreated( WindowInfo *window, int32_t i32MakeCurrentUserData );
    406408extern void renderspuWindowTerm( WindowInfo *window );
    407 extern GLboolean renderspuWindowInit( WindowInfo *window, VisualInfo *visual, GLboolean showIt, GLint id );
     409extern WindowInfo* renderspuGetDummyWindow(GLint visBits);
     410extern void renderspuPerformMakeCurrent(WindowInfo *window, GLint nativeWindow, ContextInfo *context);
     411extern GLboolean renderspuWindowInit(WindowInfo *pWindow, const char *dpyName, GLint visBits, GLint id);
     412extern GLboolean renderspuWindowInitWithVisual( WindowInfo *window, VisualInfo *visual, GLboolean showIt, GLint id );
    408413extern GLboolean renderspuInitVisual(VisualInfo *pVisInfo, const char *displayName, GLbitfield visAttribs);
    409414extern void renderspuVBoxCompositorBlit ( struct VBOXVR_SCR_COMPOSITOR * pCompositor, PCR_BLITTER pBlitter);

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_agl.c

    r45132 r48291  
    887887}
    888888
     889int renderspu_SystemInit()
     890{
     891    return VINF_SUCCESS;
     892}
     893
     894int renderspu_SystemTerm()
     895{
     896    return VINF_SUCCESS;
     897}
     898
     899void renderspu_SystemDefaultSharedContextChanged(ContextInfo *fromContext, ContextInfo *toContext)
     900{
     901
     902}

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa.c

    r45132 r48291  
    187187{
    188188}
     189
     190int renderspu_SystemInit()
     191{
     192    return VINF_SUCCESS;
     193}
     194
     195int renderspu_SystemTerm()
     196{
     197    CrGlslTerm(&render_spu.GlobalShaders);
     198    return VINF_SUCCESS;
     199}
     200
     201typedef struct CR_RENDER_CTX_INFO
     202{
     203    ContextInfo * pContext;
     204    WindowInfo * pWindow;
     205} CR_RENDER_CTX_INFO;
     206
     207void renderspuCtxInfoInitCurrent(CR_RENDER_CTX_INFO *pInfo)
     208{
     209    GET_CONTEXT(pCurCtx);
     210    pInfo->pContext = pCurCtx;
     211    pInfo->pWindow = pCurCtx->currentWindow;
     212}
     213
     214void renderspuCtxInfoRestoreCurrent(CR_RENDER_CTX_INFO *pInfo)
     215{
     216    GET_CONTEXT(pCurCtx);
     217    if (pCurCtx == pInfo->pContext && (!pCurCtx || pCurCtx->currentWindow == pInfo->pWindow))
     218        return;
     219    renderspuPerformMakeCurrent(pInfo->pWindow, 0, pInfo->pContext);
     220}
     221
     222GLboolean renderspuCtxSetCurrentWithAnyWindow(ContextInfo * pContext, CR_RENDER_CTX_INFO *pInfo)
     223{
     224    WindowInfo * window;
     225    renderspuCtxInfoInitCurrent(pInfo);
     226
     227    if (pInfo->pContext == pContext)
     228        return GL_TRUE;
     229
     230    window = pContext->currentWindow;
     231    if (!window)
     232    {
     233        window = renderspuGetDummyWindow(pContext->BltInfo.Base.visualBits);
     234        if (!window)
     235        {
     236            crWarning("renderspuGetDummyWindow failed");
     237            return GL_FALSE;
     238        }
     239    }
     240
     241    Assert(window);
     242
     243    renderspuPerformMakeCurrent(window, 0, pContext);
     244    return GL_TRUE;
     245}
     246
     247void renderspu_SystemDefaultSharedContextChanged(ContextInfo *fromContext, ContextInfo *toContext)
     248{
     249    CRASSERT(fromContext != toContext);
     250
     251    if (!CrGlslIsInited(&render_spu.GlobalShaders))
     252    {
     253        CrGlslInit(&render_spu.GlobalShaders, render_spu.blitterDispatch);
     254    }
     255
     256    if (fromContext)
     257    {
     258        if (CrGlslNeedsCleanup(&render_spu.GlobalShaders))
     259        {
     260            CR_RENDER_CTX_INFO Info;
     261            if (renderspuCtxSetCurrentWithAnyWindow(fromContext, &Info))
     262            {
     263                CrGlslCleanup(&render_spu.GlobalShaders);
     264                renderspuCtxInfoRestoreCurrent(&Info);
     265            }
     266            else
     267                crWarning("renderspuCtxSetCurrentWithAnyWindow failed!");
     268        }
     269    }
     270    else
     271    {
     272        CRASSERT(!CrGlslNeedsCleanup(&render_spu.GlobalShaders));
     273    }
     274
     275    CRASSERT(!CrGlslNeedsCleanup(&render_spu.GlobalShaders));
     276
     277    if (toContext)
     278    {
     279        CR_RENDER_CTX_INFO Info;
     280        if (renderspuCtxSetCurrentWithAnyWindow(toContext, &Info))
     281        {
     282            int rc = CrGlslProgGenAllNoAlpha(&render_spu.GlobalShaders);
     283            if (!RT_SUCCESS(rc))
     284                crWarning("CrGlslProgGenAllNoAlpha failed, rc %d", rc);
     285
     286            renderspuCtxInfoRestoreCurrent(&Info);
     287        }
     288        else
     289            crWarning("renderspuCtxSetCurrentWithAnyWindow failed!");
     290    }
     291}

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m

    r48275 r48291  
    10891089                if (m_pBlitter)
    10901090                {
    1091                     int rc = CrBltInit(m_pBlitter, NULL, false, false, NULL, render_spu.blitterDispatch);
     1091                    int rc = CrBltInit(m_pBlitter, NULL, false, false, &render_spu.GlobalShaders, render_spu.blitterDispatch);
    10921092                    if (RT_SUCCESS(rc))
    10931093                    {
    … …  
    13281328                    }
    13291329                   
    1330                     CrBltBlitTexMural(m_pBlitter, true, &pEntry->Tex, pSrcRect, pDstRect, 1, fFlags);
     1330                    CrBltBlitTexMural(m_pBlitter, true, &pEntry->Tex, pSrcRect, pDstRect, 1, fFlags | CRBLT_F_NOALPHA);
    13311331                }
    13321332                CrBltLeave(m_pBlitter);
    … …  
    14521452                            }
    14531453                   
    1454                             CrBltBlitTexMural(m_pBlitter, true, &pEntry->Tex, pSrcRect, pDstRect, 1, fFlags);
     1454                            CrBltBlitTexMural(m_pBlitter, true, &pEntry->Tex, pSrcRect, pDstRect, 1, fFlags | CRBLT_F_NOALPHA);
    14551455                        }
    14561456                        CrBltLeave(m_pBlitter);

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c

    r45581 r48291  
    448448            if (bRc)
    449449            {
    450                 bRc = renderspuWindowInit(&render_spu.WinCmdWindow, &render_spu.WinCmdVisual, GL_FALSE, CR_RENDER_WINCMD_ID);
     450                bRc = renderspuWindowInitWithVisual(&render_spu.WinCmdWindow, &render_spu.WinCmdVisual, GL_FALSE, CR_RENDER_WINCMD_ID);
    451451                if (bRc)
    452452                {
    … …  
    458458                else
    459459                {
    460                     crError("renderspuWindowInit failed");
     460                    crError("renderspuWindowInitWithVisual failed");
    461461                }
    462462                /* there is no visual destroy impl currently
    … …  
    20782078    XSync(window->visual->dpy, False);
    20792079}
     2080
     2081void renderspu_SystemDefaultSharedContextChanged(ContextInfo *fromContext, ContextInfo *toContext)
     2082{
     2083
     2084}

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c

    r48079 r48291  
    142142    WindowInfo *windowInfo;
    143143    const char * pcpwSetting;
     144    int rc;
    144145
    145146    (void) child;
    … …  
    194195    render_spu.contextTable = crAllocHashtableEx(1, INT32_MAX);
    195196    render_spu.windowTable = crAllocHashtableEx(1, INT32_MAX);
     197
     198    render_spu.dummyWindowTable = crAllocHashtable();
    196199
    197200    pcpwSetting = crGetenv("CR_RENDER_ENABLE_SINGLE_PRESENT_CONTEXT");
    … …  
    217220    CRASSERT(render_spu.default_visual & CR_RGB_BIT);
    218221   
    219 #ifdef GLX
    220     {
    221         int rc = renderspu_SystemInit();
    222         if (!RT_SUCCESS(rc))
    223         {
    224             crError("renderspu_SystemInit failed rc %d", rc);
    225             return NULL;
    226         }
    227     }
    228 #endif
    229 
     222    rc = renderspu_SystemInit();
     223    if (!RT_SUCCESS(rc))
     224    {
     225        crError("renderspu_SystemInit failed rc %d", rc);
     226        return NULL;
     227    }
    230228#ifdef USE_OSMESA
    231229    if (render_spu.use_osmesa) {
    … …  
    444442    {
    445443        crHashtableWalk(render_spu.windowTable, renderspuBlitterCleanupCB, NULL);
    446     }
    447 
    448     if (render_spu.defaultSharedContext)
    449     {
    450         renderspuContextRelease(render_spu.defaultSharedContext);
    451         render_spu.defaultSharedContext = NULL;
    452     }
     444
     445        crHashtableWalk(render_spu.dummyWindowTable, renderspuBlitterCleanupCB, NULL);
     446    }
     447
     448    renderspuSetDefaultSharedContext(NULL);
    453449
    454450    crFreeHashtable(render_spu.contextTable, DeleteContextCallback);
    … …  
    456452    crFreeHashtable(render_spu.windowTable, DeleteWindowCallback);
    457453    render_spu.windowTable = NULL;
     454    crFreeHashtable(render_spu.dummyWindowTable, DeleteWindowCallback);
     455    render_spu.dummyWindowTable = NULL;
    458456    crFreeHashtable(render_spu.barrierHash, crFree);
    459457    render_spu.barrierHash = NULL;

  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_wgl.c

    r46887 r48291  
    16781678    SetParent(window->hWnd, (HWND)render_spu_parent_window_id);
    16791679}
     1680
     1681int renderspu_SystemInit()
     1682{
     1683    return VINF_SUCCESS;
     1684}
     1685
     1686int renderspu_SystemTerm()
     1687{
     1688    return VINF_SUCCESS;
     1689}
     1690
     1691void renderspu_SystemDefaultSharedContextChanged(ContextInfo *fromContext, ContextInfo *toContext)
     1692{
     1693
     1694}
Note: See TracChangeset for help on using the changeset viewer.

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