Changeset 45132 in vbox for trunk/src/VBox/GuestHost/OpenGL

Timestamp:

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

Author:

vboxsync

Message:

crOpenGL: seamles mode support impl; bugfizes & cleanup

Location:

trunk/src/VBox/GuestHost/OpenGL

Files:

• glapi_parser/APIspec.txt (modified) (2 diffs)
• include/chromium.h (modified) (1 diff)
• include/cr_blitter.h (modified) (1 diff)
• include/cr_server.h (modified) (4 diffs)
• include/cr_vreg.h (modified) (9 diffs)
• packer/pack_visibleregion.c (modified) (2 diffs)
• util/blitter.cpp (modified) (4 diffs)
• util/vreg.cpp (modified) (25 diffs)

trunk/src/VBox/GuestHost/OpenGL/glapi_parser/APIspec.txt

@@ -8367 +8367 @@
 param       window      GLint
 param       cRects      GLint
-param       pRects      GLint *
+param       pRects      const GLint *
 category    Chromium
 props       nolist
@@ -8379 +8379 @@
 param       yPos        GLint
 param       cRects      GLint
-param       pRects      GLint *
+param       pRects      const GLint *
 category    Chromium
 props       nolist

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

@@ -772 +772 @@
 extern void APIENTRY crWindowSize(GLint window, GLint w, GLint h);
 extern void APIENTRY crWindowPosition(GLint window, GLint x, GLint y);
-extern void APIENTRY crWindowVisibleRegion( GLint window, GLint cRects, void *pRects );
+extern void APIENTRY crWindowVisibleRegion( GLint window, GLint cRects, const void *pRects );
 extern void APIENTRY crWindowShow( GLint window, GLint flag );
-extern void APIENTRY crVBoxTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, GLint *pRects);
+extern void APIENTRY crVBoxTexPresent(GLuint texture, GLuint cfg, GLint xPos, GLint yPos, GLint cRects, const GLint *pRects);
 
 typedef int (CR_APIENTRY *CR_PROC)();

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

@@ -54 +54 @@
 struct CR_BLITTER;
 
-typedef DECLCALLBACK(int) FNCRBLT_BLITTER(struct CR_BLITTER *pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRect, const PRTRECTSIZE pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags);
+typedef DECLCALLBACK(int) FNCRBLT_BLITTER(struct CR_BLITTER *pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRect, const RTRECTSIZE *pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags);
 typedef FNCRBLT_BLITTER *PFNCRBLT_BLITTER;
 

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

@@ -125 +125 @@
     GLuint idPBO;
 
+    GLboolean fRootVrOn;
+
     VBOXVR_SCR_COMPOSITOR_ENTRY CEntry;
     VBOXVR_SCR_COMPOSITOR Compositor;
+
+    /* if root Visible regions are set, these two contain actual regions being passed to render spu */
+    VBOXVR_SCR_COMPOSITOR_ENTRY RootVrCEntry;
+    VBOXVR_SCR_COMPOSITOR RootVrCompositor;
 
     /* bitfield representing contexts the mural has been ever current with
@@ -220 +226 @@
 void CrDpResize(PCR_DISPLAY pDisplay, uint32_t width, uint32_t height,
         uint32_t stretchedWidth, uint32_t stretchedHeight);
-void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const PVBOXVR_TEXTURE pTextureData);
+void CrDpEntryInit(PCR_DISPLAY_ENTRY pEntry, const VBOXVR_TEXTURE *pTextureData);
 void CrDpEntryCleanup(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry);
 int CrDpEntryRegionsSet(PCR_DISPLAY pDisplay, PCR_DISPLAY_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
@@ -303 +309 @@
     /* visBits -> dummy mural association */
     CRHashTable *dummyMuralTable;
+
+    GLboolean fRootVrOn;
+    VBOXVR_LIST RootVr;
+    /* we need to translate Root Vr to each window coords, this one cpecifies the current translation point
+     * note that since window attributes modifications is performed in HGCM thread only and thus is serialized,
+     * we deal with the global RootVr data directly */
+    RTPOINT RootVrCurPoint;
 
     /** configuration options */
@@ -400 +413 @@
 extern DECLEXPORT(int32_t) crVBoxServerMapScreen(int sIndex, int32_t x, int32_t y, uint32_t w, uint32_t h, uint64_t winID);
 
-extern DECLEXPORT(int32_t) crVBoxServerSetRootVisibleRegion(GLint cRects, GLint *pRects);
+extern DECLEXPORT(int32_t) crVBoxServerSetRootVisibleRegion(GLint cRects, const RTRECT *pRects);
 
 extern DECLEXPORT(void) crVBoxServerSetPresentFBOCB(PFNCRSERVERPRESENTFBO pfnPresentFBO);

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

@@ -47 +47 @@
 }
 
+DECLINLINE(void) VBoxRectIntersect(PRTRECT pRect1, const RTRECT * pRect2)
+{
+    Assert(pRect1);
+    Assert(pRect2);
+    pRect1->xLeft = RT_MAX(pRect1->xLeft, pRect2->xLeft);
+    pRect1->yTop = RT_MAX(pRect1->yTop, pRect2->yTop);
+    pRect1->xRight = RT_MIN(pRect1->xRight, pRect2->xRight);
+    pRect1->yBottom = RT_MIN(pRect1->yBottom, pRect2->yBottom);
+}
+
+DECLINLINE(void) VBoxRectIntersected(const RTRECT *pRect1, const RTRECT * pRect2, RTRECT *pResult)
+{
+    *pResult = *pRect1;
+    VBoxRectIntersect(pResult, pRect2);
+}
+
+
 DECLINLINE(void) VBoxRectTranslate(RTRECT * pRect, int32_t x, int32_t y)
 {
@@ -93 +110 @@
 }
 
-DECLINLINE(uint32_t) VBoxVrListRectsCount(PVBOXVR_LIST pList)
+DECLINLINE(uint32_t) VBoxVrListRectsCount(const VBOXVR_LIST *pList)
 {
     return pList->cEntries;
 }
 
-DECLINLINE(bool) VBoxVrListIsEmpty(const PVBOXVR_LIST pList)
+DECLINLINE(bool) VBoxVrListIsEmpty(const VBOXVR_LIST *pList)
 {
     return !VBoxVrListRectsCount(pList);
@@ -115 +132 @@
 VBOXVREGDECL(int) VBoxVrListCmp(PVBOXVR_LIST pList1, PVBOXVR_LIST pList2);
 
+VBOXVREGDECL(int) VBoxVrListRectsSet(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged);
 VBOXVREGDECL(int) VBoxVrListRectsAdd(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged);
 VBOXVREGDECL(int) VBoxVrListRectsSubst(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged);
 VBOXVREGDECL(int) VBoxVrListRectsGet(PVBOXVR_LIST pList, uint32_t cRects, RTRECT * aRects);
+
+/* NOTE: with the current implementation the VBoxVrListIntersect is faster than VBoxVrListRectsIntersect,
+ * i.e. VBoxVrListRectsIntersect is actually a convenience function that create a temporary list and calls VBoxVrListIntersect internally */
+VBOXVREGDECL(int) VBoxVrListRectsIntersect(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged);
+VBOXVREGDECL(int) VBoxVrListIntersect(PVBOXVR_LIST pList, const VBOXVR_LIST *pList2, bool *pfChanged);
 
 VBOXVREGDECL(int) VBoxVrInit();
@@ -177 +200 @@
 VBOXVREGDECL(void) VBoxVrCompositorTerm(PVBOXVR_COMPOSITOR pCompositor);
 VBOXVREGDECL(void) VBoxVrCompositorEntryInit(PVBOXVR_COMPOSITOR_ENTRY pEntry);
-DECLINLINE(bool) VBoxVrCompositorEntryIsInList(const PVBOXVR_COMPOSITOR_ENTRY pEntry)
+DECLINLINE(bool) VBoxVrCompositorEntryIsInList(const VBOXVR_COMPOSITOR_ENTRY *pEntry)
 {
     return !VBoxVrListIsEmpty(&pEntry->Vr);
 }
 
-#define VBOXVR_COMPOSITOR_CF_ENTRIES_REGIONS_CHANGED    0x00000001
-#define VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED 0x00000002
-#define VBOXVR_COMPOSITOR_CF_ENTRY_ADDED                0x00000004
+/* compositor regions changed
+ * always comes with VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED */
+#define VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED             0x00000001
+/* only current entry regions changed */
+#define VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED       0x00000002
+/* the given entry has replaced some other entry, while overal regions did NOT change.
+ * always comes with VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED */
+#define VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED              0x00000004
 
 
@@ -191 +219 @@
 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsSubst(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsSet(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
+VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
+VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged);
+VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersectAll(PVBOXVR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
+VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersectAll(PVBOXVR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged);
 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsTranslate(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, int32_t x, int32_t y, bool *pfChanged);
 VBOXVREGDECL(void) VBoxVrCompositorVisit(PVBOXVR_COMPOSITOR pCompositor, PFNVBOXVRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor);
 
-DECLINLINE(bool) VBoxVrCompositorIsEmpty(const PVBOXVR_COMPOSITOR pCompositor)
+DECLINLINE(bool) VBoxVrCompositorIsEmpty(const VBOXVR_COMPOSITOR *pCompositor)
 {
     return RTListIsEmpty(&pCompositor->List);
@@ -261 +293 @@
 typedef FNVBOXVRSCRCOMPOSITOR_VISITOR *PFNVBOXVRSCRCOMPOSITOR_VISITOR;
 
-DECLINLINE(void) CrVrScrCompositorEntryInit(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const PVBOXVR_TEXTURE pTex)
+DECLINLINE(void) CrVrScrCompositorEntryInit(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_TEXTURE *pTex)
 {
     VBoxVrCompositorEntryInit(&pEntry->Ce);
@@ -268 +300 @@
 }
 
-DECLINLINE(bool) CrVrScrCompositorEntryIsUsed(const PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
+DECLINLINE(bool) CrVrScrCompositorEntryIsUsed(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
 {
     return VBoxVrCompositorEntryIsInList(&pEntry->Ce);
@@ -284 +316 @@
 }
 
-DECLINLINE(bool) CrVrScrCompositorEntryIsChanged(const PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
+DECLINLINE(void) CrVrScrCompositorEntryTexUpdate(PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_TEXTURE *pTex)
+{
+    pEntry->Tex = *pTex;
+    CrVrScrCompositorEntrySetChanged(pEntry, true);
+}
+
+DECLINLINE(const VBOXVR_TEXTURE *) CrVrScrCompositorEntryTexGet(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
+{
+    return &pEntry->Tex;
+}
+
+DECLINLINE(bool) CrVrScrCompositorEntryIsChanged(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
 {
     return !!pEntry->fChanged;
 }
 
-DECLINLINE(bool) CrVrScrCompositorIsEmpty(const PVBOXVR_SCR_COMPOSITOR pCompositor)
+DECLINLINE(bool) CrVrScrCompositorIsEmpty(const VBOXVR_SCR_COMPOSITOR *pCompositor)
 {
     return VBoxVrCompositorIsEmpty(&pCompositor->Compositor);
@@ -296 +339 @@
 VBOXVREGDECL(void) CrVrScrCompositorVisit(PVBOXVR_SCR_COMPOSITOR pCompositor, PFNVBOXVRSCRCOMPOSITOR_VISITOR pfnVisitor, void *pvVisitor);
 VBOXVREGDECL(void) CrVrScrCompositorEntrySetAllChanged(PVBOXVR_SCR_COMPOSITOR pCompositor, bool fChanged);
-DECLINLINE(bool) CrVrScrCompositorEntryIsInList(const PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry)
+DECLINLINE(bool) CrVrScrCompositorEntryIsInList(const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry)
 {
     return VBoxVrCompositorEntryIsInList(&pEntry->Ce);
 }
-VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
-VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions);
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, uint32_t *pfChangeFlags);
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
+VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged);
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged);
+VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged);
 VBOXVREGDECL(int) CrVrScrCompositorEntryPosSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos);
 

trunk/src/VBox/GuestHost/OpenGL/packer/pack_visibleregion.c

@@ -23 +23 @@
 #endif
 
-void PACK_APIENTRY crPackWindowVisibleRegion( CR_PACKER_CONTEXT_ARGDECL GLint window, GLint cRects, GLint * pRects )
+void PACK_APIENTRY crPackWindowVisibleRegion( CR_PACKER_CONTEXT_ARGDECL GLint window, GLint cRects, const GLint * pRects )
 {
     GLint i, size, cnt;
@@ -50 +50 @@
 }
 
-void PACK_APIENTRY crPackWindowVisibleRegionSWAP( CR_PACKER_CONTEXT_ARGDECL  GLint window, GLint cRects, GLint * pRects )
+void PACK_APIENTRY crPackWindowVisibleRegionSWAP( CR_PACKER_CONTEXT_ARGDECL  GLint window, GLint cRects, const GLint * pRects )
 {
     crError( "crPackWindowVisibleRegionSWAP unimplemented and shouldn't be called" );

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

@@ -81 +81 @@
 #define CRBLT_FILTER_FROM_FLAGS(_f) (((_f) & CRBLT_F_LINEAR) ? GL_LINEAR : GL_NEAREST)
 
-static DECLCALLBACK(int) crBltBlitTexBufImplFbo(PCR_BLITTER pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRect, const PRTRECTSIZE pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags)
+static DECLCALLBACK(int) crBltBlitTexBufImplFbo(PCR_BLITTER pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRect, const RTRECTSIZE *pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags)
 {
     GLenum filter = CRBLT_FILTER_FROM_FLAGS(fFlags);
@@ -269 +269 @@
 }
 
-static void crBltCheckSetupViewport(PCR_BLITTER pBlitter, const PRTRECTSIZE pDstSize, bool fFBODraw)
+static void crBltCheckSetupViewport(PCR_BLITTER pBlitter, const RTRECTSIZE *pDstSize, bool fFBODraw)
 {
     if (!pBlitter->Flags.LastWasFBODraw != !fFBODraw
@@ -308 +308 @@
 }
 
-static DECLCALLBACK(int) crBltBlitTexBufImplDraw2D(PCR_BLITTER pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRect, const PRTRECTSIZE pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags)
+static DECLCALLBACK(int) crBltBlitTexBufImplDraw2D(PCR_BLITTER pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRect, const RTRECTSIZE *pDstSize, const RTRECT *paDstRect, uint32_t cRects, uint32_t fFlags)
 {
     GLuint normalX, normalY;
@@ -515 +515 @@
 }
 
-static void crBltBlitTexBuf(PCR_BLITTER pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRects, GLenum enmDstBuff, const PRTRECTSIZE pDstSize, const RTRECT *paDstRects, uint32_t cRects, uint32_t fFlags)
+static void crBltBlitTexBuf(PCR_BLITTER pBlitter, VBOXVR_TEXTURE *pSrc, const RTRECT *paSrcRects, GLenum enmDstBuff, const RTRECTSIZE *pDstSize, const RTRECT *paDstRects, uint32_t cRects, uint32_t fFlags)
 {
     pBlitter->pDispatch->DrawBuffer(enmDstBuff);

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

@@ -113 +113 @@
 }
 
-typedef DECLCALLBACK(int) FNVBOXVR_CB_COMPARATOR(const PVBOXVR_REG pReg1, const PVBOXVR_REG pReg2);
+typedef DECLCALLBACK(int) FNVBOXVR_CB_COMPARATOR(const VBOXVR_REG *pReg1, const VBOXVR_REG *pReg2);
 typedef FNVBOXVR_CB_COMPARATOR *PFNVBOXVR_CB_COMPARATOR;
 
@@ -162 +162 @@
     RTListNodeRemove(&pReg->ListEntry);
     --pList->cEntries;
+    vboxVrDbgListVerify(pList);
 }
 
@@ -292 +293 @@
 }
 
+/* @returns Entry to be used for continuing the rectangles iterations being made currently on the callback call.
+ *          ListHead is returned to break the current iteration
+ * @param ppNext specifies next reg entry to be used for iteration. the default is pReg1->ListEntry.pNext */
 typedef DECLCALLBACK(PRTLISTNODE) FNVBOXVR_CB_INTERSECTED_VISITOR(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, const RTRECT * pRect2, void *pvContext, PRTLISTNODE *ppNext);
 typedef FNVBOXVR_CB_INTERSECTED_VISITOR *PFNVBOXVR_CB_INTERSECTED_VISITOR;
@@ -310 +314 @@
             if (VBoxRectIsZero(pRect2))
                 continue;
-            if (pReg1->Rect.yBottom <= pRect2->yTop)
+
+            if (!VBoxRectIsIntersect(&pReg1->Rect, pRect2))
                 continue;
-            else if (pRect2->yBottom <= pReg1->Rect.yTop)
-                continue;
-            /* y coords intersect */
-            else if (pReg1->Rect.xRight <= pRect2->xLeft)
-                continue;
-            else if (pRect2->xRight <= pReg1->Rect.xLeft)
-                continue;
-            /* x coords intersect */
 
             /* the visitor can modify the list 1, apply necessary adjustments after it */
-            PRTLISTNODE pEntry1 = pfnVisitor (pList1, pReg1, pRect2, pvVisitor, &pNext1);
+            pEntry1 = pfnVisitor (pList1, pReg1, pRect2, pvVisitor, &pNext1);
             if (pEntry1 == &pList1->ListHead)
                 break;
-        }
-    }
-}
-
+            else
+                pReg1 = PVBOXVR_REG_FROM_ENTRY(pEntry1);
+        }
+    }
+}
+
+/* @returns Entry to be iterated next. ListHead is returned to break the iteration
+ *
+ */
+typedef DECLCALLBACK(PRTLISTNODE) FNVBOXVR_CB_NONINTERSECTED_VISITOR(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, void *pvContext);
+typedef FNVBOXVR_CB_NONINTERSECTED_VISITOR *PFNVBOXVR_CB_NONINTERSECTED_VISITOR;
+
+static void vboxVrListVisitNonintersected(PVBOXVR_LIST pList1, uint32_t cRects, const RTRECT *aRects, PFNVBOXVR_CB_NONINTERSECTED_VISITOR pfnVisitor, void* pvVisitor)
+{
+    PRTLISTNODE pEntry1 = pList1->ListHead.pNext;
+    PRTLISTNODE pNext1;
+    uint32_t iFirst2 = 0;
+
+    for (; pEntry1 != &pList1->ListHead; pEntry1 = pNext1)
+    {
+        PVBOXVR_REG pReg1 = PVBOXVR_REG_FROM_ENTRY(pEntry1);
+        uint32_t i = iFirst2;
+        for (; i < cRects; ++i)
+        {
+            const RTRECT *pRect2 = &aRects[i];
+            if (VBoxRectIsZero(pRect2))
+                continue;
+
+            if (VBoxRectIsIntersect(&pReg1->Rect, pRect2))
+                break;
+        }
+
+        if (i == cRects)
+            pNext1 = pfnVisitor(pList1, pReg1, pvVisitor);
+        else
+            pNext1 = pEntry1->pNext;
+    }
+}
 
 static void vboxVrListJoinRectsHV(PVBOXVR_LIST pList, bool fHorizontal)
@@ -508 +539 @@
 static int vboxVrListSubstNoJoin(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
 {
+    *pfChanged = false;
+
     if (VBoxVrListIsEmpty(pList))
         return VINF_SUCCESS;
@@ -514 +547 @@
     Data.rc = VINF_SUCCESS;
     Data.fChanged = false;
-
-    *pfChanged = false;
 
     vboxVrListVisitIntersected(pList, cRects, aRects, vboxVrListSubstNoJoinCb, &Data);
@@ -600 +631 @@
 }
 
+static DECLCALLBACK(PRTLISTNODE) vboxVrListIntersectNoJoinNonintersectedCb(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, void *pvContext)
+{
+    VBOXVR_CBDATA_SUBST *pData = (VBOXVR_CBDATA_SUBST*)pvContext;
+
+    PRTLISTNODE pNext = pReg1->ListEntry.pNext;
+
+    vboxVrDbgListVerify(pList1);
+
+    vboxVrListRegRemove(pList1, pReg1);
+    vboxVrRegTerm(pReg1);
+
+    vboxVrDbgListVerify(pList1);
+
+    pData->fChanged = true;
+
+    return pNext;
+}
+
+static DECLCALLBACK(PRTLISTNODE) vboxVrListIntersectNoJoinIntersectedCb(PVBOXVR_LIST pList1, PVBOXVR_REG pReg1, const RTRECT *pRect2, void *pvContext, PRTLISTNODE *ppNext)
+{
+    PVBOXVR_CBDATA_SUBST pData = (PVBOXVR_CBDATA_SUBST)pvContext;
+    pData->fChanged = true;
+
+    vboxVrDbgListVerify(pList1);
+
+    PRTLISTNODE pMemberEntry = pReg1->ListEntry.pNext;
+
+    Assert(VBoxRectIsIntersect(&pReg1->Rect, pRect2));
+    Assert(!VBoxRectIsZero(pRect2));
+
+    vboxVrListRegRemove(pList1, pReg1);
+    VBoxRectIntersect(&pReg1->Rect, pRect2);
+    Assert(!VBoxRectIsZero(&pReg1->Rect));
+
+    vboxVrListRegAddOrder(pList1, pMemberEntry, pReg1);
+
+    vboxVrDbgListVerify(pList1);
+
+    return &pReg1->ListEntry;
+}
+
+static int vboxVrListIntersectNoJoin(PVBOXVR_LIST pList, const VBOXVR_LIST *pList2, bool *pfChanged)
+{
+    bool fChanged = false;
+    *pfChanged = false;
+
+    if (VBoxVrListIsEmpty(pList))
+        return VINF_SUCCESS;
+
+    if (VBoxVrListIsEmpty(pList2))
+    {
+        if (pfChanged)
+            *pfChanged = true;
+
+        VBoxVrListClear(pList);
+        return VINF_SUCCESS;
+    }
+
+    PRTLISTNODE pNext1;
+
+    for (PRTLISTNODE pEntry1 = pList->ListHead.pNext; pEntry1 != &pList->ListHead; pEntry1 = pNext1)
+    {
+        pNext1 = pEntry1->pNext;
+        PVBOXVR_REG pReg1 = PVBOXVR_REG_FROM_ENTRY(pEntry1);
+        RTRECT RegRect1 = pReg1->Rect;
+        PRTLISTNODE pMemberEntry = pReg1->ListEntry.pNext;
+
+        for (const RTLISTNODE *pEntry2 = pList2->ListHead.pNext; pEntry2 != &pList2->ListHead; pEntry2 = pEntry2->pNext)
+        {
+            const VBOXVR_REG *pReg2 = PVBOXVR_REG_FROM_ENTRY(pEntry2);
+            const RTRECT *pRect2 = &pReg2->Rect;
+
+            if (!VBoxRectIsIntersect(&RegRect1, pRect2))
+                continue;
+
+            if (pReg1)
+            {
+                if (!VBoxRectCmp(&pReg1->Rect, pRect2))
+                {
+                    /* no change, and we can break the iteration here */
+
+                    /* zero up the pReg1 to mark it as intersected (see the code after this inner loop) */
+                    pReg1 = NULL;
+                    break;
+                }
+                /* @todo: this can have false-alarming sometimes if the separated rects will then be joind into the original rect,
+                 * so far this should not be a problem for VReg clients, so keep it this way for now  */
+                fChanged = true;
+
+                /* re-use the reg entry */
+                vboxVrListRegRemove(pList, pReg1);
+                VBoxRectIntersect(&pReg1->Rect, pRect2);
+                Assert(!VBoxRectIsZero(&pReg1->Rect));
+
+                vboxVrListRegAddOrder(pList, pMemberEntry, pReg1);
+                pReg1 = NULL;
+            }
+            else
+            {
+                Assert(fChanged); /* <- should be set by the if branch above */
+                PVBOXVR_REG pReg = vboxVrRegCreate();
+                if (!pReg)
+                {
+                    WARN(("vboxVrRegCreate failed!"));
+                    return VERR_NO_MEMORY;
+                }
+                VBoxRectIntersected(&RegRect1, pRect2, &pReg->Rect);
+                Assert(!VBoxRectIsZero(&pReg->Rect));
+                vboxVrListRegAddOrder(pList, pList->ListHead.pNext, pReg);
+            }
+        }
+
+        if (pReg1)
+        {
+            /* the region has no intersections, remove it */
+            vboxVrListRegRemove(pList, pReg1);
+            vboxVrRegTerm(pReg1);
+            fChanged = true;
+        }
+    }
+
+    *pfChanged = fChanged;
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) VBoxVrListIntersect(PVBOXVR_LIST pList, const VBOXVR_LIST *pList2, bool *pfChanged)
+{
+    if (pfChanged)
+        *pfChanged = false;
+
+    int rc = vboxVrListIntersectNoJoin(pList, pList2, pfChanged);
+    if (!RT_SUCCESS(rc))
+    {
+        WARN(("vboxVrListSubstNoJoin failed!"));
+        return rc;
+    }
+
+    if (*pfChanged)
+    {
+        vboxVrListJoinRects(pList);
+    }
+
+    return rc;
+}
+
+VBOXVREGDECL(int) VBoxVrListRectsIntersect(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
+{
+    if (pfChanged)
+        *pfChanged = false;
+
+    if (VBoxVrListIsEmpty(pList))
+        return VINF_SUCCESS;
+
+    if (!cRects)
+    {
+        if (pfChanged)
+            *pfChanged = true;
+
+        VBoxVrListClear(pList);
+        return VINF_SUCCESS;
+    }
+
+    /* we perform intersection using lists because the algorythm axpects the rects to be non-intersected,
+     * which list guaranties to us */
+
+    VBOXVR_LIST TmpList;
+    VBoxVrListInit(&TmpList);
+
+    int rc = VBoxVrListRectsAdd(&TmpList, cRects, aRects, NULL);
+    if (RT_SUCCESS(rc))
+    {
+        rc = VBoxVrListIntersect(pList, &TmpList, pfChanged);
+        if (!RT_SUCCESS(rc))
+        {
+            WARN(("VBoxVrListIntersect failed! rc %d", rc));
+        }
+    }
+    else
+    {
+        WARN(("VBoxVrListRectsAdd failed, rc %d", rc));
+    }
+    VBoxVrListClear(&TmpList);
+
+    return rc;
+}
+
 VBOXVREGDECL(int) VBoxVrListRectsSubst(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
 {
@@ -631 +848 @@
 }
 
+VBOXVREGDECL(int) VBoxVrListRectsSet(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
+{
+    if (pfChanged)
+        *pfChanged = false;
+
+    if (!cRects && VBoxVrListIsEmpty(pList))
+    {
+        return VINF_SUCCESS;
+    }
+
+    /* @todo: fChanged will have false alarming here, fix if needed */
+    VBoxVrListClear(pList);
+
+    int rc = VBoxVrListRectsAdd(pList, cRects, aRects, NULL);
+    if (!RT_SUCCESS(rc))
+    {
+        WARN(("VBoxVrListRectsSet failed rc %d", rc));
+        return rc;
+    }
+
+    if (pfChanged)
+        *pfChanged = true;
+
+    return VINF_SUCCESS;
+}
+
 VBOXVREGDECL(int) VBoxVrListRectsAdd(PVBOXVR_LIST pList, uint32_t cRects, const RTRECT * aRects, bool *pfChanged)
 {
     uint32_t cCovered = 0;
+
+    if (pfChanged)
+        *pfChanged = false;
 
 #if 0
@@ -673 +919 @@
 
     if (cCovered == cRects)
-    {
-        *pfChanged = false;
         return VINF_SUCCESS;
-    }
 
     /* rects are not covered, need to go the slow way */
@@ -766 +1009 @@
         vboxVrListJoinRects(pList);
 
-    *pfChanged = fChanged;
+    if (pfChanged)
+        *pfChanged = fChanged;
 
     return VINF_SUCCESS;
@@ -871 +1115 @@
 VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsAdd(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT *paRects, uint32_t *pfChangeFlags)
 {
-    bool fOthersChanged = false, fCurChanged = false, fEntryChanged = false, fEntryInList = false, fEntryReplaces = false;
+    bool fOthersChanged = false, fCurChanged = false, fEntryChanged = false, fEntryWasInList = false, fEntryReplaced = false;
     PVBOXVR_COMPOSITOR_ENTRY pCur;
     int rc = VINF_SUCCESS;
@@ -884 +1128 @@
     if (pEntry)
     {
-        fEntryInList = VBoxVrCompositorEntryIsInList(pEntry);
+        fEntryWasInList = VBoxVrCompositorEntryIsInList(pEntry);
         rc = VBoxVrListRectsAdd(&pEntry->Vr, cRects, paRects, &fEntryChanged);
         if (RT_SUCCESS(rc))
@@ -910 +1154 @@
         if (pCur == pEntry)
         {
-            Assert(fEntryInList);
+            Assert(fEntryWasInList);
         }
         else
@@ -918 +1162 @@
                 VBoxVrListClear(&pCur->Vr);
                 vboxVrCompositorEntryRemove(pCompositor, pCur, pEntry);
-                fEntryReplaces = true;
+                fEntryReplaced = true;
+                break;
             }
             else
@@ -936 +1181 @@
     AssertRC(rc);
 
-    if (pEntry && !fEntryInList)
+    if (pEntry && !fEntryWasInList)
     {
         Assert(!VBoxVrListIsEmpty(&pEntry->Vr));
@@ -946 +1191 @@
         uint32_t fFlags = 0;
         if (fOthersChanged)
-            fFlags = VBOXVR_COMPOSITOR_CF_ENTRIES_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED;
-        else if (fEntryReplaces)
+            fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED;
+        else if (fEntryReplaced)
         {
             Assert(fEntryChanged);
-            fFlags = VBOXVR_COMPOSITOR_CF_ENTRIES_REGIONS_CHANGED;
+            fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REPLACED;
         }
         else if (fEntryChanged)
-            fFlags = VBOXVR_COMPOSITOR_CF_ENTRIES_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED;
-        if (!fEntryInList)
-            fFlags |= VBOXVR_COMPOSITOR_CF_ENTRY_ADDED;
+            fFlags = VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED;
+
+        if (!fEntryWasInList)
+            Assert(fEntryChanged);
 
         *pfChangeFlags = fFlags;
@@ -1019 +1265 @@
         *pfChanged = fChanged;
     return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged)
+{
+    int rc = VINF_SUCCESS;
+    bool fChanged = false;
+    if (VBoxVrCompositorEntryIsInList(pEntry))
+    {
+        rc = VBoxVrListIntersect(&pEntry->Vr, pList2, &fChanged);
+        if (RT_SUCCESS(rc))
+        {
+            if (VBoxVrListIsEmpty(&pEntry->Vr))
+            {
+                Assert(fChanged);
+                vboxVrCompositorEntryRemove(pCompositor, pEntry, NULL);
+            }
+        }
+        else
+        {
+            WARN(("VBoxVrListRectsIntersect failed, rc %d", rc));
+        }
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return rc;
+}
+
+VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersect(PVBOXVR_COMPOSITOR pCompositor, PVBOXVR_COMPOSITOR_ENTRY pEntry, uint32_t cRects, const RTRECT *paRects, bool *pfChanged)
+{
+    int rc = VINF_SUCCESS;
+    bool fChanged = false;
+    if (VBoxVrCompositorEntryIsInList(pEntry))
+    {
+        rc = VBoxVrListRectsIntersect(&pEntry->Vr, cRects, paRects, &fChanged);
+        if (RT_SUCCESS(rc))
+        {
+            if (VBoxVrListIsEmpty(&pEntry->Vr))
+            {
+                Assert(fChanged);
+                vboxVrCompositorEntryRemove(pCompositor, pEntry, NULL);
+            }
+        }
+        else
+        {
+            WARN(("VBoxVrListRectsIntersect failed, rc %d", rc));
+        }
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return rc;
+}
+
+VBOXVREGDECL(int) VBoxVrCompositorEntryListIntersectAll(PVBOXVR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged)
+{
+    VBOXVR_COMPOSITOR_ITERATOR Iter;
+    VBoxVrCompositorIterInit(pCompositor, &Iter);
+    PVBOXVR_COMPOSITOR_ENTRY pEntry;
+    int rc = VINF_SUCCESS;
+    bool fChanged = false;
+
+    while ((pEntry = VBoxVrCompositorIterNext(&Iter)) != NULL)
+    {
+        bool fTmpChanged = false;
+        int tmpRc = VBoxVrCompositorEntryListIntersect(pCompositor, pEntry, pList2, &fTmpChanged);
+        if (RT_SUCCESS(tmpRc))
+        {
+            fChanged |= fChanged;
+        }
+        else
+        {
+            crWarning("VBoxVrCompositorEntryRegionsIntersect failed, rc %d", tmpRc);
+            rc = tmpRc;
+        }
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return rc;
+}
+
+VBOXVREGDECL(int) VBoxVrCompositorEntryRegionsIntersectAll(PVBOXVR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+{
+    VBOXVR_COMPOSITOR_ITERATOR Iter;
+    VBoxVrCompositorIterInit(pCompositor, &Iter);
+    PVBOXVR_COMPOSITOR_ENTRY pEntry;
+    int rc = VINF_SUCCESS;
+    bool fChanged = false;
+
+    while ((pEntry = VBoxVrCompositorIterNext(&Iter)) != NULL)
+    {
+        bool fTmpChanged = false;
+        int tmpRc = VBoxVrCompositorEntryRegionsIntersect(pCompositor, pEntry, cRegions, paRegions, &fTmpChanged);
+        if (RT_SUCCESS(tmpRc))
+        {
+            fChanged |= fChanged;
+        }
+        else
+        {
+            crWarning("VBoxVrCompositorEntryRegionsIntersect failed, rc %d", tmpRc);
+            rc = tmpRc;
+        }
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return rc;
 }
 
@@ -1268 +1626 @@
 
 
-static int crVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+static int crVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, uint32_t *pfChangedFlags)
 {
     uint32_t fChangedFlags = 0;
@@ -1278 +1636 @@
     }
 
-    if (fChangedFlags & VBOXVR_COMPOSITOR_CF_COMPOSITED_REGIONS_CHANGED)
+    if (fChangedFlags & VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED)
     {
         crVrScrCompositorRectsInvalidate(pCompositor);
     }
 
-    CrVrScrCompositorEntrySetChanged(pEntry, true);
-
-    if (pfChanged)
-        *pfChanged = !!fChangedFlags;
+    if (fChangedFlags & VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED)
+    {
+        CrVrScrCompositorEntrySetChanged(pEntry, true);
+    }
+
+    if (pfChangedFlags)
+        *pfChangedFlags = fChangedFlags;
     return VINF_SUCCESS;
 }
@@ -1334 +1695 @@
 }
 
-VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsAdd(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, uint32_t *pfChangeFlags)
 {
     int rc;
+    uint32_t fChangeFlags = 0;
+    bool fPosChanged = false;
     if (pPos)
     {
-        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, NULL);
+        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, &fPosChanged);
         if (!RT_SUCCESS(rc))
         {
@@ -1347 +1710 @@
     }
 
-    rc = crVrScrCompositorEntryRegionsAdd(pCompositor, pEntry, cRegions, paRegions, NULL);
+    rc = crVrScrCompositorEntryRegionsAdd(pCompositor, pEntry, cRegions, paRegions, &fChangeFlags);
     if (!RT_SUCCESS(rc))
     {
@@ -1354 +1717 @@
     }
 
+    if (pfChangeFlags)
+    {
+        if (fPosChanged)
+        {
+            /* means entry was in list and was moved, so regions changed */
+            *pfChangeFlags = VBOXVR_COMPOSITOR_CF_REGIONS_CHANGED | VBOXVR_COMPOSITOR_CF_ENTRY_REGIONS_CHANGED;
+        }
+        else
+            *pfChangeFlags = fChangeFlags;
+    }
+
     return VINF_SUCCESS;
 }
 
-VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions)
-{
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsSet(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const RTPOINT *pPos, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+{
+    bool fChanged = false, fPosChanged = false;
     int rc = CrVrScrCompositorEntryRemove(pCompositor, pEntry);
     if (!RT_SUCCESS(rc))
@@ -1368 +1743 @@
     if (pPos)
     {
-        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, NULL);
+        rc = crVrScrCompositorEntryPositionSet(pCompositor, pEntry, pPos, &fPosChanged);
         if (!RT_SUCCESS(rc))
         {
@@ -1376 +1751 @@
     }
 
-    rc = crVrScrCompositorEntryRegionsSet(pCompositor, pEntry, cRegions, paRegions, NULL);
+    rc = crVrScrCompositorEntryRegionsSet(pCompositor, pEntry, cRegions, paRegions, &fChanged);
     if (!RT_SUCCESS(rc))
     {
@@ -1383 +1758 @@
     }
 
+    if (pfChanged)
+        *pfChanged = fPosChanged || fChanged;
+
     return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, const VBOXVR_LIST *pList2, bool *pfChanged)
+{
+    bool fChanged = false;
+    int rc = VBoxVrCompositorEntryListIntersect(&pCompositor->Compositor, &pEntry->Ce, pList2, &fChanged);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("RegionsIntersect: VBoxVrCompositorEntryRegionsIntersect failed rc %d", rc);
+        return rc;
+    }
+
+    if (fChanged)
+    {
+        CrVrScrCompositorEntrySetChanged(pEntry, true);
+        crVrScrCompositorRectsInvalidate(pCompositor);
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersect(PVBOXVR_SCR_COMPOSITOR pCompositor, PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+{
+    bool fChanged = false;
+    int rc = VBoxVrCompositorEntryRegionsIntersect(&pCompositor->Compositor, &pEntry->Ce, cRegions, paRegions, &fChanged);
+    if (!RT_SUCCESS(rc))
+    {
+        crWarning("RegionsIntersect: VBoxVrCompositorEntryRegionsIntersect failed rc %d", rc);
+        return rc;
+    }
+
+    if (fChanged)
+    {
+        CrVrScrCompositorEntrySetChanged(pEntry, true);
+        crVrScrCompositorRectsInvalidate(pCompositor);
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return VINF_SUCCESS;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryListIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, const VBOXVR_LIST *pList2, bool *pfChanged)
+{
+    VBOXVR_SCR_COMPOSITOR_ITERATOR Iter;
+    CrVrScrCompositorIterInit(pCompositor, &Iter);
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
+    int rc = VINF_SUCCESS;
+    bool fChanged = false;
+
+    while ((pEntry = CrVrScrCompositorIterNext(&Iter)) != NULL)
+    {
+        bool fTmpChanged = false;
+        int tmpRc = CrVrScrCompositorEntryListIntersect(pCompositor, pEntry, pList2, &fTmpChanged);
+        if (RT_SUCCESS(tmpRc))
+        {
+            fChanged |= fTmpChanged;
+        }
+        else
+        {
+            crWarning("CrVrScrCompositorEntryRegionsIntersect failed, rc %d", tmpRc);
+            rc = tmpRc;
+        }
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return rc;
+}
+
+VBOXVREGDECL(int) CrVrScrCompositorEntryRegionsIntersectAll(PVBOXVR_SCR_COMPOSITOR pCompositor, uint32_t cRegions, const RTRECT *paRegions, bool *pfChanged)
+{
+    VBOXVR_SCR_COMPOSITOR_ITERATOR Iter;
+    CrVrScrCompositorIterInit(pCompositor, &Iter);
+    PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
+    int rc = VINF_SUCCESS;
+    bool fChanged = false;
+
+    while ((pEntry = CrVrScrCompositorIterNext(&Iter)) != NULL)
+    {
+        bool fTmpChanged = false;
+        int tmpRc = CrVrScrCompositorEntryRegionsIntersect(pCompositor, pEntry, cRegions, paRegions, &fTmpChanged);
+        if (RT_SUCCESS(tmpRc))
+        {
+            fChanged |= fTmpChanged;
+        }
+        else
+        {
+            crWarning("CrVrScrCompositorEntryRegionsIntersect failed, rc %d", tmpRc);
+            rc = tmpRc;
+        }
+    }
+
+    if (pfChanged)
+        *pfChanged = fChanged;
+
+    return rc;
 }