VirtualBox

Ignore:
Timestamp:
Jul 31, 2013 12:44:53 PM (11 years ago)
Author:
vboxsync
Message:

crOpenGL: 3d data visibility notifications, bugfixes

Location:
trunk/src/VBox/HostServices/SharedOpenGL/crserverlib
Files:
5 edited

Legend:

Unmodified
Added
Removed

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

    r46885 r47485  
    133133GLboolean crServerSupportRedirMuralFBO(void);
    134134
    135 void crVBoxServerNotifyEvent(int32_t idScreen);
     135void crVBoxServerNotifyEvent(int32_t idScreen, uint32_t uEvent, void*pvData);
    136136void crServerDisplayTermAll();
     137
     138void crServerWindowSize(CRMuralInfo *pMural);
     139void crServerWindowShow(CRMuralInfo *pMural);
     140void crServerWindowVisibleRegion(CRMuralInfo *pMural);
     141
     142void crServerWindowSetIsVisible(CRMuralInfo *pMural, GLboolean fIsVisible);
     143void crServerWindowCheckIsVisible(CRMuralInfo *pMural);
    137144
    138145#define CR_SERVER_REDIR_F_NONE     0x00

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

    r46801 r47485  
    5959    cr_server.bWindowsInitiallyHidden = GL_FALSE;
    6060
    61     memset(cr_server.NotifyEventMap, 0, sizeof (cr_server.NotifyEventMap));
    62     cr_server.cDisableEvent = 0;
     61    memset(cr_server.acVisibleWindows, 0, sizeof (cr_server.acVisibleWindows));
     62
    6363    cr_server.pfnNotifyEventCB = NULL;
    6464}

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

    r47158 r47485  
    26402640}
    26412641
    2642 void crVBoxServerNotifyEvent(int32_t idScreen)
     2642void crVBoxServerNotifyEvent(int32_t idScreen, uint32_t uEvent, void*pvData)
    26432643{
    26442644    /* this is something unexpected, but just in case */
    … …  
    26492649    }
    26502650
    2651     if (!cr_server.cDisableEvent)
    2652         cr_server.pfnNotifyEventCB(idScreen, VBOX3D_NOTIFY_EVENT_TYPE_VISIBLE_WINDOW, NULL);
    2653     else
    2654         ASMBitSet(cr_server.NotifyEventMap, idScreen);
     2651    cr_server.pfnNotifyEventCB(idScreen, uEvent, pvData);
    26552652}
    26562653
    … …  
    26692666
    26702667        renderspuReparentWindow(pMI->spuWindow);
    2671 
    2672         if (pMI->bVisible && (pMI->fPresentMode & CR_SERVER_REDIR_F_DISPLAY) && pMI->fHasParentWindow)
    2673             crVBoxServerNotifyEvent(pMI->screenId);
    26742668
    26752669        crServerVBoxCompositionDisableLeave(pMI, GL_FALSE);
    … …  
    28272821            goto end;
    28282822        }
    2829 
    2830         rc = CrVrScrCompositorRegionsGet(&pMI->RootVrCompositor, &cRects, NULL, &pRects, NULL);
    2831         if (!RT_SUCCESS(rc))
    2832         {
    2833             crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
    2834             goto end;
    2835         }
    28362823    }
    28372824    else
    28382825    {
    28392826        CrVrScrCompositorClear(&pMI->RootVrCompositor);
    2840         rc = CrVrScrCompositorRegionsGet(&pMI->Compositor, &cRects, NULL, &pRects, NULL);
    2841         if (!RT_SUCCESS(rc))
    2842         {
    2843             crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
    2844             goto end;
    2845         }
    2846     }
    2847 
    2848     cr_server.head_spu->dispatch_table.WindowVisibleRegion(pMI->spuWindow, cRects, (const GLint*)pRects);
     2827    }
    28492828
    28502829    pMI->fRootVrOn = cr_server.fRootVrOn;
     2830
     2831    crServerWindowVisibleRegion(pMI);
    28512832
    28522833end:

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

    r47158 r47485  
    149149            primaryS = 0;
    150150        }
     151        else
     152        {
     153            Assert(brS == tlS);
     154
     155            primaryS = brS;
     156        }
     157
    151158
    152159        Assert(brS == tlS);
    … …  
    186193    }
    187194
     195    CRASSERT(primaryS >= 0);
     196
    188197    winID = overlappingScreenCount ? cr_server.screen[primaryS].winID : 0;
    189198
    … …  
    196205        renderspuReparentWindow(mural->spuWindow);
    197206        renderspuSetWindowId(cr_server.screen[0].winID);
    198 
    199         if (mural->bVisible && (mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY) && mural->fHasParentWindow)
    200             crVBoxServerNotifyEvent(mural->screenId);
    201     }
    202 
    203     mural->screenId = primaryS;
     207    }
     208
     209    if (primaryS != mural->screenId)
     210    {
     211        /* mark it invisible on the old screen */
     212        crServerWindowSetIsVisible(mural, GL_FALSE);
     213        mural->screenId = primaryS;
     214        /* check if mural is visivle on the new screen, and mark it as such */
     215        crServerWindowCheckIsVisible(mural);
     216    }
    204217
    205218    mural->hX = mural->gX-cr_server.screen[primaryS].x;
    … …  
    207220
    208221    fPresentMode = cr_server.fPresentMode;
     222
     223    if (!mural->fHasParentWindow)
     224        fPresentMode &= ~CR_SERVER_REDIR_F_DISPLAY;
     225
    209226    if (!overlappingScreenCount)
    210227        fPresentMode &= ~CR_SERVER_REDIR_F_DISPLAY;
    … …  
    360377        if (!(mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY))
    361378        {
    362             if  (mural->bVisible && mural->fHasParentWindow)
    363             {
    364                 cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, GL_TRUE);
    365                 crVBoxServerNotifyEvent(mural->screenId);
    366             }
    367379            mural->fPresentMode |= CR_SERVER_REDIR_F_DISPLAY;
     380
     381            if  (mural->bVisible)
     382                crServerWindowShow(mural);
    368383        }
    369384    }
    … …  
    372387        if ((mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY))
    373388        {
     389            mural->fPresentMode &= ~CR_SERVER_REDIR_F_DISPLAY;
     390
    374391            if (mural->bVisible)
    375                 cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, GL_FALSE);
    376             mural->fPresentMode &= ~CR_SERVER_REDIR_F_DISPLAY;
     392                crServerWindowShow(mural);
    377393        }
    378394    }
    … …  
    765781DECLEXPORT(void) crServerVBoxCompositionSetEnableStateGlobal(GLboolean fEnable)
    766782{
    767     if (!fEnable)
    768         ++cr_server.cDisableEvent;
    769 
    770783    crHashtableWalk(cr_server.muralTable, crServerVBoxCompositionSetEnableStateGlobalCB, (void*)(uintptr_t)fEnable);
    771784
    772785    crHashtableWalk(cr_server.dummyMuralTable, crServerVBoxCompositionSetEnableStateGlobalCB, (void*)(uintptr_t)fEnable);
    773 
    774     if (fEnable)
    775     {
    776         --cr_server.cDisableEvent;
    777         CRASSERT(cr_server.cDisableEvent < UINT32_MAX/2);
    778         if(!cr_server.cDisableEvent)
    779         {
    780             int i;
    781             for (i = 0; i < cr_server.screenCount; ++i)
    782             {
    783                 if (!ASMBitTest(cr_server.NotifyEventMap, i))
    784                     continue;
    785 
    786                 cr_server.pfnNotifyEventCB(i, VBOX3D_NOTIFY_EVENT_TYPE_VISIBLE_WINDOW, NULL);
    787 
    788                 ASMBitClear(cr_server.NotifyEventMap, i);
    789             }
    790         }
    791     }
    792786}
    793787

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

    r46990 r47485  
    1010#include "cr_rand.h"
    1111#include "cr_string.h"
     12
     13static GLboolean crServerWindowCalcIsVisible(CRMuralInfo *pMural)
     14{
     15    uint32_t cRegions;
     16    int rc;
     17    if (!pMural->width || !pMural->height)
     18        return GL_FALSE;
     19
     20    if (!pMural->bVisible || !(pMural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY))
     21        return GL_FALSE;
     22
     23    rc = CrVrScrCompositorRegionsGet(pMural->fRootVrOn ? &pMural->RootVrCompositor : &pMural->Compositor, &cRegions, NULL, NULL, NULL);
     24    if (RT_FAILURE(rc))
     25    {
     26        crWarning("CrVrScrCompositorRegionsGet failed, rc %d", rc);
     27        return GL_FALSE;
     28    }
     29
     30    if (!cRegions)
     31        return GL_FALSE;
     32
     33    return GL_TRUE;
     34}
     35
     36void crServerWindowSetIsVisible(CRMuralInfo *pMural, GLboolean fIsVisible)
     37{
     38    if (!fIsVisible == !pMural->fIsVisible)
     39        return;
     40
     41    pMural->fIsVisible = fIsVisible;
     42
     43    CRASSERT(pMural->screenId < RT_ELEMENTS(cr_server.acVisibleWindows));
     44
     45    if (fIsVisible)
     46    {
     47        ++cr_server.acVisibleWindows[pMural->screenId];
     48        if (cr_server.acVisibleWindows[pMural->screenId] == 1)
     49            crVBoxServerNotifyEvent(pMural->screenId, VBOX3D_NOTIFY_EVENT_TYPE_VISIBLE_3DDATA, (void*)1);
     50    }
     51    else
     52    {
     53        --cr_server.acVisibleWindows[pMural->screenId];
     54        CRASSERT(cr_server.acVisibleWindows[pMural->screenId] < UINT32_MAX/2);
     55        if (cr_server.acVisibleWindows[pMural->screenId] == 0)
     56            crVBoxServerNotifyEvent(pMural->screenId, VBOX3D_NOTIFY_EVENT_TYPE_VISIBLE_3DDATA, NULL);
     57    }
     58}
     59
     60void crServerWindowCheckIsVisible(CRMuralInfo *pMural)
     61{
     62    GLboolean fIsVisible = crServerWindowCalcIsVisible(pMural);
     63
     64    crServerWindowSetIsVisible(pMural, fIsVisible);
     65}
     66
     67void crServerWindowSize(CRMuralInfo *pMural)
     68{
     69    cr_server.head_spu->dispatch_table.WindowSize(pMural->spuWindow, pMural->width, pMural->height);
     70
     71    crServerWindowCheckIsVisible(pMural);
     72}
     73
     74void crServerWindowShow(CRMuralInfo *pMural)
     75{
     76    cr_server.head_spu->dispatch_table.WindowShow(pMural->spuWindow,
     77            !!(pMural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY) && pMural->bVisible);
     78
     79    crServerWindowCheckIsVisible(pMural);
     80}
     81
     82void crServerWindowVisibleRegion(CRMuralInfo *pMural)
     83{
     84    uint32_t cRects;
     85    const RTRECT *pRects;
     86    int rc = CrVrScrCompositorRegionsGet(pMural->fRootVrOn ? &pMural->RootVrCompositor : &pMural->Compositor, &cRects, NULL, &pRects, NULL);
     87    if (RT_SUCCESS(rc))
     88    {
     89        cr_server.head_spu->dispatch_table.WindowVisibleRegion(pMural->spuWindow, cRects, (const GLint*)pRects);
     90
     91        crServerWindowCheckIsVisible(pMural);
     92    }
     93    else
     94        crWarning("CrVrScrCompositorRegionsGet failed rc %d", rc);
     95
     96}
    1297
    1398GLint SERVER_DISPATCH_APIENTRY
    … …  
    128213                        || pRects[0].xRight != mural->width || pRects[0].yBottom != mural->height)
    129214                {
    130                     /* do visible rects only ig they differ from the default */
    131                     cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, (const GLint*)pRects);
     215                    /* do visible rects only if they differ from the default */
     216                    crServerWindowVisibleRegion(mural);
    132217                }
    133218            }
    … …  
    435520void crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height)
    436521{
    437     uint32_t cRects;
    438     const RTRECT *pRects;
    439522    RTRECT Rect;
    440523    VBOXVR_TEXTURE Tex;
    … …  
    515598    }
    516599
    517     rc = CrVrScrCompositorRegionsGet(&mural->Compositor, &cRects, NULL, &pRects, NULL);
    518     if (!RT_SUCCESS(rc))
    519     {
    520         crWarning("CrVrScrCompositorRegionsGet failed, rc %d", rc);
    521         goto end;
    522     }
    523 
    524600    if (mural->fRootVrOn)
    525601    {
    … …  
    530606            goto end;
    531607        }
    532 
    533         rc = CrVrScrCompositorRegionsGet(&mural->RootVrCompositor, &cRects, NULL, &pRects, NULL);
    534         if (!RT_SUCCESS(rc))
    535         {
    536             crWarning("CrVrScrCompositorRegionsGet failed, rc %d", rc);
    537             goto end;
    538         }
    539608    }
    540609
    541610    crServerCheckMuralGeometry(mural);
    542611
    543     cr_server.head_spu->dispatch_table.WindowSize(mural->spuWindow, width, height);
    544 
    545     cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, (const GLint*)pRects);
     612    crServerWindowSize(mural);
     613
     614    crServerWindowVisibleRegion(mural);
    546615
    547616    if (mural->pvOutputRedirectInstance)
    548617    {
     618        uint32_t cRects;
     619        const RTRECT *pRects;
     620
    549621        /* always get non-stretched rects for output redirect */
    550622//        if (mural->fRootVrOn)
    … …  
    635707                if (RT_SUCCESS(rc))
    636708                {
    637                     rc = CrVrScrCompositorRegionsGet(&mural->RootVrCompositor, &cRects, NULL, &pRects, NULL);
    638                     if (RT_SUCCESS(rc))
    639                     {
    640                         cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, (const GLint*)pRects);
    641                     }
    642                     else
    643                     {
    644                         crWarning("CrVrScrCompositorRegionsGet failed, rc %d", rc);
    645                     }
     709                    crServerWindowVisibleRegion(mural);
    646710                }
    647711                else
    … …  
    728792    if (fRegionsChanged)
    729793    {
    730         const RTRECT * pRealRects;
    731         uint32_t cRealRects;
    732 
    733794        if (mural->fRootVrOn)
    734795        {
    … …  
    739800                goto end;
    740801            }
    741 
    742             rc = CrVrScrCompositorRegionsGet(&mural->RootVrCompositor, &cRealRects, NULL, &pRealRects, NULL);
     802        }
     803
     804        crServerWindowVisibleRegion(mural);
     805
     806        if (mural->pvOutputRedirectInstance)
     807        {
     808            const RTRECT * pRealRects;
     809            uint32_t cRealRects;
     810
     811            /* always get unstretched regions here */
     812            rc = CrVrScrCompositorRegionsGet(&mural->Compositor, &cRealRects, NULL, NULL, &pRealRects);
    743813            if (!RT_SUCCESS(rc))
    744814            {
    … …  
    746816                goto end;
    747817            }
    748         }
    749         else
    750         {
    751             rc = CrVrScrCompositorRegionsGet(&mural->Compositor, &cRealRects, NULL, &pRealRects, NULL);
    752             if (!RT_SUCCESS(rc))
    753             {
    754                 crWarning("CrVrScrCompositorRegionsGet failed, rc %d", rc);
    755                 goto end;
    756             }
    757         }
    758 
    759         cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRealRects, (const GLint*)pRealRects);
    760 
    761         if (mural->pvOutputRedirectInstance)
    762         {
    763 //            if (mural->fRootVrOn)
    764             {
    765                 /* always get unstretched regions here */
    766                 rc = CrVrScrCompositorRegionsGet(&mural->Compositor, &cRealRects, NULL, NULL, &pRealRects);
    767                 if (!RT_SUCCESS(rc))
    768                 {
    769                     crWarning("CrVrScrCompositorRegionsGet failed, rc %d", rc);
    770                     goto end;
    771                 }
    772             }
     818
    773819            /* @todo the code assumes that RTRECT == four GLInts. */
    774820            cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance, cRealRects, pRealRects);
    … …  
    796842void crServerMuralShow( CRMuralInfo *mural, GLint state )
    797843{
     844    mural->bVisible = !!state;
     845
    798846    if (mural->fPresentMode & CR_SERVER_REDIR_F_DISPLAY)
    799     {
    800         cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, state);
    801 
    802         if (state && mural->fHasParentWindow)
    803             crVBoxServerNotifyEvent(mural->screenId);
    804     }
    805 
    806     mural->bVisible = !!state;
     847        crServerWindowShow(mural);
    807848}
    808849
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