Changeset 45066 in vbox for trunk/src/VBox/HostServices/SharedOpenGL

Timestamp:

Mar 18, 2013 5:08:39 PM (12 years ago)

Author:

vboxsync

Message:

crOpenGL: misc bugfixes & cleanups

Location:

trunk/src/VBox/HostServices/SharedOpenGL

Files:

• crserverlib/server.h (modified) (1 diff)
• crserverlib/server_main.c (modified) (1 diff)
• crserverlib/server_muralfbo.c (modified) (6 diffs)
• crserverlib/server_window.c (modified) (6 diffs)
• render/renderspu.c (modified) (3 diffs)
• render/renderspu.h (modified) (2 diffs)
• render/renderspu_cocoa.c (modified) (1 diff)
• render/renderspu_cocoa_helper.h (modified) (1 diff)
• render/renderspu_cocoa_helper.m (modified) (22 diffs)
• render/renderspu_glx.c (modified) (2 diffs)
• render/renderspu_wgl.c (modified) (2 diffs)

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

@@ -142 +142 @@
 void crServerMuralFBOSwapBuffers(CRMuralInfo *mural);
 
-void crServerVBoxCompositionReenable(CRMuralInfo *mural, bool fOnContentHide);
+void crServerVBoxCompositionReenable(CRMuralInfo *mural, GLboolean fForcePresent);
 void crServerVBoxCompositionDisable(CRMuralInfo *mural);
-void crServerVBoxCompositionPresent(CRMuralInfo *mural, bool fOnContentHide);
+void crServerVBoxCompositionPresent(CRMuralInfo *mural);
+DECLINLINE(GLboolean) crServerVBoxCompositionPresentNeeded(CRMuralInfo *mural)
+{
+    return mural->bVisible
+                && mural->width
+                && mural->height
+                && CrVrScrCompositorEntryIsInList(&mural->CEntry);
+}
 
 #define CR_SERVER_FBO_BB_IDX(_mural) ((_mural)->iBbBuffer)

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

@@ -1806 +1806 @@
         crVBoxServerFBImageDataTerm(&Data.data);
 
-        if (pMural->fUseFBO && pMural->bVisible)
+        if (pMural->fUseFBO && crServerVBoxCompositionPresentNeeded(pMural))
         {
             crServerPresentFBO(pMural);

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

@@ -251 +251 @@
     }
 
+    crServerVBoxCompositionDisable(mural);
+
     if (redir)
     {
@@ -313 +315 @@
 
     mural->fUseFBO = redir;
+    crServerVBoxCompositionReenable(mural, GL_FALSE);
 }
 
@@ -513 +516 @@
 }
 
-void crServerVBoxCompositionPresent(CRMuralInfo *mural, bool fOnContentHide)
+static void crServerVBoxCompositionPresentPerform(CRMuralInfo *mural)
 {
     CRMuralInfo *currentMural = cr_server.currentMural;
@@ -522 +525 @@
     CRASSERT(curCtx == crStateGetCurrent());
 
-    Assert(!CrVrScrCompositorIsEmpty(&mural->Compositor) == !fOnContentHide);
-
-    if (!fOnContentHide)
-    {
-        if (!mural->bVisible)
-        {
-            return;
-        }
-
-        if (!mural->width || !mural->height)
-        {
-            return;
-        }
-
-        if (!CrVrScrCompositorEntryIsInList(&mural->CEntry))
-            return;
-    }
-
     if (currentMural)
     {
@@ -556 +541 @@
 
     crStateSwitchPostprocess(curCtx, NULL, idDrawFBO, idReadFBO);
-
-    mural->fCompositorPresented = !fOnContentHide;
-}
-
-void crServerVBoxCompositionReenable(CRMuralInfo *mural, bool fOnContentHide)
-{
-    if (!mural->fCompositorPresented)
-        return;
-
-    crServerVBoxCompositionPresent(mural, fOnContentHide);
+}
+
+void crServerVBoxCompositionPresent(CRMuralInfo *mural)
+{
+    if (!crServerVBoxCompositionPresentNeeded(mural))
+        return;
+    crServerVBoxCompositionPresentPerform(mural);
+}
+
+void crServerVBoxCompositionReenable(CRMuralInfo *mural, GLboolean fForcePresent)
+{
+    if (mural->fUseFBO != CR_SERVER_REDIR_FBO_BLT ||
+            (!fForcePresent
+                    && !crServerVBoxCompositionPresentNeeded(mural)))
+        return;
+
+    crServerVBoxCompositionPresentPerform(mural);
 }
 
 void crServerVBoxCompositionDisable(CRMuralInfo *mural)
 {
+    if (mural->fUseFBO != CR_SERVER_REDIR_FBO_BLT)
+        return;
     cr_server.head_spu->dispatch_table.VBoxPresentComposition(mural->spuWindow, NULL, NULL);
 }
@@ -585 +579 @@
     CRASSERT(cr_server.pfnPresentFBO || mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT);
 
-    if (!mural->bVisible)
-    {
-        return;
-    }
-
-    if (!mural->width || !mural->height)
-    {
-        return;
-    }
-
-    if (!CrVrScrCompositorEntryIsInList(&mural->CEntry))
-        return;
-
     if (mural->fUseFBO == CR_SERVER_REDIR_FBO_BLT)
     {
-        crServerVBoxCompositionPresent(mural, false);
-        return;
-    }
+        crServerVBoxCompositionPresent(mural);
+        return;
+    }
+
+    if (!crServerVBoxCompositionPresentNeeded(mural))
+        return;
 
     Tex.width = mural->width;

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

@@ -31 +31 @@
         return -1;
     }
-
-    mural->fCompositorPresented = GL_FALSE;
 
     /*
@@ -332 +330 @@
         Tex.hwid = 0;
 
-        if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
-        {
-            /* since we're going to change the current compositor & the window we need to avoid
-             * renderspu fron dealing with inconsistent data, i.e. modified compositor and
-             * still unmodified window.
-             * So what we do is:
-             * 1. tell renderspu to stop using the current compositor -> renderspu would do necessary synchronization with its redraw thread to ensure compositor is no longer used
-             * 2. do necessary modifications
-             * 3. (so far not needed for resize, but in case it is in the future) re-set the compositor */
-
-            /* 1. tell renderspu to stop using the current compositor (see above comment) */
-            crServerVBoxCompositionDisable(mural);
-        }
-
-        mural->fCompositorPresented = GL_FALSE;
+
+        /* since we're going to change the current compositor & the window we need to avoid
+         * renderspu fron dealing with inconsistent data, i.e. modified compositor and
+         * still unmodified window.
+         * So what we do is:
+         * 1. tell renderspu to stop using the current compositor -> renderspu would do necessary synchronization with its redraw thread to ensure compositor is no longer used
+         * 2. do necessary modifications
+         * 3. (so far not needed for resize, but in case it is in the future) re-set the compositor */
+
+        /* 1. tell renderspu to stop using the current compositor (see above comment) */
+        crServerVBoxCompositionDisable(mural);
 
         /* 2. do necessary modifications (see above comment) */
@@ -377 +371 @@
         /* 3. (so far not needed for resize, but in case it is in the future) re-set the compositor (see above comment) */
         /* uncomment when needed */
-        /* NOTE: !!! we have mural->fCompositorPresented set to GL_FALSE above, so crServerVBoxCompositionReenable will have no effect in any way
-        if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
-        {
-            crServerVBoxCompositionReenable(mural);
-        }
+        /* NOTE: !!! we have mural->fHasPresentationData set to GL_FALSE above, so crServerVBoxCompositionReenable will have no effect in any way
+        crServerVBoxCompositionReenable(mural);
         */
     }
@@ -423 +414 @@
 //    if (mural->gX != x || mural->gY != y)
     {
-        if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
-        {
-            /* since we're going to change the current compositor & the window we need to avoid
-             * renderspu fron dealing with inconsistent data, i.e. modified compositor and
-             * still unmodified window.
-             * So what we do is:
-             * 1. tell renderspu to stop using the current compositor -> renderspu would do necessary synchronization with its redraw thread to ensure compositor is no longer used
-             * 2. do necessary modifications
-             * 3. re-set the compositor */
-
-            /* 1. tell renderspu to stop using the current compositor (see above comment) */
-            crServerVBoxCompositionDisable(mural);
-        }
-
-        /* 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;
-
-        crServerCheckMuralGeometry(mural);
-
-        /* 3. re-set the compositor (see above comment) */
-        if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
-        {
-            crServerVBoxCompositionReenable(mural, false);
-        }
-    }
-}
-
-void SERVER_DISPATCH_APIENTRY
-crServerDispatchWindowVisibleRegion( GLint window, GLint cRects, GLint *pRects )
-{
-    CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
-    bool fContainedRegions;
-    if (!mural) {
-#if EXTRA_WARN
-         crWarning("CRServer: invalid window %d passed to WindowVisibleRegion()", window);
-#endif
-         return;
-    }
-
-    if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
-    {
         /* since we're going to change the current compositor & the window we need to avoid
          * renderspu fron dealing with inconsistent data, i.e. modified compositor and
@@ -485 +424 @@
         /* 1. tell renderspu to stop using the current compositor (see above comment) */
         crServerVBoxCompositionDisable(mural);
-    }
-
-    fContainedRegions = !CrVrScrCompositorIsEmpty(&mural->Compositor);
+
+        /* 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;
+
+        crServerCheckMuralGeometry(mural);
+
+        /* 3. re-set the compositor (see above comment) */
+        crServerVBoxCompositionReenable(mural, GL_FALSE);
+    }
+}
+
+void SERVER_DISPATCH_APIENTRY
+crServerDispatchWindowVisibleRegion( GLint window, GLint cRects, GLint *pRects )
+{
+    CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
+    GLboolean fForcePresent = crServerVBoxCompositionPresentNeeded(mural);
+    if (!mural) {
+#if EXTRA_WARN
+         crWarning("CRServer: invalid window %d passed to WindowVisibleRegion()", window);
+#endif
+         return;
+    }
+
+    /* since we're going to change the current compositor & the window we need to avoid
+     * renderspu fron dealing with inconsistent data, i.e. modified compositor and
+     * still unmodified window.
+     * So what we do is:
+     * 1. tell renderspu to stop using the current compositor -> renderspu would do necessary synchronization with its redraw thread to ensure compositor is no longer used
+     * 2. do necessary modifications
+     * 3. re-set the compositor */
+
+    /* 1. tell renderspu to stop using the current compositor (see above comment) */
+    crServerVBoxCompositionDisable(mural);
+
     /* 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 */
@@ -523 +504 @@
 
     /* 3. re-set the compositor (see above comment) */
-    if (mural->fUseFBO != CR_SERVER_REDIR_NONE)
-    {
-        crServerVBoxCompositionReenable(mural, fContainedRegions && CrVrScrCompositorIsEmpty(&mural->Compositor));
-    }
-}
-
-
+    crServerVBoxCompositionReenable(mural, fForcePresent);
+}
 
 void SERVER_DISPATCH_APIENTRY

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

@@ -367 +367 @@
 GLboolean renderspuWindowInit( WindowInfo *window, VisualInfo *visual, GLboolean showIt, GLint id )
 {
+    crMemset(window, 0, sizeof (*window));
     RTCritSectInit(&window->CompositorLock);
+    window->fCompositorPresentEmpty = GL_FALSE;
     window->pCompositor = NULL;
 
@@ -644 +646 @@
     window = (WindowInfo *) crHashtableSearch(render_spu.windowTable, win);
     if (window) {
-#if !defined(RT_OS_DARWIN) || !defined(VBOX_WITH_COCOA_QT)
-        if (CrVrScrCompositorIsEmpty(pCompositor))
+        if (pCompositor && CrVrScrCompositorIsEmpty(pCompositor) && !window->fCompositorPresentEmpty)
             pCompositor = NULL;
-#endif
+
+        if (pCompositor)
+            window->fCompositorPresentEmpty = GL_FALSE;
+
         renderspuVBoxCompositorSet( window, pCompositor);
         if (pCompositor)
         {
-            renderspu_SystemVBoxPresentComposition(window, pCompositor, pChangedEntry);
-#if defined(RT_OS_DARWIN) && defined(VBOX_WITH_COCOA_QT)
+            renderspu_SystemVBoxPresentComposition(window, pChangedEntry);
             if (CrVrScrCompositorIsEmpty(pCompositor))
                 renderspuVBoxCompositorSet( window, NULL);
-#endif
         }
     }
@@ -976 +978 @@
     int rc;
     Assert(window->pCompositor);
+    if (CrVrScrCompositorIsEmpty(window->pCompositor))
+        window->pCompositor = NULL;
     rc = RTCritSectLeave(&window->CompositorLock);
     if (!RT_SUCCESS(rc))

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

@@ -100 +100 @@
     GLboolean visible;
     GLboolean everCurrent; /**< has this window ever been bound? */
+    GLboolean fCompositorPresentEmpty;
     char *title;
 
@@ -391 +392 @@
 extern void renderspu_SystemSwapBuffers( WindowInfo *window, GLint flags );
 extern void renderspu_SystemReparentWindow(WindowInfo *window);
-extern void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry );
+extern void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry );
 extern void renderspu_GCWindow(void);
 extern int renderspuCreateFunctions( SPUNamedFunctionTable table[] );

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

@@ -152 +152 @@
 }
 
-void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
 {
-    cocoaViewPresentComposition(window->window, pCompositor, pChangedEntry);
+    cocoaViewPresentComposition(window->window, pChangedEntry);
 }
 

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

@@ -47 +47 @@
 void cocoaViewMakeCurrentContext(NativeNSViewRef pView, NativeNSOpenGLContextRef pCtx);
 void cocoaViewSetVisibleRegion(NativeNSViewRef pView, GLint cRects, GLint* paRects);
-void cocoaViewPresentComposition(NativeNSViewRef pView, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry);
+void cocoaViewPresentComposition(NativeNSViewRef pView, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry);
 
 RT_C_DECLS_END

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

@@ -192 +192 @@
 }
 
+typedef struct VBOX_CR_RENDER_CTX_INFO
+{
+    bool fIsValid;
+    NSOpenGLContext *pCtx;
+    NSView *pView;
+} VBOX_CR_RENDER_CTX_INFO, *PVBOX_CR_RENDER_CTX_INFO;
+
+static void vboxCtxEnter(NSOpenGLContext*pCtx, PVBOX_CR_RENDER_CTX_INFO pCtxInfo)
+{
+    NSOpenGLContext *pOldCtx = vboxCtxGetCurrent();
+    NSView *pOldView = (pOldCtx ? [pOldCtx view] : nil);
+    NSView *pView = [pCtx view];
+    bool fNeedCtxSwitch = (pOldCtx != pCtx || pOldView != pView);
+    Assert(pCtx);
+ //   Assert(pOldCtx == m_pGLCtx);
+ //   Assert(pOldView == self);
+ //   Assert(fNeedCtxSwitch);
+    if (fNeedCtxSwitch)
+    {
+        if(pOldCtx != nil)
+            glFlush();
+        
+        [pCtx makeCurrentContext];
+        
+        pCtxInfo->fIsValid = true;
+        pCtxInfo->pCtx = pOldCtx;
+        pCtxInfo->pView = pView;
+    }
+    else
+    {
+        pCtxInfo->fIsValid = false;
+    }
+}    
+    
+static void vboxCtxLeave(PVBOX_CR_RENDER_CTX_INFO pCtxInfo)
+{
+    if (pCtxInfo->fIsValid)
+    {
+        NSOpenGLContext *pOldCtx = pCtxInfo->pCtx;
+        NSView *pOldView = pCtxInfo->pView;
+    
+        glFlush();
+        if (pOldCtx != nil)
+        {
+            if ([pOldCtx view] != pOldView)
+            {
+                [pOldCtx setView: pOldView];
+            }
+        
+            [pOldCtx makeCurrentContext];
+            
+#ifdef DEBUG
+            {
+                NSOpenGLContext *pTstOldCtx = [NSOpenGLContext currentContext];
+                NSView *pTstOldView = (pTstOldCtx ? [pTstOldCtx view] : nil);
+                Assert(pTstOldCtx == pOldCtx);
+                Assert(pTstOldView == pOldView);
+            }
+#endif
+        }
+        else
+        {
+            [NSOpenGLContext clearCurrentContext];
+        }
+    }
+}
+
 /** Custom OpenGL context class.
  *
@@ -248 +315 @@
     
     WindowInfo *m_pWinInfo;
-    PVBOXVR_SCR_COMPOSITOR m_pCompositor; 
     bool m_fNeedViewportUpdate;
     bool m_fNeedCtxUpdate;
@@ -276 +342 @@
 - (void)vboxTryDraw;
 - (void)vboxTryDrawUI;
-- (void)vboxPresent;
-- (void)vboxPresentCS;
-- (void)vboxPresentToDockTileCS;
-- (void)vboxPresentToViewCS;
-- (void)presentComposition:(PVBOXVR_SCR_COMPOSITOR)pCompositor withChangedEntry:(PVBOXVR_SCR_COMPOSITOR_ENTRY)pChangedEntry;
-- (void)performSelectorMakingCurrent:(NSOpenGLContext*)pCtx idSel:(SEL)selector;
+- (void)vboxPresent:(PVBOXVR_SCR_COMPOSITOR)pCompositor;
+- (void)vboxPresentCS:(PVBOXVR_SCR_COMPOSITOR)pCompositor;
+- (void)vboxPresentToDockTileCS:(PVBOXVR_SCR_COMPOSITOR)pCompositor;
+- (void)vboxPresentToViewCS:(PVBOXVR_SCR_COMPOSITOR)pCompositor;
+- (void)presentComposition:(PVBOXVR_SCR_COMPOSITOR_ENTRY)pChangedEntry;
 
 - (void)clearVisibleRegions;
@@ -677 +742 @@
     m_RootShift               = NSZeroPoint;
     m_pWinInfo                    = pWinInfo;
-    m_pCompositor             = nil;
     m_fNeedViewportUpdate     = true;        
     m_fNeedCtxUpdate          = true;
@@ -776 +840 @@
     [self reshape];
     
-    [self vboxTryDraw];
+    /* we need to redwar on regions change, however the compositor now is cleared 
+     * because all compositor&window data-related modifications are performed with compositor cleared
+     * the renderspu client will re-set the compositor after modifications are complete
+     * this way we indicate renderspu generic code not to ignore the empty compositor */
+     /* generally this should not be needed for setPos because compositor should not be zeroed with it,
+      * in any way setting this flag here should not hurt as it will be re-set on next present */
+    m_pWinInfo->fCompositorPresentEmpty = GL_TRUE;
 }
 
@@ -806 +876 @@
         m_fNeedCtxUpdate = true;
     }
+    
+    /* we need to redwar on regions change, however the compositor now is cleared 
+     * because all compositor&window data-related modifications are performed with compositor cleared
+     * the renderspu client will re-set the compositor after modifications are complete
+     * this way we indicate renderspu generic code not to ignore the empty compositor */
+     /* generally this should not be needed for setSize because compositor should not be zeroed with it,
+      * in any way setting this flag here should not hurt as it will be re-set on next present */
+    m_pWinInfo->fCompositorPresentEmpty = GL_TRUE;
 }
 
@@ -906 +984 @@
     if (m_pSharedGLCtx)
     {
-        [self performSelectorMakingCurrent:m_pSharedGLCtx idSel:@selector(updateViewportCS)];
+        VBOX_CR_RENDER_CTX_INFO CtxInfo; 
+        vboxCtxEnter(m_pSharedGLCtx, &CtxInfo);
+    
+        [self updateViewportCS];
+    
+        vboxCtxLeave(&CtxInfo);
     }
 }
@@ -987 +1070 @@
     if ([self lockFocusIfCanDraw])
     {
-        bool fCompositorAquired = false;
+        VBOXVR_SCR_COMPOSITOR *pCompositor = NULL;
         if (!m_pSharedGLCtx)
             {
-                m_pCompositor = renderspuVBoxCompositorAcquire(m_pWinInfo);
-                if (m_pCompositor)
+                pCompositor = renderspuVBoxCompositorAcquire(m_pWinInfo);
+                if (pCompositor)
                 {
-                    fCompositorAquired = true;
                         /* Create a shared context out of the main context. Use the same pixel format. */
                         m_pSharedGLCtx = [[NSOpenGLContext alloc] initWithFormat:[(OverlayOpenGLContext*)m_pGLCtx openGLPixelFormat] shareContext:m_pGLCtx];
@@ -1004 +1086 @@
 #ifdef CR_RENDER_FORCE_PRESENT_MAIN_THREAD
                                 renderspuVBoxCompositorRelease(m_pWinInfo);
-                                fCompositorAquired = false;
 #endif
                     }
@@ -1011 +1092 @@
                 if (m_pSharedGLCtx)
                 {
-                        if (!fCompositorAquired)
+                        if (!pCompositor)
                         {
 #ifndef CR_RENDER_FORCE_PRESENT_MAIN_THREAD
                                 /* we do not want to be blocked with the GUI thread here, so only draw her eif we are really able to do that w/o bllocking */
-                                int rc = renderspuVBoxCompositorTryAcquire(m_pWinInfo, &m_pCompositor);
+                                int rc = renderspuVBoxCompositorTryAcquire(m_pWinInfo, &pCompositor);
                                 if (RT_SUCCESS(rc))
                                 {
-                                        fCompositorAquired = true;
+                                        Assert(pCompositor);
                                 }
                             else if (rc == VERR_SEM_BUSY)
@@ -1037 +1118 @@
                 
 #ifdef CR_RENDER_FORCE_PRESENT_MAIN_THREAD
-                        Assert(!fCompositorAquired);
+                        Assert(!pCompositor);
 #endif  
-                        if (fCompositorAquired)
+                        if (pCompositor)
                         {
-                                Assert(m_pCompositor);
-                                [self vboxPresent];
+                                [self vboxPresent:pCompositor];
                                 renderspuVBoxCompositorRelease(m_pWinInfo);
                         }
@@ -1048 +1128 @@
                 else
                 {
-                        AssertRelease(!fCompositorAquired);
+                        AssertRelease(!pCompositor);
                 }
         [self unlockFocus];
@@ -1060 +1140 @@
         if (m_pSharedGLCtx)
             {
-                m_pCompositor = renderspuVBoxCompositorAcquire(m_pWinInfo);
-                if (m_pCompositor)
+                VBOXVR_SCR_COMPOSITOR *pCompositor = renderspuVBoxCompositorAcquire(m_pWinInfo);
+                if (pCompositor)
                 {
-                        [self vboxPresent];
+                        [self vboxPresent:pCompositor];
                                 renderspuVBoxCompositorRelease(m_pWinInfo);
                         }
@@ -1076 +1156 @@
 }
 
-- (void)vboxPresent
-{
-    DEBUG_MSG(("OVIW(%p): renderFBOToView\n", (void*)self));
+- (void)vboxPresent:(PVBOXVR_SCR_COMPOSITOR)pCompositor
+{
+    VBOX_CR_RENDER_CTX_INFO CtxInfo;    
     
-    Assert(m_pCompositor);
+    DEBUG_MSG(("OVIW(%p): renderFBOToView\n", (void*)self));    
+    
+    Assert(pCompositor);
     
 #if 0 //def DEBUG
@@ -1090 +1172 @@
             }
 #endif
+
+    vboxCtxEnter(m_pSharedGLCtx, &CtxInfo);
     
-    [self performSelectorMakingCurrent:m_pSharedGLCtx idSel:@selector(vboxPresentCS)];
-}
-
-- (void)vboxPresentCS
+    [self vboxPresentCS:pCompositor];
+    
+    vboxCtxLeave(&CtxInfo);
+}
+
+- (void)vboxPresentCS:(PVBOXVR_SCR_COMPOSITOR)pCompositor
 {
         {
@@ -1111 +1197 @@
             
             /* Render FBO content to the dock tile when necessary. */
-            [self vboxPresentToDockTileCS];
+            [self vboxPresentToDockTileCS:pCompositor];
             
-            [self vboxPresentToViewCS];
+            [self vboxPresentToViewCS:pCompositor];
         }
 }
 
-- (void)vboxPresentToViewCS
+- (void)vboxPresentToViewCS:(PVBOXVR_SCR_COMPOSITOR)pCompositor
 {
     NSRect r = [self frame];
@@ -1126 +1212 @@
     PVBOXVR_SCR_COMPOSITOR_ENTRY pEntry;
         
-    CrVrScrCompositorIterInit(m_pCompositor, &CIter);
+    CrVrScrCompositorIterInit(pCompositor, &CIter);
         
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
@@ -1138 +1224 @@
         uint32_t cRegions;
         const RTRECT *paSrcRegions, *paDstRegions;
-        int rc = CrVrScrCompositorEntryRegionsGet(m_pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
+        int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
         if (RT_SUCCESS(rc))
         {
@@ -1177 +1263 @@
 }
 
-- (void)performSelectorMakingCurrent:(NSOpenGLContext*)pCtx idSel:(SEL)selector
-{
-    NSOpenGLContext *pOldCtx = vboxCtxGetCurrent();
-    NSView *pOldView = (pOldCtx ? [pOldCtx view] : nil);
-    NSView *pView = [pCtx view];
-    bool fNeedCtxSwitch = (pOldCtx != pCtx || pOldView != pView);
-    Assert(pCtx);
- //   Assert(pOldCtx == m_pGLCtx);
- //   Assert(pOldView == self);
- //   Assert(fNeedCtxSwitch);
-    if (fNeedCtxSwitch)
-    {
-        if(pOldCtx != nil)
-            glFlush();
-        
-        [pCtx makeCurrentContext];
-    }
-    
-    [self performSelector:selector];
-    
-    if (fNeedCtxSwitch)
-    {
-        glFlush();
-        if (pOldCtx != nil)
-        {
-            if ([pOldCtx view] != pOldView)
-            {
-                [pOldCtx setView: pOldView];
-            }
-        
-                [pOldCtx makeCurrentContext];
-            
-#ifdef DEBUG
-            {
-                NSOpenGLContext *pTstOldCtx = [NSOpenGLContext currentContext];
-                NSView *pTstOldView = (pTstOldCtx ? [pTstOldCtx view] : nil);
-                Assert(pTstOldCtx == pOldCtx);
-                Assert(pTstOldView == pOldView);
-            }
-#endif
-        }
-        else
-        {
-            [NSOpenGLContext clearCurrentContext];
-        }
-    }
-}
-
-- (void)presentComposition:(PVBOXVR_SCR_COMPOSITOR)pCompositor withChangedEntry:(PVBOXVR_SCR_COMPOSITOR_ENTRY)pChangedEntry
+- (void)presentComposition:(PVBOXVR_SCR_COMPOSITOR_ENTRY)pChangedEntry
 {
     [self vboxTryDraw];
 }
 
-- (void)vboxPresentToDockTileCS
+- (void)vboxPresentToDockTileCS:(PVBOXVR_SCR_COMPOSITOR)pCompositor
 {
     NSRect r        = [self frame];
@@ -1272 +1310 @@
             rr = [m_DockTileView frame];
             
-            CrVrScrCompositorIterInit(m_pCompositor, &CIter);
+            CrVrScrCompositorIterInit(pCompositor, &CIter);
             while ((pEntry = CrVrScrCompositorIterNext(&CIter)) != NULL)
             {
                 uint32_t cRegions;
                 const RTRECT *paSrcRegions, *paDstRegions;
-                int rc = CrVrScrCompositorEntryRegionsGet(m_pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
+                int rc = CrVrScrCompositorEntryRegionsGet(pCompositor, pEntry, &cRegions, &paSrcRegions, &paDstRegions);
                 if (RT_SUCCESS(rc))
                 {
@@ -1363 +1401 @@
     }
 
-    [self vboxTryDraw];
+    /* we need to redwar on regions change, however the compositor now is cleared 
+     * because all compositor&window data-related modifications are performed with compositor cleared
+     * the renderspu client will re-set the compositor after modifications are complete
+     * this way we indicate renderspu generic code not to ignore the empty compositor */
+    m_pWinInfo->fCompositorPresentEmpty = GL_TRUE;
 }
 
@@ -1659 +1701 @@
 }
 
-void cocoaViewPresentComposition(NativeNSViewRef pView, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry)
+void cocoaViewPresentComposition(NativeNSViewRef pView, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry)
 {
     NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
 
-    [(OverlayView*)pView presentComposition:pCompositor withChangedEntry:pChangedEntry];
+    [(OverlayView*)pView presentComposition:pChangedEntry];
 
     [pPool release];

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

@@ -1972 +1972 @@
 }
 
-void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
 {
     /* the CR_RENDER_FORCE_PRESENT_MAIN_THREAD is actually inherited from cocoa backend impl,
@@ -1979 +1979 @@
      * @todo: change to some more generic macro name */
 #ifndef CR_RENDER_FORCE_PRESENT_MAIN_THREAD
-    struct VBOXVR_SCR_COMPOSITOR *pCurCompositor;
+    struct VBOXVR_SCR_COMPOSITOR *pCompositor;
     /* we do not want to be blocked with the GUI thread here, so only draw her eif we are really able to do that w/o bllocking */
-    int rc = renderspuVBoxCompositorTryAcquire(window, &pCurCompositor);
+    int rc = renderspuVBoxCompositorTryAcquire(window, &pCompositor);
     if (RT_SUCCESS(rc))
     {
-        Assert(pCurCompositor == pCompositor);
         renderspuVBoxPresentCompositionGeneric(window, pCompositor, pChangedEntry, 0);
         renderspuVBoxCompositorRelease(window);

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

@@ -1245 +1245 @@
 }
 
-void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR * pCompositor, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
+void renderspu_SystemVBoxPresentComposition( WindowInfo *window, struct VBOXVR_SCR_COMPOSITOR_ENTRY *pChangedEntry )
 {
     /* the CR_RENDER_FORCE_PRESENT_MAIN_THREAD is actually inherited from cocoa backend impl,
@@ -1252 +1252 @@
      * @todo: change to some more generic macro name */
 #ifndef CR_RENDER_FORCE_PRESENT_MAIN_THREAD
-    struct VBOXVR_SCR_COMPOSITOR *pCurCompositor;
+    struct VBOXVR_SCR_COMPOSITOR *pCompositor;
     /* we do not want to be blocked with the GUI thread here, so only draw her eif we are really able to do that w/o bllocking */
-    int rc = renderspuVBoxCompositorTryAcquire(window, &pCurCompositor);
+    int rc = renderspuVBoxCompositorTryAcquire(window, &pCompositor);
     if (RT_SUCCESS(rc))
     {
-        Assert(pCurCompositor == pCompositor);
         renderspuVBoxPresentCompositionGeneric(window, pCompositor, pChangedEntry, 0);
         renderspuVBoxCompositorRelease(window);