Changeset 45132 in vbox for trunk/src/VBox/HostServices

Timestamp:

Mar 21, 2013 4:11:28 PM (12 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

84435

Message:

crOpenGL: seamles mode support impl; bugfizes & cleanup

Location:

trunk/src/VBox/HostServices/SharedOpenGL

Files:

• crserver/crservice.cpp (modified) (1 diff)
• crserverlib/server.h (modified) (2 diffs)
• crserverlib/server_main.c (modified) (3 diffs)
• crserverlib/server_muralfbo.c (modified) (5 diffs)
• crserverlib/server_presenter.cpp (modified) (6 diffs)
• crserverlib/server_window.c (modified) (12 diffs)
• render/renderspu.c (modified) (1 diff)
• render/renderspu.h (modified) (2 diffs)
• render/renderspu_agl.c (modified) (4 diffs)
• render/renderspu_cocoa.c (modified) (2 diffs)
• render/renderspu_cocoa_helper.h (modified) (1 diff)
• render/renderspu_cocoa_helper.m (modified) (3 diffs)
• render/renderspu_glx.c (modified) (1 diff)
• render/renderspu_init.c (modified) (1 diff)
• render/renderspu_wgl.c (modified) (1 diff)

trunk/src/VBox/HostServices/SharedOpenGL/crserver/crservice.cpp

@@ -1074 +1074 @@
             Assert(sizeof(RTRECT)==4*sizeof(GLint));
 
-            rc = crVBoxServerSetRootVisibleRegion(paParms[1].u.uint32, (GLint*)paParms[0].u.pointer.addr);
+            rc = crVBoxServerSetRootVisibleRegion(paParms[1].u.uint32, (const RTRECT*)paParms[0].u.pointer.addr);
             break;
         }

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

@@ -116 +116 @@
 void crServerMuralTerm(CRMuralInfo *mural);
 void crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height);
+int crServerMuralSynchRootVr(CRMuralInfo *mural, uint32_t *pcRects, const RTRECT **ppRects);
 
 GLint crServerGenerateID(GLint *pCounter);
@@ -150 +151 @@
                 && mural->width
                 && mural->height
-                && CrVrScrCompositorEntryIsInList(&mural->CEntry);
+                && !mural->fRootVrOn ? CrVrScrCompositorEntryIsInList(&mural->CEntry) : CrVrScrCompositorEntryIsInList(&mural->RootVrCEntry);
 }
 

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

@@ -349 +349 @@
     cr_server.dummyMuralTable = crAllocHashtable();
 
+    cr_server.fRootVrOn = GL_FALSE;
+    VBoxVrListInit(&cr_server.RootVr);
+    crMemset(&cr_server.RootVrCurPoint, 0, sizeof (cr_server.RootVrCurPoint));
+
     crServerInitDispatch();
     crStateDiffAPI( &(cr_server.head_spu->dispatch_table) );
@@ -433 +437 @@
 
     cr_server.dummyMuralTable = crAllocHashtable();
+
+    cr_server.fRootVrOn = GL_FALSE;
+    VBoxVrListInit(&cr_server.RootVr);
+    crMemset(&cr_server.RootVrCurPoint, 0, sizeof (cr_server.RootVrCurPoint));
 
     crServerSetVBoxConfigurationHGCM();
@@ -2328 +2336 @@
 }
 
-DECLEXPORT(int32_t) crVBoxServerSetRootVisibleRegion(GLint cRects, GLint *pRects)
-{
-    renderspuSetRootVisibleRegion(cRects, pRects);
+static int crVBoxServerUpdateMuralRootVisibleRegion(CRMuralInfo *pMI)
+{
+    GLboolean fForcePresent;
+    uint32_t cRects;
+    const RTRECT *pRects;
+    int rc;
+
+    fForcePresent = crServerVBoxCompositionPresentNeeded(pMI);
+
+    crServerVBoxCompositionDisable(pMI);
+
+    if (cr_server.fRootVrOn)
+    {
+        if (!pMI->fRootVrOn)
+        {
+            VBOXVR_TEXTURE Tex = {0};
+
+            rc = CrVrScrCompositorInit(&pMI->RootVrCompositor);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorInit failed, rc %d", rc);
+                return rc;
+            }
+
+
+            Tex.width = pMI->width;
+            Tex.height = pMI->height;
+            Tex.target = GL_TEXTURE_2D;
+            Tex.hwid = 0;
+            CrVrScrCompositorEntryInit(&pMI->RootVrCEntry, &Tex);
+        }
+
+        rc = crServerMuralSynchRootVr(pMI, &cRects, &pRects);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("crServerMuralSynchRootVr failed, rc %d", rc);
+            return rc;
+        }
+
+        if (!pMI->fRootVrOn)
+            CrVrScrCompositorEntryTexUpdate(&pMI->RootVrCEntry,  CrVrScrCompositorEntryTexGet(&pMI->CEntry));
+    }
+    else
+    {
+        CrVrScrCompositorTerm(&pMI->RootVrCompositor);
+        rc = CrVrScrCompositorEntryRegionsGet(&pMI->Compositor, &pMI->CEntry, &cRects, NULL, &pRects);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+            return rc;
+        }
+
+        /* CEntry should always be in sync */
+//        CrVrScrCompositorEntryTexUpdate(&pMI->CEntry,  CrVrScrCompositorEntryTexGet(&pMI->RootVrCEntry));
+    }
+
+    cr_server.head_spu->dispatch_table.WindowVisibleRegion(pMI->spuWindow, cRects, pRects);
+
+    if (pMI->pvOutputRedirectInstance)
+    {
+        /* @todo the code assumes that RTRECT == four GLInts. */
+        cr_server.outputRedirect.CRORVisibleRegion(pMI->pvOutputRedirectInstance,
+                                                   cRects, pRects);
+    }
+
+    pMI->fRootVrOn = cr_server.fRootVrOn;
+
+    crServerVBoxCompositionReenable(pMI, fForcePresent);
+
+    return rc;
+}
+
+static void crVBoxServerSetRootVisibleRegionCB(unsigned long key, void *data1, void *data2)
+{
+    CRMuralInfo *pMI = (CRMuralInfo*) data1;
+
+    if (!pMI->CreateInfo.externalID)
+        return;
+    (void) data2;
+
+    crVBoxServerUpdateMuralRootVisibleRegion(pMI);
+}
+
+DECLEXPORT(int32_t) crVBoxServerSetRootVisibleRegion(GLint cRects, const RTRECT *pRects)
+{
+    int32_t rc = VINF_SUCCESS;
+
+    /* non-zero rects pointer indicate rects are present and switched on
+     * i.e. cRects==0 and pRects!=NULL means root visible regioning is ON and there are no visible regions,
+     * while pRects==NULL means root visible regioning is OFF, i.e. everything is visible */
+    if (pRects)
+    {
+        crMemset(&cr_server.RootVrCurPoint, 0, sizeof (cr_server.RootVrCurPoint));
+        rc = VBoxVrListRectsSet(&cr_server.RootVr, cRects, pRects, NULL);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("VBoxVrListRectsSet failed! rc %d", rc);
+            return rc;
+        }
+
+        cr_server.fRootVrOn = GL_TRUE;
+    }
+    else
+    {
+        if (!cr_server.fRootVrOn)
+            return VINF_SUCCESS;
+
+        VBoxVrListClear(&cr_server.RootVr);
+
+        cr_server.fRootVrOn = GL_FALSE;
+    }
+
+    crHashtableWalk(cr_server.muralTable, crVBoxServerSetRootVisibleRegionCB, NULL);
 
     return VINF_SUCCESS;

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

@@ -325 +325 @@
     SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
     CRContextInfo *pMuralContextInfo;
+    VBOXVR_TEXTURE Tex;
 
     CRASSERT(mural->aidFBOs[0]==0);
@@ -429 +430 @@
 
     CRASSERT(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
-    CrVrScrCompositorEntryTexNameUpdate(&mural->CEntry, mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
+
+    Tex.width = mural->width;
+    Tex.height = mural->height;
+    Tex.target = GL_TEXTURE_2D;
+    Tex.hwid = mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)];
+
+    CrVrScrCompositorEntryTexUpdate(&mural->CEntry, &Tex);
+
+    if (mural->fRootVrOn)
+        CrVrScrCompositorEntryTexUpdate(&mural->RootVrCEntry, &Tex);
 }
 
@@ -538 +548 @@
     crStateSwitchPrepare(NULL, curCtx, idDrawFBO, idReadFBO);
 
-    cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
+    if (!mural->fRootVrOn)
+        cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->Compositor, &mural->CEntry);
+    else
+        cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, &mural->RootVrCompositor, &mural->RootVrCEntry);
 
     crStateSwitchPostprocess(curCtx, NULL, idDrawFBO, idReadFBO);
@@ -677 +690 @@
 GLboolean crServerIsRedirectedToFBO()
 {
+#ifdef DEBUG_misha
+    Assert(cr_server.curClient);
+    if (cr_server.curClient)
+    {
+        Assert(cr_server.curClient->currentMural == cr_server.currentMural);
+        Assert(cr_server.curClient->currentCtxInfo == cr_server.currentCtxInfo);
+    }
+#endif
     return cr_server.curClient
            && cr_server.curClient->currentMural
@@ -711 +732 @@
     Assert(mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
     CrVrScrCompositorEntryTexNameUpdate(&mural->CEntry, mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
-}
+    if (mural->fRootVrOn)
+        CrVrScrCompositorEntryTexNameUpdate(&mural->RootVrCEntry, mural->aidColorTexs[CR_SERVER_FBO_FB_IDX(mural)]);
+}

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_presenter.cpp

@@ -107 +107 @@
 {
     CrVrScrCompositorLock(&pDisplay->Compositor);
-    int rc = CrVrScrCompositorEntryRegionsSet(&pDisplay->Compositor, &pEntry->CEntry, pPos, cRegions, paRegions);
+    int rc = CrVrScrCompositorEntryRegionsSet(&pDisplay->Compositor, &pEntry->CEntry, pPos, cRegions, paRegions, NULL);
     CrVrScrCompositorUnlock(&pDisplay->Compositor);
     return rc;
@@ -115 +115 @@
 {
     CrVrScrCompositorLock(&pDisplay->Compositor);
-    int rc = CrVrScrCompositorEntryRegionsAdd(&pDisplay->Compositor, &pEntry->CEntry, pPos, cRegions, paRegions);
+    int rc = CrVrScrCompositorEntryRegionsAdd(&pDisplay->Compositor, &pEntry->CEntry, pPos, cRegions, paRegions, NULL);
     CrVrScrCompositorUnlock(&pDisplay->Compositor);
     return rc;
@@ -141 +141 @@
 }
 
-void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const PVBOXVR_TEXTURE pTextureData)
+void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const VBOXVR_TEXTURE *pTextureData)
 {
     CrVrScrCompositorEntryInit(&pEntry->CEntry, pTextureData);
@@ -317 +317 @@
 
         GLuint uid = pTObj->hwid;
+        CRASSERT(uid);
         cr_server.head_spu->dispatch_table.BindTexture(pTexture->target, uid);
     }
@@ -363 +364 @@
 
         GLuint uid = pTObj->hwid;
+        CRASSERT(uid);
         cr_server.head_spu->dispatch_table.BindTexture(pTexture->target, uid);
     }
@@ -385 +387 @@
 
 void SERVER_DISPATCH_APIENTRY
-crServerDispatchVBoxTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, GLint *pRects)
+crServerDispatchVBoxTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, const GLint *pRects)
 {
     uint32_t idScreen = CR_PRESENT_GET_SCREEN(cfg);

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

@@ -24 +24 @@
     GLint spuWindow;
     VBOXVR_TEXTURE Tex = {0};
-
-    int rc = CrVrScrCompositorInit(&mural->Compositor);
+    RTRECT Rect;
+    int rc;
+
+    crMemset(mural, 0, sizeof (*mural));
+
+    rc = CrVrScrCompositorInit(&mural->Compositor);
     if (!RT_SUCCESS(rc))
     {
         crWarning("CrVrScrCompositorInit failed, rc %d", rc);
         return -1;
+    }
+
+    if (cr_server.fRootVrOn)
+    {
+        rc = CrVrScrCompositorInit(&mural->RootVrCompositor);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrVrScrCompositorInit failed, rc %d", rc);
+            return -1;
+        }
     }
 
@@ -38 +52 @@
     if (spuWindow < 0) {
         CrVrScrCompositorTerm(&mural->Compositor);
+        if (cr_server.fRootVrOn)
+            CrVrScrCompositorTerm(&mural->RootVrCompositor);
         return spuWindow;
     }
@@ -49 +65 @@
     Tex.hwid = 0;
     CrVrScrCompositorEntryInit(&mural->CEntry, &Tex);
+
+    if (cr_server.fRootVrOn)
+    {
+        CrVrScrCompositorEntryInit(&mural->RootVrCEntry, &Tex);
+        mural->fRootVrOn = GL_TRUE;
+    }
 
     defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
@@ -83 +105 @@
 
     crServerSetupOutputRedirect(mural);
+
+    Rect.xLeft = 0;
+    Rect.xRight = mural->width;
+    Rect.yTop = 0;
+    Rect.yBottom = mural->height;
+    rc = CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, 1, &Rect, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+        return -1;
+    }
+
+    if (mural->fRootVrOn)
+    {
+        uint32_t cRects;
+        const RTRECT *pRects;
+        int rc = crServerMuralSynchRootVr(mural, &cRects, &pRects);
+        if (RT_SUCCESS(rc))
+        {
+            if (cRects != 1
+                    || pRects[0].xLeft != 0 || pRects[0].yTop != 0
+                    || pRects[0].xRight != mural->width || pRects[0].yBottom != mural->height)
+            {
+                /* do visible rects only ig they differ from the default */
+                cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
+
+                if (mural->pvOutputRedirectInstance)
+                {
+                    /* @todo the code assumes that RTRECT == four GLInts. */
+                    cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance,
+                                                               cRects, pRects);
+                }
+            }
+        }
+    }
 
     return windowID;
@@ -165 +222 @@
 }
 
+static bool crServerVBoxTranslateIntersectRect(CRMuralInfo *mural, const RTRECT *pSrcRect, PRTRECT pDstRect)
+{
+    int32_t xLeft = RT_MAX(mural->gX, pSrcRect->xRight);
+    int32_t yTop = RT_MAX(mural->gY, pSrcRect->yBottom);
+    int32_t xRight = RT_MIN(mural->gX + mural->width, pSrcRect->xLeft);
+    int32_t yBottom = RT_MIN(mural->gY + mural->height, pSrcRect->yTop);
+
+    if (xLeft < xRight && yTop < yBottom)
+    {
+        pDstRect->xLeft = xLeft;
+        pDstRect->yTop = yTop;
+        pDstRect->xRight = xRight;
+        pDstRect->yBottom = yBottom;
+        return true;
+    }
+
+    return false;
+}
+
+static void crServerVBoxRootVrTranslateForMural(CRMuralInfo *mural)
+{
+    int32_t dx = cr_server.RootVrCurPoint.x - mural->gX;
+    int32_t dy = cr_server.RootVrCurPoint.y - mural->gY;
+
+    VBoxVrListTranslate(&cr_server.RootVr, dx, dy);
+}
+
 static int crServerRemoveClientWindow(CRClient *pClient, GLint window)
 {
@@ -316 +400 @@
     CrVrScrCompositorTerm(&mural->Compositor);
 
+    if (mural->fRootVrOn)
+        CrVrScrCompositorTerm(&mural->RootVrCompositor);
+
     crHashtableDelete(cr_server.muralTable, window, crFree);
 }
 
+int crServerMuralSynchRootVr(CRMuralInfo *mural, uint32_t *pcRects, const RTRECT **ppRects)
+{
+    int rc;
+
+    rc = CrVrScrCompositorEntryRegionsGet(&mural->Compositor, &mural->CEntry, pcRects, NULL, ppRects);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+        return rc;
+    }
+
+    rc = CrVrScrCompositorEntryRegionsSet(&mural->RootVrCompositor, &mural->RootVrCEntry, NULL, *pcRects, *ppRects, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+        return rc;
+    }
+
+    crServerVBoxRootVrTranslateForMural(mural);
+    rc = CrVrScrCompositorEntryListIntersect(&mural->RootVrCompositor, &mural->RootVrCEntry, &cr_server.RootVr, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+        return rc;
+    }
+
+    rc = CrVrScrCompositorEntryRegionsGet(&mural->RootVrCompositor, &mural->RootVrCEntry, pcRects, NULL, ppRects);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+        return rc;
+    }
+
+    return VINF_SUCCESS;
+}
+
 void crServerMuralSize(CRMuralInfo *mural, GLint width, GLint height)
 {
     if (mural->width != width || mural->height != height)
     {
+        uint32_t cRects;
+        const RTRECT *pRects;
         RTRECT Rect;
         VBOXVR_TEXTURE Tex;
+        int rc = VINF_SUCCESS;
         Tex.width = width;
         Tex.height = height;
@@ -346 +472 @@
         /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
         /* CrVrScrCompositorLock(&mural->Compositor); */
-        CrVrScrCompositorEntryRemove(&mural->Compositor, &mural->CEntry);
+        rc = CrVrScrCompositorEntryRemove(&mural->Compositor, &mural->CEntry);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrVrScrCompositorEntryRemove failed, rc %d", rc);
+            return;
+        }
         CrVrScrCompositorEntryInit(&mural->CEntry, &Tex);
         /* initially set regions to all visible since this is what some guest assume
@@ -354 +485 @@
         Rect.yTop = 0;
         Rect.yBottom = height;
-        CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, 1, &Rect);
+        rc = CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, 1, &Rect, NULL);
+        if (!RT_SUCCESS(rc))
+        {
+            crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+            return;
+        }
         /* CrVrScrCompositorUnlock(&mural->Compositor); */
         mural->width = width;
@@ -365 +501 @@
         }
 
+        if (mural->fRootVrOn)
+        {
+            rc = CrVrScrCompositorEntryRemove(&mural->RootVrCompositor, &mural->RootVrCEntry);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRemove failed, rc %d", rc);
+                return;
+            }
+            CrVrScrCompositorEntryInit(&mural->RootVrCEntry, &Tex);
+            /* initially set regions to all visible since this is what some guest assume
+             * and will not post any more visible regions command */
+            Rect.xLeft = 0;
+            Rect.xRight = width;
+            Rect.yTop = 0;
+            Rect.yBottom = height;
+            rc = CrVrScrCompositorEntryRegionsSet(&mural->RootVrCompositor, &mural->RootVrCEntry, NULL, 1, &Rect, NULL);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+                return;
+            }
+
+            crServerVBoxRootVrTranslateForMural(mural);
+            rc = CrVrScrCompositorEntryListIntersect(&mural->RootVrCompositor, &mural->RootVrCEntry, &cr_server.RootVr, NULL);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+                return;
+            }
+
+            rc = CrVrScrCompositorEntryRegionsGet(&mural->RootVrCompositor, &mural->RootVrCEntry, &cRects, NULL, &pRects);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+                return;
+            }
+        }
+        else
+        {
+            rc = CrVrScrCompositorEntryRegionsGet(&mural->Compositor, &mural->CEntry, &cRects, NULL, &pRects);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+                return;
+            }
+        }
+
         crServerCheckMuralGeometry(mural);
 
         cr_server.head_spu->dispatch_table.WindowSize(mural->spuWindow, width, height);
+
+        cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
+
+        if (mural->pvOutputRedirectInstance)
+        {
+            /* @todo the code assumes that RTRECT == four GLInts. */
+            cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance,
+                                                       cRects, (RTRECT *)pRects);
+        }
 
         /* 3. (so far not needed for resize, but in case it is in the future) re-set the compositor (see above comment) */
@@ -404 +596 @@
 {
     CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
-    RTPOINT Pos;
+    GLboolean fForcePresent = GL_FALSE;
     /*  crDebug("CRServer: Window %d pos %d, %d", window, x, y);*/
     if (!mural) {
@@ -427 +619 @@
         /* 2. do necessary modifications (see above comment) */
         /* NOTE: we can do it even if mural->fUseFBO == CR_SERVER_REDIR_NONE to make sure the compositor data is always up to date */
-        Pos.x = x;
-        Pos.y = y;
-
-        /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
-        /* CrVrScrCompositorLock(&mural->Compositor); */
-        /* no need to set position because the position is relative to window */
-        /*CrVrScrCompositorEntryPosSet(&mural->Compositor, &mural->CEntry, &Pos);*/
-        /*CrVrScrCompositorUnlock(&mural->Compositor);*/
-
-        mural->gX = x;
-        mural->gY = y;
+
+        if (mural->gX != x || mural->gY != y)
+        {
+            if (mural->fRootVrOn)
+            {
+                fForcePresent = crServerVBoxCompositionPresentNeeded(mural);
+            }
+
+            mural->gX = x;
+            mural->gY = y;
+
+            /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
+            /* CrVrScrCompositorLock(&mural->Compositor); */
+            /* no need to set position because the position is relative to window */
+            /*CrVrScrCompositorEntryPosSet(&mural->Compositor, &mural->CEntry, &Pos);*/
+            /*CrVrScrCompositorUnlock(&mural->Compositor);*/
+
+            if (mural->fRootVrOn)
+            {
+                uint32_t cRects;
+                const RTRECT *pRects;
+                int rc = crServerMuralSynchRootVr(mural, &cRects, &pRects);
+
+                if (RT_SUCCESS(rc))
+                {
+                    cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
+
+                    if (mural->pvOutputRedirectInstance)
+                    {
+                        /* @todo the code assumes that RTRECT == four GLInts. */
+                        cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance,
+                                                                   cRects, pRects);
+                    }
+                }
+                else
+                {
+                    crWarning("crServerMuralSynchRootVr failed, rc %d", rc);
+                }
+            }
+        }
 
         crServerCheckMuralGeometry(mural);
 
         /* 3. re-set the compositor (see above comment) */
-        crServerVBoxCompositionReenable(mural, GL_FALSE);
+        crServerVBoxCompositionReenable(mural, fForcePresent);
     }
 }
 
 void SERVER_DISPATCH_APIENTRY
-crServerDispatchWindowVisibleRegion( GLint window, GLint cRects, GLint *pRects )
+crServerDispatchWindowVisibleRegion( GLint window, GLint cRects, const GLint *pRects )
 {
     CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
     GLboolean fForcePresent = crServerVBoxCompositionPresentNeeded(mural);
+    bool fRegionsChanged = false;
+    int rc = VINF_SUCCESS;
     if (!mural) {
 #if EXTRA_WARN
@@ -470 +693 @@
 
     /* 2. do necessary modifications (see above comment) */
+    if (mural->pVisibleRects)
+    {
+        crFree(mural->pVisibleRects);
+        mural->pVisibleRects = NULL;
+    }
+
+    mural->cVisibleRects = cRects;
+    mural->bReceivedRects = GL_TRUE;
+    if (cRects)
+    {
+        mural->pVisibleRects = (GLint*) crAlloc(4*sizeof(GLint)*cRects);
+        if (!mural->pVisibleRects)
+        {
+            crError("Out of memory in crServerDispatchWindowVisibleRegion");
+        }
+        crMemcpy(mural->pVisibleRects, pRects, 4*sizeof(GLint)*cRects);
+    }
+
     /* NOTE: we can do it even if mural->fUseFBO = CR_SERVER_REDIR_NONE to make sure the compositor data is always up to date */
     /* the compositor lock is not needed actually since we have prevented renderspu from using the compositor */
     /* CrVrScrCompositorLock(&mural->Compositor); */
-    CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, cRects, (const RTRECT *)pRects);
+    rc = CrVrScrCompositorEntryRegionsSet(&mural->Compositor, &mural->CEntry, NULL, cRects, (const RTRECT *)pRects, &fRegionsChanged);
     /*CrVrScrCompositorUnlock(&mural->Compositor);*/
-
-    if (mural->pVisibleRects)
-    {
-        crFree(mural->pVisibleRects);
-        mural->pVisibleRects = NULL;
-    }
-
-    mural->cVisibleRects = cRects;
-    mural->bReceivedRects = GL_TRUE;
-    if (cRects)
-    {
-        mural->pVisibleRects = (GLint*) crAlloc(4*sizeof(GLint)*cRects);
-        if (!mural->pVisibleRects)
-        {
-            crError("Out of memory in crServerDispatchWindowVisibleRegion");
-        }
-        crMemcpy(mural->pVisibleRects, pRects, 4*sizeof(GLint)*cRects);
-    }
-
-    cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
-
-    if (mural->pvOutputRedirectInstance)
-    {
-        /* @todo the code assumes that RTRECT == four GLInts. */
-        cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance,
-                                                   cRects, (RTRECT *)pRects);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+        return;
+    }
+
+    if (fRegionsChanged)
+    {
+        if (mural->fRootVrOn)
+        {
+            rc = CrVrScrCompositorEntryRegionsSet(&mural->RootVrCompositor, &mural->RootVrCEntry, NULL, cRects, (const RTRECT *)pRects, NULL);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+                return;
+            }
+
+            crServerVBoxRootVrTranslateForMural(mural);
+            rc = CrVrScrCompositorEntryListIntersect(&mural->RootVrCompositor, &mural->RootVrCEntry, &cr_server.RootVr, NULL);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsSet failed, rc %d", rc);
+                return;
+            }
+
+            rc = CrVrScrCompositorEntryRegionsGet(&mural->RootVrCompositor, &mural->RootVrCEntry, &cRects, NULL, (const RTRECT **)&pRects);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+                return;
+            }
+        }
+        else
+        {
+            rc = CrVrScrCompositorEntryRegionsGet(&mural->Compositor, &mural->CEntry, &cRects, NULL, (const RTRECT **)&pRects);
+            if (!RT_SUCCESS(rc))
+            {
+                crWarning("CrVrScrCompositorEntryRegionsGet failed, rc %d", rc);
+                return;
+            }
+        }
+
+        cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
+
+        if (mural->pvOutputRedirectInstance)
+        {
+            /* @todo the code assumes that RTRECT == four GLInts. */
+            cr_server.outputRedirect.CRORVisibleRegion(mural->pvOutputRedirectInstance,
+                                                       cRects, (RTRECT *)pRects);
+        }
     }
 

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

@@ -597 +597 @@
 
 static void RENDER_APIENTRY
-renderspuWindowVisibleRegion(GLint win, GLint cRects, GLint *pRects)
+renderspuWindowVisibleRegion(GLint win, GLint cRects, const GLint *pRects)
 {
     WindowInfo *window;

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

@@ -378 +378 @@
 extern void renderspu_SystemGetMaxWindowSize( WindowInfo *window, GLint *w, GLint *h );
 extern void renderspu_SystemWindowPosition( WindowInfo *window, GLint x, GLint y );
-extern void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, GLint* pRects);
-extern void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window);
-#ifdef RT_OS_DARWIN
-extern void renderspu_SystemSetRootVisibleRegion(GLint cRects, GLint *pRects);
-#endif
+extern void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, const GLint* pRects);
 
 #ifdef GLX
@@ -428 +424 @@
 #endif
 DECLEXPORT(void) renderspuSetWindowId(uint64_t winId);
-DECLEXPORT(void) renderspuSetRootVisibleRegion(GLint cRects, GLint *pRects);
 DECLEXPORT(void) renderspuReparentWindow(GLint window);
 #ifdef __cplusplus

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

@@ -65 +65 @@
         DEBUG_MSG_RESULT(result, text); \
     }
+
+static void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window);
+static void renderspu_SystemSetRootVisibleRegion(GLint cRects, GLint *pRects);
 
 /* In some case (like compiz which doesn't provide us with clipping regions) we
@@ -701 +704 @@
 }
 
-void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, GLint* pRects)
+void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, const GLint* pRects)
 {
     CRASSERT(window);
@@ -736 +739 @@
 }
 
-void renderspu_SystemSetRootVisibleRegion(GLint cRects, GLint *pRects)
+static void renderspu_SystemSetRootVisibleRegion(GLint cRects, GLint *pRects)
 {
     /* Remember the visible region of the root window if there is one */
@@ -763 +766 @@
 
 /*Assumes that all regions are in the guest coordinates system*/
-void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window)
+static void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window)
 {
     ContextInfo *c = renderspuGetWindowContext(window);

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

@@ -177 +177 @@
 }
 
-void renderspu_SystemWindowVisibleRegion(WindowInfo *pWinInfo, GLint cRects, GLint* paRects)
+void renderspu_SystemWindowVisibleRegion(WindowInfo *pWinInfo, GLint cRects, const GLint* paRects)
 {
     CRASSERT(pWinInfo);
@@ -184 +184 @@
 }
 
-void renderspu_SystemSetRootVisibleRegion(GLint cRects, GLint *paRects)
-{
-}
-
 void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *pWinInfo)
 {

trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.h

@@ -46 +46 @@
 
 void cocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx);
-void cocoaViewSetVisibleRegion(NativeNSViewRef pView, GLint cRects, GLint* paRects);
+void cocoaViewSetVisibleRegion(NativeNSViewRef pView, GLint cRects, const GLint* paRects);
 void cocoaViewPresentComposition(NativeNSViewRef pView, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry);
 

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

@@ -349 +349 @@
 
 - (void)clearVisibleRegions;
-- (void)setVisibleRegions:(GLint)cRects paRects:(GLint*)paRects;
+- (void)setVisibleRegions:(GLint)cRects paRects:(const GLint*)paRects;
 
 - (NSView*)dockTileScreen;
@@ -1380 +1380 @@
 }
 
-- (void)setVisibleRegions:(GLint)cRects paRects:(GLint*)paRects
+- (void)setVisibleRegions:(GLint)cRects paRects:(const GLint*)paRects
 {
     GLint cOldRects = m_cClipRects;
@@ -1729 +1729 @@
 }
 
-void cocoaViewSetVisibleRegion(NativeNSViewRef pView, GLint cRects, GLint* paRects)
+void cocoaViewSetVisibleRegion(NativeNSViewRef pView, GLint cRects, const GLint* paRects)
 {
     NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];

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

@@ -1893 +1893 @@
 
 void
-renderspu_SystemWindowVisibleRegion( WindowInfo *window, GLint cRects, GLint *pRects )
+renderspu_SystemWindowVisibleRegion( WindowInfo *window, GLint cRects, const GLint *pRects )
 {
 #ifdef USE_OSMESA

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

@@ -538 +538 @@
     render_spu_parent_window_id = winId;
 }
-
-#ifdef RT_OS_DARWIN
-static void renderspuWindowVisibleRegionCB(unsigned long key, void *data1, void *data2)
-{
-    WindowInfo *window = (WindowInfo *) data1;
-    CRASSERT(window);
-
-    renderspu_SystemWindowApplyVisibleRegion(window);
-}
-#endif
-
-DECLEXPORT(void) renderspuSetRootVisibleRegion(GLint cRects, GLint *pRects)
-{
-#ifdef RT_OS_DARWIN
-    renderspu_SystemSetRootVisibleRegion(cRects, pRects);
-
-    crHashtableWalk(render_spu.windowTable, renderspuWindowVisibleRegionCB, NULL);
-#endif
-}
-
-#ifndef RT_OS_DARWIN
-void renderspu_SystemWindowApplyVisibleRegion(WindowInfo *window)
-{
-}
-#endif

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

@@ -1552 +1552 @@
 }
 
-void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, GLint* pRects)
+void renderspu_SystemWindowVisibleRegion(WindowInfo *window, GLint cRects, const GLint* pRects)
 {
     GLint i;