Changeset 28534 in vbox

Timestamp:

Apr 20, 2010 6:30:11 PM (15 years ago)

Author:

vboxsync

Message:

crOpenGL: add visible region support for host offscreen rendering

Location:

trunk/src/VBox

Files:

• GuestHost/OpenGL/include/cr_server.h (modified) (1 diff)
• GuestHost/OpenGL/include/state/cr_statetypes.h (modified) (1 diff)
• HostServices/SharedOpenGL/crserver/crservice.cpp (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (3 diffs)
• HostServices/SharedOpenGL/crserverlib/server_muralfbo.c (modified) (4 diffs)
• HostServices/SharedOpenGL/crserverlib/server_window.c (modified) (3 diffs)

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

@@ -61 +61 @@
     GLboolean bVisible;      /*guest window is visible*/
     GLboolean bUseFBO;       /*redirect to FBO instead of real host window*/
+
+    GLint  cVisibleRects;    /*count of visible rects*/
+    GLint *pVisibleRects;    /*visible rects left, top, right, bottom*/
 
     GLuint idFBO, idColorTex, idDepthStencilRB;

trunk/src/VBox/GuestHost/OpenGL/include/state/cr_statetypes.h

@@ -37 +37 @@
 
 typedef struct {
-        GLint x1, x2, y1, y2;
+        GLint x1, y1, x2, y2;
 } CRrecti;
 

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

@@ -69 +69 @@
 
 static const char* gszVBoxOGLSSMMagic = "***OpenGL state data***";
-#define SHCROGL_SSM_VERSION 17
+#define SHCROGL_SSM_VERSION 18
 
 static DECLCALLBACK(int) svcUnload (void *)

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

@@ -552 +552 @@
     rc = SSMR3PutMem(pSSM, pMI, sizeof(*pMI));
     CRASSERT(rc == VINF_SUCCESS);
+
+    if (pMI->pVisibleRects)
+    {
+        rc = SSMR3PutMem(pSSM, pMI->pVisibleRects, 4*sizeof(GLint)*pMI->cVisibleRects);
+    }
 }
 
@@ -852 +857 @@
         AssertRCReturn(rc, rc);
 
+        if (muralInfo.pVisibleRects)
+        {
+            muralInfo.pVisibleRects = crAlloc(4*sizeof(GLint)*muralInfo.cVisibleRects);
+            if (!muralInfo.pVisibleRects)
+            {
+                return VERR_NO_MEMORY;
+            }
+
+            rc = SSMR3GetMem(pSSM, muralInfo.pVisibleRects, 4*sizeof(GLint)*muralInfo.cVisibleRects);
+            AssertRCReturn(rc, rc);
+        }
+
         /* Restore windows geometry info */
         crServerDispatchWindowSize(key, muralInfo.width, muralInfo.height);
         crServerDispatchWindowPosition(key, muralInfo.gX, muralInfo.gY);
+        crServerDispatchWindowVisibleRegion(key, muralInfo.cVisibleRects, muralInfo.pVisibleRects);
+
+        if (muralInfo.pVisibleRects)
+        {
+            crFree(muralInfo.pVisibleRects);
+        }
     }
 
@@ -1070 +1093 @@
 DECLEXPORT(int32_t) crVBoxServerMapScreen(int sIndex, int32_t x, int32_t y, uint32_t w, uint32_t h, uint64_t winID)
 {
+    crDebug("crVBoxServerMapScreen(%i) [%i,%i:%u,%u]", sIndex, x, y, w, h);
+
     if (sIndex<0 || sIndex>=cr_server.screenCount)
         return VERR_INVALID_PARAMETER;

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

@@ -262 +262 @@
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
 
+static GLboolean crServerIntersectRect(CRrecti *a, CRrecti *b, CRrecti *rect)
+{
+    CRASSERT(a && b && rect);
+
+    rect->x1 = MAX(a->x1, b->x1);
+    rect->x2 = MIN(a->x2, b->x2);
+    rect->y1 = MAX(a->y1, b->y1);
+    rect->y2 = MIN(a->y2, b->y2);
+
+    return (rect->x2>rect->x1) && (rect->y2>rect->y1);
+}
+
 static GLboolean crServerIntersectScreen(CRMuralInfo *mural, int sId, CRrecti *rect)
 {
@@ -272 +284 @@
 }
 
+static void crServerCopySubImage(char *pDst, char* pSrc, CRrecti *pRect, int srcWidth, int srcHeight)
+{
+    int i;
+    int dstrowsize = 4*(pRect->x2-pRect->x1);
+    int srcrowsize = 4*srcWidth;
+    int height = pRect->y2-pRect->y1;
+
+    pSrc += 4*pRect->x1 + srcrowsize*(srcHeight-1-pRect->y1);
+
+    for (i=0; i<height; ++i)
+    {
+        crMemcpy(pDst, pSrc, dstrowsize);
+
+        pSrc -= srcrowsize;
+        pDst += dstrowsize;
+    }
+}
+
+static void crServerTransformRect(CRrecti *pDst, CRrecti *pSrc, int dx, int dy)
+{
+    pDst->x1 = pSrc->x1+dx;
+    pDst->x2 = pSrc->x2+dx;
+    pDst->y1 = pSrc->y1+dy;
+    pDst->y2 = pSrc->y2+dy;
+}
+
 void crServerPresentFBO(CRMuralInfo *mural)
 {
-    char *pixels, *tmppixels, *pSrc, *pDst;
+    char *pixels, *tmppixels;
     GLuint uid;
-    int i, j, rowsize, rowstride, height;
-    CRrecti rect;
+    int i, j;
+    CRrecti rect, rectwr, sectr;
     CRContext *ctx = crStateGetCurrent();
 
     CRASSERT(cr_server.pfnPresentFBO);
+
+    if (!mural->bVisible)
+    {
+        return;
+    }
 
     pixels = crAlloc(4*mural->fboWidth*mural->fboHeight);
@@ -298 +341 @@
         if (crServerIntersectScreen(mural, i, &rect))
         {
-            rowsize = 4*(rect.x2-rect.x1);
-            tmppixels = crAlloc(rowsize*(rect.y2-rect.y1));
-            
+            tmppixels = crAlloc(4*(rect.x2-rect.x1)*(rect.y2-rect.y1));
             if (!tmppixels)
             {
@@ -307 +348 @@
                 return;
             }
-            rowstride = 4*mural->fboWidth;
-            height = rect.y2-rect.y1;
-
-            pSrc = pixels + 4*(rect.x1-mural->gX) + rowstride*(rect.y2-mural->gY-1);
-            pDst = tmppixels;
-
-            for (j=0; j<height; ++j)
-            {
-                crMemcpy(pDst, pSrc, rowsize);
-
-                pSrc -= rowstride;
-                pDst += rowsize;
-            }
-
-            cr_server.pfnPresentFBO(tmppixels, i, rect.x1-cr_server.screen[i].x, rect.y1-cr_server.screen[i].y, rect.x2-rect.x1, height);
+
+            /* rect in window relative coords */
+            crServerTransformRect(&rectwr, &rect, -mural->gX, -mural->gY);
+
+            if (!mural->pVisibleRects)
+            {
+                crServerCopySubImage(tmppixels, pixels, &rectwr, mural->fboWidth, mural->fboHeight);
+                cr_server.pfnPresentFBO(tmppixels, i, rect.x1-cr_server.screen[i].x, rect.y1-cr_server.screen[i].y, rect.x2-rect.x1, rect.y2-rect.y1);
+            }
+            else
+            {
+                for (j=0; j<mural->cVisibleRects; ++j)
+                {
+                    if (crServerIntersectRect(&rectwr, (CRrecti*) &mural->pVisibleRects[4*j], &sectr))
+                    {
+                        crServerCopySubImage(tmppixels, pixels, &sectr, mural->fboWidth, mural->fboHeight);
+                        cr_server.pfnPresentFBO(tmppixels, i,
+                                                sectr.x1+mural->gX-cr_server.screen[i].x,
+                                                sectr.y1+mural->gY-cr_server.screen[i].y,
+                                                sectr.x2-sectr.x1, sectr.y2-sectr.y1);
+                    }
+                }
+            }
 
             crFree(tmppixels);

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

@@ -84 +84 @@
         mural->bUseFBO = GL_FALSE;
 
+        mural->cVisibleRects = 0;
+        mural->pVisibleRects = NULL;
+
         /* generate ID for this new window/mural (special-case for file conns) */
         if (cr_server.curClient && cr_server.curClient->conn->type == CR_FILE)
@@ -182 +185 @@
 
     crHashtableDelete(cr_server.pWindowCreateInfoTable, window, crServerCreateInfoDeleteCB);
+
+    if (mural->pVisibleRects)
+    {
+        crFree(mural->pVisibleRects);
+    }
     crHashtableDelete(cr_server.muralTable, window, crFree);
 }
@@ -237 +245 @@
          return;
     }
+
+    if (mural->pVisibleRects)
+    {
+        crFree(mural->pVisibleRects);
+        mural->pVisibleRects = NULL;
+    }
+
+    mural->cVisibleRects = cRects;
+    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);
 }