VirtualBox

Changeset 45009 in vbox


Ignore:
Timestamp:
Mar 12, 2013 5:27:04 PM (12 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
84241
Message:

crOpenGL: offscreen rendering & VRDP+3D-related fixes

Location:
trunk/src/VBox
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r44997 r45009  
    5757typedef FNCRBLT_BLITTER *PFNCRBLT_BLITTER;
    5858
    59 #define CRBLT_F_LINEAR 0x00000001
     59#define CRBLT_F_LINEAR    0x00000001
     60#define CRBLT_F_OFFSCREEN 0x00000002
    6061
    6162typedef struct CR_BLITTER_SPUITEM

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

    r44886 r45009  
    124124    GLuint fboWidth, fboHeight;
    125125    GLuint idPBO;
     126    GLboolean fCompositorPresented;
    126127
    127128    VBOXVR_SCR_COMPOSITOR_ENTRY CEntry;

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

    r44775 r45009  
    8080}
    8181
     82DECLINLINE(bool) VBoxRectIsZero(const RTRECT *pRect)
     83{
     84    return pRect->xLeft == pRect->xRight || pRect->yTop == pRect->yBottom;
     85}
     86
    8287DECLINLINE(bool) VBoxRectIsIntersect(const RTRECT * pRect1, const RTRECT * pRect2)
    8388{

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

    r44997 r45009  
    9292        const RTRECT * pSrcRect = &paSrcRect[i];
    9393        const RTRECT * pDstRect = &paDstRect[i];
    94         pBlitter->pDispatch->BlitFramebufferEXT(
    95                 pSrcRect->xLeft, pSrcRect->yTop, pSrcRect->xRight, pSrcRect->yBottom,
    96                 pDstRect->xLeft, pDstRect->yTop, pDstRect->xRight, pDstRect->yBottom,
    97                 GL_COLOR_BUFFER_BIT, filter);
     94        if (CRBLT_F_OFFSCREEN & fFlags)
     95        {
     96            pBlitter->pDispatch->BlitFramebufferEXT(
     97                    pSrcRect->xLeft, pSrcRect->yTop, pSrcRect->xRight, pSrcRect->yBottom,
     98                    pDstRect->xLeft, pDstRect->yTop, pDstRect->xRight, pDstRect->yBottom,
     99                    GL_COLOR_BUFFER_BIT, filter);
     100        }
     101        else
     102        {
     103            pBlitter->pDispatch->BlitFramebufferEXT(
     104                    pSrcRect->xLeft, pSrc->height - pSrcRect->yTop, pSrcRect->xRight, pSrc->height - pSrcRect->yBottom,
     105                    pDstRect->xLeft, pDstSize->cy - pDstRect->yTop, pDstRect->xRight, pDstSize->cy - pDstRect->yBottom,
     106                    GL_COLOR_BUFFER_BIT, filter);
     107        }
    98108    }
    99109
    … …  
    488498    crBltCheckSetupViewport(pBlitter, pDstSize, enmDstBuff == GL_DRAW_FRAMEBUFFER);
    489499
    490     pBlitter->pfnBlt(pBlitter, pSrc, paSrcRects, pDstSize, paDstRects, cRects, fFlags);
     500    pBlitter->pfnBlt(pBlitter, pSrc, paSrcRects, pDstSize, paDstRects, cRects, fFlags & CRBLT_F_OFFSCREEN);
    491501}
    492502
    … …  
    497507    pBlitter->pDispatch->BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, 0);
    498508
    499     crBltBlitTexBuf(pBlitter, pSrc, paSrcRects, GL_BACK, &DstSize, paDstRects, cRects, fFlags);
     509    crBltBlitTexBuf(pBlitter, pSrc, paSrcRects, GL_BACK, &DstSize, paDstRects, cRects, fFlags & (~CRBLT_F_OFFSCREEN));
    500510}
    501511

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

    r44766 r45009  
    130130    RTListForEach(&pList->ListHead, pReg1, VBOXVR_REG, ListEntry)
    131131    {
     132        Assert(!VBoxRectIsZero(&pReg1->Rect));
    132133        for (RTLISTNODE *pEntry2 = pReg1->ListEntry.pNext; pEntry2 != &pList->ListHead; pEntry2 = pEntry2->pNext)
    133134        {
    … …  
    217218    vboxVrDbgListVerify(pList1);
    218219#endif
     220    Assert(!VBoxRectIsZero(pRect2));
    219221
    220222    RTListInit(&List);
    … …  
    306308        {
    307309            const RTRECT *pRect2 = &aRects[i];
     310            if (VBoxRectIsZero(pRect2))
     311                continue;
    308312            if (pReg1->Rect.yBottom <= pRect2->yTop)
    309313                continue;
    … …  
    650654    for (uint32_t i = 0; i < cRects; ++i)
    651655    {
     656        if (VBoxRectIsZero(&aRects[i]))
     657        {
     658            cCovered++;
     659            continue;
     660        }
     661
    652662        for (PRTLISTNODE pEntry1 = pList->ListHead.pNext; pEntry1 != &pList->ListHead; pEntry1 = pEntry1->pNext)
    653663        {
    654664            PVBOXVR_REG pReg1 = PVBOXVR_REG_FROM_ENTRY(pEntry1);
     665
    655666            if (VBoxRectIsCoveres(&pReg1->Rect, &aRects[i]))
    656667            {
    … …  
    679690    for (uint32_t i = 0; i < cRects; ++i)
    680691    {
     692        if (VBoxRectIsZero(&aRects[i]))
     693            continue;
     694
    681695        PVBOXVR_REG pReg = vboxVrRegCreate();
    682696        if (!pReg)

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server.h

    r44740 r45009  
    142142void crServerMuralFBOSwapBuffers(CRMuralInfo *mural);
    143143
     144void crServerVBoxCompositionReenable(CRMuralInfo *mural);
     145void crServerVBoxCompositionDisable(CRMuralInfo *mural);
     146void crServerVBoxCompositionPresent(CRMuralInfo *mural);
     147
    144148#define CR_SERVER_FBO_BB_IDX(_mural) ((_mural)->iBbBuffer)
    145149#define CR_SERVER_FBO_FB_IDX(_mural) (((_mural)->iBbBuffer + 1) % ((_mural)->cBuffers))

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_context.c

    r44860 r45009  
    287287    CRASSERT(ctx);
    288288
    289     oldMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, cr_server.currentWindow);
     289    oldMural = cr_server.currentMural;
    290290
    291291    /* Ubuntu 11.04 hosts misbehave if context window switch is

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.c

    r44951 r45009  
    265265        }
    266266
    267         if (!crStateGetCurrent()->framebufferobject.drawFB)
    268         {
    269             cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, mural->aidFBOs[mural->iCurDrawBuffer]);
    270         }
    271         if (!crStateGetCurrent()->framebufferobject.readFB)
    272         {
    273             cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, mural->aidFBOs[mural->iCurReadBuffer]);
    274         }
    275 
    276         if (cr_server.curClient && cr_server.curClient->currentMural == mural)
    277         {
     267        if (cr_server.currentMural == mural)
     268        {
     269            if (!crStateGetCurrent()->framebufferobject.drawFB)
     270            {
     271                cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, mural->aidFBOs[mural->iCurDrawBuffer]);
     272            }
     273            if (!crStateGetCurrent()->framebufferobject.readFB)
     274            {
     275                cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, mural->aidFBOs[mural->iCurReadBuffer]);
     276            }
     277
    278278            crStateGetCurrent()->buffer.width = 0;
    279279            crStateGetCurrent()->buffer.height = 0;
    … …  
    286286            /* tell renderspu we do not want compositor presentation anymore
    287287             * renderspu will ensure its redraw thread is done with using the compositor, etc. */
    288             cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, NULL, NULL);
     288            crServerVBoxCompositionDisable(mural);
    289289        }
    290290
    … …  
    292292            cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, mural->bVisible);
    293293
    294         if (mural->fUseFBO && crServerSupportRedirMuralFBO())
     294        if (cr_server.currentMural == mural)
    295295        {
    296296            if (!crStateGetCurrent()->framebufferobject.drawFB)
    … …  
    302302                cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, 0);
    303303            }
    304         }
    305 
    306         if (cr_server.curClient && cr_server.curClient->currentMural == mural)
    307         {
     304
    308305            crStateGetCurrent()->buffer.width = mural->width;
    309306            crStateGetCurrent()->buffer.height = mural->height;
    … …  
    512509}
    513510
     511void crServerVBoxCompositionPresent(CRMuralInfo *mural)
     512{
     513    CRMuralInfo *currentMural = cr_server.currentMural;
     514    CRContextInfo *curCtxInfo = cr_server.currentCtxInfo;
     515    GLuint idDrawFBO, idReadFBO;
     516    CRContext *curCtx = curCtxInfo->pContext;
     517
     518    CRASSERT(curCtx == crStateGetCurrent());
     519
     520    if (!mural->bVisible)
     521    {
     522        return;
     523    }
     524
     525    if (!mural->width || !mural->height)
     526    {
     527        return;
     528    }
     529
     530    if (!CrVrScrCompositorEntryIsInList(&mural->CEntry))
     531        return;
     532
     533    if (currentMural)
     534    {
     535        idDrawFBO = currentMural->aidFBOs[currentMural->iCurDrawBuffer];
     536        idReadFBO = currentMural->aidFBOs[currentMural->iCurReadBuffer];
     537    }
     538    else
     539    {
     540        idDrawFBO = 0;
     541        idReadFBO = 0;
     542    }
     543
     544    crStateSwitchPrepare(NULL, curCtx, idDrawFBO, idReadFBO);
     545
     546    cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
     547
     548    crStateSwitchPostprocess(curCtx, NULL, idDrawFBO, idReadFBO);
     549
     550    mural->fCompositorPresented = GL_TRUE;
     551}
     552
     553void crServerVBoxCompositionReenable(CRMuralInfo *mural)
     554{
     555    if (!mural->fCompositorPresented)
     556        return;
     557
     558    crServerVBoxCompositionPresent(mural);
     559}
     560
     561void crServerVBoxCompositionDisable(CRMuralInfo *mural)
     562{
     563    cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, NULL, NULL);
     564}
     565
    514566void crServerPresentFBO(CRMuralInfo *mural)
    515567{
    … …  
    539591    if (mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT)
    540592    {
    541         GLuint idDrawFBO, idReadFBO;
    542 
    543         idDrawFBO = mural->aidFBOs[mural->iCurDrawBuffer];
    544         idReadFBO = mural->aidFBOs[mural->iCurReadBuffer];
    545 
    546         crStateSwitchPrepare(NULL, ctx, idDrawFBO, idReadFBO);
    547 
    548         cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
    549 
    550         crStateSwitchPostprocess(ctx, NULL, idDrawFBO, idReadFBO);
    551 
     593        crServerVBoxCompositionPresent(mural);
    552594        return;
    553595    }

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_window.c

    r44951 r45009  
    3131        return -1;
    3232    }
     33
     34    mural->fCompositorPresented = GL_FALSE;
    3335
    3436    /*
    … …  
    339341
    340342            /* 1. tell renderspu to stop using the current compositor (see above comment) */
    341             cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, NULL, NULL);
    342         }
     343            crServerVBoxCompositionDisable(mural);
     344        }
     345
     346        mural->fCompositorPresented = GL_FALSE;
    343347
    344348        /* 2. do necessary modifications (see above comment) */
    … …  
    359363        mural->height = height;
    360364
    361         if (cr_server.curClient && cr_server.curClient->currentMural == mural)
     365        if (cr_server.currentMural == mural)
    362366        {
    363367            crStateGetCurrent()->buffer.width = mural->width;
    … …  
    370374
    371375        /* 3. (so far not needed for resize, but in case it is in the future) re-set the compositor (see above comment) */
    372         /*
     376        /* uncomment when needed */
     377        /* NOTE: !!! we have mural->fCompositorPresented set to GL_FALSE above, so crServerVBoxCompositionReenable will have no effect in any way
    373378        if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
    374379        {
    375             cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
     380            crServerVBoxCompositionReenable(mural);
    376381        }
    377382        */
    … …  
    395400    crServerMuralSize(mural, width, height);
    396401
    397     /* Work-around Intel driver bug */
    398     CRASSERT(!cr_server.curClient
    399             || !cr_server.curClient->currentMural
    400             || cr_server.curClient->currentMural == mural);
    401     if (cr_server.curClient && cr_server.curClient->currentMural == mural)
    402     {
    403         CRContextInfo * ctxInfo = cr_server.currentCtxInfo;
    404         CRASSERT(ctxInfo);
    405         crServerDispatchMakeCurrent(window, 0, ctxInfo->CreateInfo.externalID);
     402    if (cr_server.currentMural == mural)
     403    {
     404        crServerPerformMakeCurrent( mural, cr_server.currentCtxInfo );
    406405    }
    407406}
    … …  
    433432
    434433            /* 1. tell renderspu to stop using the current compositor (see above comment) */
    435             cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, NULL, NULL);
     434            crServerVBoxCompositionDisable(mural);
    436435        }
    437436
    … …  
    443442        /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
    444443        /* CrVrScrCompositorLock(&mural->Compositor); */
    445         CrVrScrCompositorEntryPosSet(&mural->Compositor, &mural->CEntry, &Pos);
     444        /* no need to set position because the position is relative to window */
     445        /*CrVrScrCompositorEntryPosSet(&mural->Compositor, &mural->CEntry, &Pos);*/
    446446        /*CrVrScrCompositorUnlock(&mural->Compositor);*/
    447447
    … …  
    454454        if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
    455455        {
    456             cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
     456            crServerVBoxCompositionReenable(mural);
    457457        }
    458458    }
    … …  
    481481
    482482        /* 1. tell renderspu to stop using the current compositor (see above comment) */
    483         cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, NULL, NULL);
     483        crServerVBoxCompositionDisable(mural);
    484484    }
    485485
    … …  
    521521    if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
    522522    {
    523         cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
     523        crServerVBoxCompositionReenable(mural);
    524524    }
    525525}
Note: See TracChangeset for help on using the changeset viewer.

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