VirtualBox

Ignore:
Timestamp:
Oct 26, 2017 5:17:51 PM (7 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
118714
Message:

HostServices/SharedOpenGL: scm updates

Location:
trunk/src/VBox/HostServices/SharedOpenGL/render
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostServices/SharedOpenGL/render/render.def

    • Property svn:keywords changed from Id to Id Revision
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu.c

    • Property svn:keywords changed from Id to Id Revision
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_agl.c

    • Property svn:keywords changed from Id to Id Revision
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa.c

    r62489 r69390  
     1/* $Id$ */
    12/** @file
    23 * VirtualBox OpenGL Cocoa Window System implementation
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_cocoa_helper.m

    r56276 r69390  
    6262 *   this is our own one, before use. Really neat concept of Objective-C/Cocoa
    6363 *   ;)
    64  * 
     64 *
    6565 */
    6666
    67 /*******************************************************************************
    68 *   Header Files                                                               *
    69 *******************************************************************************/
     67
     68/*********************************************************************************************************************************
     69*   Header Files                                                                                                                 *
     70*********************************************************************************************************************************/
    7071#ifdef IN_VMSVGA3D
    7172# define LOG_GROUP LOG_GROUP_DEV_VMSVGA
     
    108109
    109110
    110 /*******************************************************************************
    111 *   Defined Constants And Macros                                               *
    112 *******************************************************************************/
     111/*********************************************************************************************************************************
     112*   Defined Constants And Macros                                                                                                 *
     113*********************************************************************************************************************************/
    113114/* Debug macros */
    114 /** @def FBO 
     115/** @def FBO
    115116 * Disable this to see how the output is without the FBO in the middle of the processing chain. */
    116117#define FBO 1
    117118/** @def CR_RENDER_FORCE_PRESENT_MAIN_THREAD
    118  * Force present schedule to main thread. */ 
     119 * Force present schedule to main thread. */
    119120/** @def SHOW_WINDOW_BACKGROUND
    120  * Define this to see the window background even if the window is clipped. */ 
    121 /** @def DEBUG_VERBOSE 
     121 * Define this to see the window background even if the window is clipped. */
     122/** @def DEBUG_VERBOSE
    122123 * Define this to get some debug info about the messages flow. */
    123124#if 0 || defined(DOXYGEN_RUNNING)
     
    204205        if (RT_UNLIKELY(iGlCheckErr != GL_NO_ERROR)) \
    205206            AssertMsgFailed((a_szOp ": iGlCheckErr=%#x\n", iGlCheckErr)); \
    206     } while (0) 
     207    } while (0)
    207208#else
    208209# define DEBUG_CLEAR_GL_ERRORS()        do {} while (0)
     
    240241
    241242/**
    242  * Works functions that creates a NSOpenGLPixelFormat instance. 
    243  * 
     243 * Works functions that creates a NSOpenGLPixelFormat instance.
     244 *
    244245 * @returns Instance.
    245246 * @param   fVisParams          Context flags.
     
    367368        fAdjusted = true;
    368369    }
    369    
     370
    370371    return fAdjusted;
    371372#endif
     
    373374
    374375
    375 /** 
    376  * State carrying structure for use with vboxCtxEnter and vboxCtxLeave 
    377  */ 
     376/**
     377 * State carrying structure for use with vboxCtxEnter and vboxCtxLeave
     378 */
    378379typedef struct VBOX_CR_RENDER_CTX_INFO
    379380{
     
    387388static void vboxCtxEnter(NSOpenGLContext *pNewCtx, PVBOX_CR_RENDER_CTX_INFO pCtxInfo)
    388389{
    389     NSOpenGLContext *pOldCtx  = vboxCtxGetCurrent(); 
     390    NSOpenGLContext *pOldCtx  = vboxCtxGetCurrent();
    390391    NSView          *pOldView = pOldCtx ? [pOldCtx view] : nil;
    391392    NSView          *pNewView = [pNewCtx view];
     
    393394    Assert(pNewCtx);
    394395
    395     if (   pOldCtx  != pNewCtx 
     396    if (   pOldCtx  != pNewCtx
    396397        || pOldView != pNewView)
    397398    {
    398399        if (pOldCtx != nil)
    399400            glFlush();
    400        
     401
    401402        DEBUG_CLEAR_GL_ERRORS();
    402403        [pNewCtx makeCurrentContext];
    403404        DEBUG_CHECK_GL_ERROR("makeCurrentContext");
    404        
     405
    405406        pCtxInfo->fIsValid = true;
    406407        pCtxInfo->pCtx     = pOldCtx;
    407408        /** @todo r=bird: Why do we save the NEW VIEW here? vboxCtxLeave calls it 'pOldView'. Bug? */
    408         pCtxInfo->pView    = pNewView; 
     409        pCtxInfo->pView    = pNewView;
    409410    }
    410411    else
     
    413414        pCtxInfo->fIsValid = false;
    414415    }
    415 }   
    416    
     416}
     417
    417418static void vboxCtxLeave(PVBOX_CR_RENDER_CTX_INFO pCtxInfo)
    418419{
     
    421422        NSOpenGLContext *pOldCtx  = pCtxInfo->pCtx;
    422423        NSView          *pOldView = pCtxInfo->pView;
    423    
     424
    424425        glFlush();
    425426        if (pOldCtx != nil)
     
    430431            /** @todo r=bird: Figure out what we really want to do here, and either rename
    431432             *        pOldView or fix the code. */
    432             if ([pOldCtx view] != pOldView) 
     433            if ([pOldCtx view] != pOldView)
    433434            {
    434435                DEBUG_CLEAR_GL_ERRORS();
     
    436437                DEBUG_CHECK_GL_ERROR("setView");
    437438            }
    438        
     439
    439440            DEBUG_CLEAR_GL_ERRORS();
    440441            [pOldCtx makeCurrentContext];
    441442            DEBUG_CHECK_GL_ERROR("makeCurrentContext");
    442            
     443
    443444#ifdef VBOX_STRICT
    444445            {
     
    458459
    459460
    460 /** 
     461/**
    461462 * Custom OpenGL context class.
    462463 *
    463464 * This implementation doesn't allow to set a view to the context, but save the
    464  * view for later use.  Also it saves a copy of the pixel format used to create 
    465  * that context for later use. 
    466  */ 
     465 * view for later use.  Also it saves a copy of the pixel format used to create
     466 * that context for later use.
     467 */
    467468@interface OverlayOpenGLContext: NSOpenGLContext
    468469{
     
    509510
    510511@implementation VBoxTaskPerformSelector
    511    
     512
    512513/**
    513514 * Initializes a VBoxTaskPerformSelector.
    514  * 
     515 *
    515516 * @param   aObject             The object (reference not consumed).
    516517 * @param   aSelector           The method selector.
     
    550551
    551552/**
    552  * 
     553 *
    553554 */
    554555@interface VBoxTaskComposite : VBoxTask
     
    589590/**
    590591 * Adds a task to the composite task object.
    591  * 
     592 *
    592593 * @param   pTask               Task to add.  Reference is NOT consumed.
    593594 */
     
    621622            break;
    622623        }
    623        
     624
    624625        NSUInteger count = [m_pArray count];
    625626        Assert(m_CurIndex <= count);
     
    634635        VBoxTask *pTask = (VBoxTask *)[m_pArray objectAtIndex:m_CurIndex];
    635636        Assert(pTask != nil);
    636        
     637
    637638        ++m_CurIndex;
    638        
     639
    639640        /*
    640641         * Remove the first 1025 empty entires.
     
    649650        }
    650651        RTCritSectLeave(&m_Lock);
    651        
     652
    652653        /*
    653654         * Run the task and release it.
     
    667668        [pTask release];
    668669    }
    669    
     670
    670671    [m_pArray release];
    671672    RTCritSectDelete(&m_Lock);
     
    677678
    678679/**
    679  * 
    680  * 
     680 *
     681 *
    681682 */
    682683@interface VBoxMainThreadTaskRunner : NSObject
     
    702703        m_pTasks = [[VBoxTaskComposite alloc] init];
    703704    }
    704    
     705
    705706    return self;
    706707}
     
    728729        [self performSelectorOnMainThread:@selector(runTasks) withObject:nil waitUntilDone:NO];
    729730    }
    730    
     731
    731732    DEBUG_FUNC_LEAVE();
    732733}
     
    734735/**
    735736 * Adds a task calling an object method (selector).
    736  * 
     737 *
    737738 * @param   aObject             The object (reference not consumed)..
    738739 * @param   aSelector           The method selector.
     
    746747}
    747748
    748    
     749
    749750/**
    750751 * Internal method for running the pending tasks.
     
    757758        /** @todo r=bird: This release and the retain in the add method aren't
    758759         *        necessarily balanced if there are more than one call to add().
    759          * 
     760         *
    760761         *  This could probably end up deleting the singleton prematurely and leave
    761762         *  globalInstance() returning pointers to a stale object in freed memory,
     
    773774}
    774775
    775 /** 
    776  * Callback for calling runTasks via renderspuCalloutClient. 
    777  * @param   pvUser      The VBoxMainThreadTaskRunner singleton. 
    778  */ 
     776/**
     777 * Callback for calling runTasks via renderspuCalloutClient.
     778 * @param   pvUser      The VBoxMainThreadTaskRunner singleton.
     779 */
    779780static DECLCALLBACK(void) VBoxMainThreadTaskRunner_RcdRunCallback(void *pvUser)
    780781{
     
    786787}
    787788
    788 /** 
    789  * Runs pending tasks synchronously, if possible in the current context. 
    790  * 
     789/**
     790 * Runs pending tasks synchronously, if possible in the current context.
     791 *
    791792 * @returns true if executed tasks, false if not possible.
    792793 */
     
    794795{
    795796#ifndef IN_VMSVGA3D
    796     /* 
     797    /*
    797798     * Call on main thread (?) via renderspuCalloutClient (whatever that is).
    798799     */
     
    804805    }
    805806#endif
    806    
     807
    807808    /*
    808809     * Run directly if on main thread.
     
    813814        return true;
    814815    }
    815    
     816
    816817    /* Not possible. */
    817818    return false;
     
    834835#endif
    835836
    836 /** 
    837  * The custom view class. 
    838  * 
    839  * This is the main class of the cocoa OpenGL implementation.  It manages a 
    840  * frame buffer object for the rendering of the guest applications.  The guest 
     837/**
     838 * The custom view class.
     839 *
     840 * This is the main class of the cocoa OpenGL implementation.  It manages a
     841 * frame buffer object for the rendering of the guest applications.  The guest
    841842 * applications render in this frame buffer which is bound to an OpenGL texture.
    842  * To display the guest content, a secondary shared OpenGL context of the main 
     843 * To display the guest content, a secondary shared OpenGL context of the main
    843844 * OpenGL context is created.  The secondary context is marked as non-opaque and
    844  * the texture is displayed on an object which is composed out of the several 
    845  * visible region rectangles. 
    846  */ 
     845 * the texture is displayed on an object which is composed out of the several
     846 * visible region rectangles.
     847 */
    847848@interface OverlayView : NSView
    848849{
     
    850851    NSView             *m_pParentView;
    851852    NSWindow           *m_pOverlayWin;
    852                        
     853
    853854    NSOpenGLContext    *m_pGLCtx;
    854855    NSOpenGLContext    *m_pSharedGLCtx;
    855856    RTTHREAD            m_Thread;
    856                        
     857
    857858    GLuint              m_FBOId;
    858859
     
    875876
    876877    /** @name Position/Size tracking
    877      * @{ */ 
     878     * @{ */
    878879    NSPoint             m_Pos;
    879880    NSSize              m_Size;
     
    883884    NSRect              m_RootRect;
    884885    float               m_yInvRootOffset;
    885    
     886
    886887#ifndef IN_VMSVGA3D
    887888    CR_BLITTER         *m_pBlitter;
     
    894895    bool                m_fEverSized;
    895896}
    896 - (id)initWithFrame:(NSRect)frame thread:(RTTHREAD)aThread parentView:(NSView *)pParentView winInfo:(WindowInfo *)pWinInfo 
     897- (id)initWithFrame:(NSRect)frame thread:(RTTHREAD)aThread parentView:(NSView *)pParentView winInfo:(WindowInfo *)pWinInfo
    897898         fVisParams:(GLbitfield) fVisParams;
    898899- (void)setGLCtx:(NSOpenGLContext*)pCtx;
     
    960961@end
    961962
    962 /** 
     963/**
    963964 * Helper view.
    964965 *
     
    967968 * (which happens on fullscreen/seamless entry/exit) the overlay
    968969 * window is informed & can add them self as a child window
    969  * again. 
    970  */ 
     970 * again.
     971 */
    971972@class OverlayWindow;
    972973@interface OverlayHelperView: NSView
     
    978979@end
    979980
    980 /** 
     981/**
    981982 * Custom window class.
    982983 *
     
    984985 * Its a direct child of the Qt Main window. It marks its background
    985986 * transparent & non opaque to make clipping possible. It also disable mouse
    986  * events and handle frame change events of the parent view. 
    987  */ 
     987 * events and handle frame change events of the parent view.
     988 */
    988989@interface OverlayWindow : NSWindow
    989990{
     
    10271028    if (self)
    10281029    {
    1029         /* 
     1030        /*
    10301031         * We need a lock cause the thumb image could be accessed from the main
    10311032         * thread when someone is calling display on the dock tile & from the
    1032          * OpenGL thread when the thumbnail is updated. 
    1033          */ 
     1033         * OpenGL thread when the thumbnail is updated.
     1034         */
    10341035        m_Lock = [[NSLock alloc] init];
    10351036    }
    10361037
    10371038    DEBUG_FUNC_LEAVE();
    1038    
     1039
    10391040    return self;
    10401041}
     
    10431044{
    10441045    DEBUG_FUNC_ENTER();
    1045    
     1046
    10461047    [self cleanup];
    10471048    [m_Lock release];
    10481049
    10491050    [super dealloc];
    1050    
     1051
    10511052    DEBUG_FUNC_LEAVE();
    10521053}
     
    10551056{
    10561057    DEBUG_FUNC_ENTER();
    1057    
     1058
    10581059    if (m_ThumbImage != nil)
    10591060    {
     
    10671068        m_ThumbBitmap = nil;
    10681069    }
    1069    
     1070
    10701071    DEBUG_FUNC_LEAVE();
    10711072}
     
    11911192
    11921193    [super dealloc];
    1193    
     1194
    11941195    DEBUG_FUNC_LEAVE();
    11951196}
     
    12011202    GLint val;
    12021203    [m_pPixelFormat getValues:&val forAttribute:NSOpenGLPFADoubleBuffer forVirtualScreen:0];
    1203    
     1204
    12041205    DEBUG_FUNC_LEAVE();
    12051206    return val == GL_TRUE ? YES : NO;
     
    12381239    m_pView = NULL;;
    12391240    [super clearDrawable];
    1240    
     1241
    12411242    DEBUG_FUNC_LEAVE();
    12421243}
     
    12821283
    12831284    [m_pOverlayWindow parentWindowChanged:[self window]];
    1284    
     1285
    12851286    DEBUG_FUNC_LEAVE();
    12861287}
     
    13101311        [m_pOverlayView setOverlayWin: self];
    13111312
    1312 #ifdef IN_VMSVGA3D                                                                           
     1313#ifdef IN_VMSVGA3D
    13131314        NSRect frame = [pParentView frame];
    13141315        frame.origin.x = frame.origin.x = 0;
     
    13681369
    13691370    [super dealloc];
    1370    
     1371
    13711372    DEBUG_FUNC_LEAVE();
    13721373}
     
    13771378    DEBUG_MSG(("OWIN(%p): parentWindowFrameChanged\n", (void *)self));
    13781379
    1379     /* 
     1380    /*
    13801381     * Reposition this window with the help of the OverlayView. Perform the
    1381      * call in the OpenGL thread. 
    1382      */ 
     1382     * call in the OpenGL thread.
     1383     */
    13831384    /*
    13841385    [m_pOverlayView performSelector:@selector(vboxReshapePerform) onThread:m_Thread withObject:nil waitUntilDone:YES];
     
    13861387
    13871388    if ([m_pOverlayView isEverSized])
    1388     {   
     1389    {
    13891390        if ([NSThread isMainThread])
    13901391            [m_pOverlayView vboxReshapePerform];
     
    13921393            [self performSelectorOnMainThread:@selector(vboxReshapePerform) withObject:nil waitUntilDone:NO];
    13931394    }
    1394    
     1395
    13951396    DEBUG_FUNC_LEAVE();
    13961397}
     
    14151416        [pWindow addChildWindow:self ordered:NSWindowAbove];
    14161417
    1417         /* 
     1418        /*
    14181419         * Reshape the overlay view after a short waiting time to let the main
    14191420         * window resize itself properly.
     
    14251426
    14261427        if ([m_pOverlayView isEverSized])
    1427         {   
     1428        {
    14281429            if ([NSThread isMainThread])
    14291430                [m_pOverlayView vboxReshapePerform];
    14301431            else
    14311432                [self performSelectorOnMainThread:@selector(vboxReshapePerform) withObject:nil waitUntilDone:NO];
    1432         }       
    1433     }
    1434    
     1433        }
     1434    }
     1435
    14351436    DEBUG_FUNC_LEAVE();
    14361437}
     
    14471448@implementation OverlayView
    14481449
    1449 - (id)initWithFrame:(NSRect)frame thread:(RTTHREAD)aThread parentView:(NSView *)pParentView winInfo:(WindowInfo *)pWinInfo 
     1450- (id)initWithFrame:(NSRect)frame thread:(RTTHREAD)aThread parentView:(NSView *)pParentView winInfo:(WindowInfo *)pWinInfo
    14501451         fVisParams:(GLbitfield) fVisParams
    14511452{
    1452     COCOA_LOG_FLOW(("%s: self=%p aThread=%p pParentView=%p pWinInfo=%p fVisParams=%#x\n", __PRETTY_FUNCTION__, (void *)self, 
     1453    COCOA_LOG_FLOW(("%s: self=%p aThread=%p pParentView=%p pWinInfo=%p fVisParams=%#x\n", __PRETTY_FUNCTION__, (void *)self,
    14531454                    (void *)aThread, (void *)pParentView, (void *)pWinInfo, fVisParams));
    14541455
     
    14951496
    14961497    [self setGLCtx:nil];
    1497    
     1498
    14981499    if (m_pSharedGLCtx)
    14991500    {
     
    15031504        [m_pSharedGLCtx release];
    15041505        m_pSharedGLCtx = nil;
    1505        
     1506
    15061507
    15071508#ifndef IN_VMSVGA3D
     
    15131514
    15141515    [self clearVisibleRegions];
    1515    
     1516
    15161517    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
    15171518}
     
    15291530- (void)drawRect:(NSRect)aRect
    15301531{
    1531     COCOA_LOG_FLOW(("%s: self=%p aRect=%d,%d %d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)aRect.origin.x, (int)aRect.origin.y, 
     1532    COCOA_LOG_FLOW(("%s: self=%p aRect=%d,%d %d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)aRect.origin.x, (int)aRect.origin.y,
    15321533                    (int)aRect.size.width, (int)aRect.size.height));
    15331534
     
    15611562            [pCtx retain];
    15621563    }
    1563        
     1564
    15641565    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
    15651566}
     
    15821583
    15831584    m_pParentView = pView;
    1584    
     1585
    15851586    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
    15861587}
     
    15911592
    15921593    m_pOverlayWin = pWin;
    1593    
     1594
    15941595    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
    15951596}
     
    16031604- (void)vboxSetPosUI:(NSPoint)pos
    16041605{
    1605     COCOA_LOG_FLOW(("%s: self=%p pos=%d,%d (old pos=%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, (int)pos.x, (int)pos.y, 
     1606    COCOA_LOG_FLOW(("%s: self=%p pos=%d,%d (old pos=%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, (int)pos.x, (int)pos.y,
    16061607                    (int)m_Pos.x, (int)m_Pos.y));
    16071608
     
    16291630- (void)vboxSetPos:(NSPoint)pos
    16301631{
    1631     COCOA_LOG_FLOW(("%s: self=%p pos=%d,%d (old pos=%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, (int)pos.x, (int)pos.y, 
     1632    COCOA_LOG_FLOW(("%s: self=%p pos=%d,%d (old pos=%d,%d)\n", __PRETTY_FUNCTION__, (void *)self, (int)pos.x, (int)pos.y,
    16321633                    (int)m_Pos.x, (int)m_Pos.y));
    16331634
     
    16561657    BOOL        fIsMain = [NSThread isMainThread];
    16571658    NSWindow   *pWin    = nil;
    1658    
     1659
    16591660    Assert(fIsMain);
    16601661
     
    16661667    [pWin setContentView: nil];
    16671668    [[pWin parentWindow] removeChildWindow: pWin];
    1668    
     1669
    16691670    if (fIsMain)
    16701671        [pWin release];
     
    16731674        /* We can NOT run synchronously with the main thread since this may lead to a deadlock,
    16741675           caused by main thread waiting xpcom thread, xpcom thread waiting to main hgcm thread,
    1675            and main hgcm thread waiting for us, this is why use waitUntilDone:NO, 
    1676            which should cause no harm. */ 
     1676           and main hgcm thread waiting for us, this is why use waitUntilDone:NO,
     1677           which should cause no harm. */
    16771678        [pWin performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
    16781679    }
     
    16861687        /* We can NOT run synchronously with the main thread since this may lead to a deadlock,
    16871688           caused by main thread waiting xpcom thread, xpcom thread waiting to main hgcm thread,
    1688            and main hgcm thread waiting for us, this is why use waitUntilDone:NO. 
     1689           and main hgcm thread waiting for us, this is why use waitUntilDone:NO.
    16891690           We need to avoid concurrency though, so we cleanup some data right away via a cleanupData call. */
    16901691        [self performSelectorOnMainThread:@selector(release) withObject:nil waitUntilDone:NO];
    16911692    }
    1692    
     1693
    16931694#ifndef IN_VMSVGA3D
    16941695    renderspuWinRelease(m_pWinInfo);
    16951696#endif
    1696    
     1697
    16971698    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
    16981699}
     
    17281729{
    17291730    COCOA_LOG_FLOW(("%s: self=%p size=%d,%d\n", __PRETTY_FUNCTION__, (void *)self, (int)size.width, (int)size.height));
    1730    
     1731
    17311732    VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
    17321733    NSValue *pSize = [NSValue valueWithSize:size];
     
    17521753    [self vboxBlitterSyncWindow];
    17531754#endif
    1754        
     1755
    17551756    /* Clear background to transparent. */
    17561757    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     
    19992000               (int)m_Pos.x, (int)m_Pos.y, (int)m_Size.width, (int)m_Size.height));
    20002001
    2001     /* @todo galitsyn: drop this!
     2002    /** @todo galitsyn: drop this!
    20022003     * Later we have to correct the texture position in the case the window is
    2003      * out of the parents window frame. So save the shift values for later use. */ 
     2004     * out of the parents window frame. So save the shift values for later use. */
    20042005    m_RootRect.origin.x = windowFrameSCS.origin.x - childFrameSCS.origin.x;
    20052006    m_RootRect.origin.y =  childFrameSCS.size.height + childFrameSCS.origin.y - (windowFrameSCS.size.height + windowFrameSCS.origin.y);
     
    20222023    if (m_pSharedGLCtx)
    20232024    {
    2024         VBOX_CR_RENDER_CTX_INFO CtxInfo; 
     2025        VBOX_CR_RENDER_CTX_INFO CtxInfo;
    20252026        vboxCtxEnter(m_pSharedGLCtx, &CtxInfo);
    20262027
     
    20732074- (void)makeCurrentFBO
    20742075{
    2075     COCOA_LOG_FLOW(("%s: self=%p - m_pGLCtx=%p m_fNeedCtxUpdate=%d\n", __PRETTY_FUNCTION__, (void *)self, 
     2076    COCOA_LOG_FLOW(("%s: self=%p - m_pGLCtx=%p m_fNeedCtxUpdate=%d\n", __PRETTY_FUNCTION__, (void *)self,
    20762077                    (void *)m_pGLCtx, m_fNeedCtxUpdate));
    20772078
     
    21192120            m_fNeedCtxUpdate = false;
    21202121        }
    2121        
     2122
    21222123        if (!m_FBOId)
    21232124        {
     
    21392140        return true;
    21402141    }
    2141        
    2142 #ifndef IN_VMSVGA3D           
     2142
     2143#ifndef IN_VMSVGA3D
    21432144    Assert(!m_pBlitter);
    21442145    m_pBlitter = RTMemAlloc(sizeof(*m_pBlitter));
     
    21492150        return false;
    21502151    }
    2151        
    2152     int rc = CrBltInit(m_pBlitter, NULL, false /*fCreateNewCtx*/, false /*fForceDrawBlt*/, 
     2152
     2153    int rc = CrBltInit(m_pBlitter, NULL, false /*fCreateNewCtx*/, false /*fForceDrawBlt*/,
    21532154                       &render_spu.GlobalShaders, &render_spu.blitterDispatch);
    21542155    if (RT_FAILURE(rc))
     
    21602161        COCOA_LOG_FLOW(("%s: returns false - CrBltInit failed with rc=%Rrc\n", __PRETTY_FUNCTION__, rc));
    21612162        return false;
    2162     }       
     2163    }
    21632164
    21642165    COCOA_LOG_FLOW(("%s: blitter (%p) created successfully for view 0x%p\n", (void *)m_pBlitter, (void *)self));
     
    21682169    NSOpenGLPixelFormat *pPixelFormat = [(OverlayOpenGLContext *)m_pGLCtx openGLPixelFormat];
    21692170    NSOpenGLContext     *pSharedGLCtx = [[NSOpenGLContext alloc] initWithFormat:pPixelFormat shareContext:m_pGLCtx];
    2170        
     2171
    21712172    /* Set the new context as non opaque */
    21722173    GLint opaque = 0;
     
    21782179
    21792180    m_pSharedGLCtx = pSharedGLCtx;
    2180    
     2181
    21812182    COCOA_LOG_FLOW(("%s: returns true - new m_pSharedGLCtx=%p\n", __PRETTY_FUNCTION__, (void *)m_pSharedGLCtx));
    21822183    return true;
     
    21882189
    21892190    glFlush();
    2190                  
     2191
    21912192    /* Issue to the gui thread. */
    21922193    [self performSelectorOnMainThread:@selector(vboxTryDrawUI) withObject:nil waitUntilDone:NO];
     
    21982199{
    21992200    COCOA_LOG_FLOW(("%s: self=%p fVisible=%d\n", __PRETTY_FUNCTION__, (void *)self, fVisible));
    2200    
     2201
    22012202    VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
    22022203    NSNumber *pVisObj = [NSNumber numberWithBool:fVisible];
     
    22172218- (void)vboxSetVisibleUIObj:(NSNumber *)pVisibleObj
    22182219{
    2219     COCOA_LOG_FLOW(("%s: self=%p pVisibleObj=%p(%d)\n", __PRETTY_FUNCTION__, 
     2220    COCOA_LOG_FLOW(("%s: self=%p pVisibleObj=%p(%d)\n", __PRETTY_FUNCTION__,
    22202221                    (void *)self, (void *)pVisibleObj, [pVisibleObj boolValue]));
    22212222
     
    22562257            [self vboxReshapeOnReparentPerform];
    22572258    }
    2258    
     2259
    22592260    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
    22602261}
     
    22632264{
    22642265    COCOA_LOG_FLOW(("%s: self=%p\n", __PRETTY_FUNCTION__, (void *)self));
    2265    
     2266
    22662267    if ([self isHidden])
    22672268    {
     
    22892290    }
    22902291#endif
    2291    
     2292
    22922293    const VBOXVR_SCR_COMPOSITOR *pCompositor = NULL;
    22932294#ifndef IN_VMSVGA3D
     
    23192320                return;
    23202321            }
    2321            
     2322
    23222323            Assert(m_pSharedGLCtx);
    2323            
     2324
    23242325            pCompositor = renderspuVBoxCompositorAcquire(m_pWinInfo);
    23252326            Assert(!m_fDataVisible);
     
    23412342#endif /* !IN_VMSVGA3D */
    23422343
    2343    
     2344
    23442345    if ([self lockFocusIfCanDraw])
    23452346    {
    23462347        COCOA_LOG_FLOW(("%s: Calling vboxPresent\n", __PRETTY_FUNCTION__));
    2347         [self vboxPresent:pCompositor];           
     2348        [self vboxPresent:pCompositor];
    23482349        [self unlockFocus];
    23492350    }
     
    23542355        m_fCleanupNeeded = false;
    23552356    }
    2356 #endif   
     2357#endif
    23572358    else
    23582359    {
     
    23602361        [NSTimer scheduledTimerWithTimeInterval:0.1 target:self selector:@selector(vboxTryDrawUI) userInfo:nil repeats:NO];
    23612362    }
    2362    
     2363
    23632364#ifndef IN_VMSVGA3D
    23642365    renderspuVBoxCompositorUnlock(m_pWinInfo);
     
    23822383#endif
    23832384
    2384     VBOX_CR_RENDER_CTX_INFO CtxInfo;   
     2385    VBOX_CR_RENDER_CTX_INFO CtxInfo;
    23852386    vboxCtxEnter(m_pSharedGLCtx, &CtxInfo);
    2386    
     2387
    23872388    [self vboxPresentCS:pCompositor];
    2388    
     2389
    23892390    vboxCtxLeave(&CtxInfo);
    23902391    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
     
    23962397    if ([m_pSharedGLCtx view] != self)
    23972398    {
    2398         COCOA_LOG_FLOW(("%s: Not current view of shared ctx! Switching... (self=%p, view=%p, m_pSharedGLCtx)\n", 
     2399        COCOA_LOG_FLOW(("%s: Not current view of shared ctx! Switching... (self=%p, view=%p, m_pSharedGLCtx)\n",
    23992400                        __PRETTY_FUNCTION__, (void *)self, (void *)[m_pSharedGLCtx view], (void *)m_pSharedGLCtx));
    24002401        [m_pSharedGLCtx setView: self];
    24012402        m_fNeedViewportUpdate = true;
    24022403    }
    2403    
     2404
    24042405    if (m_fNeedViewportUpdate)
    24052406    {
     
    24072408        m_fNeedViewportUpdate = false;
    24082409    }
    2409    
     2410
    24102411    m_fCleanupNeeded = false;
    2411    
     2412
    24122413#ifndef IN_VMSVGA3D
    24132414    /* Render FBO content to the dock tile when necessary. */
     
    24152416#endif
    24162417
    2417     /* change to #if 0 to see thumbnail image */           
     2418    /* change to #if 0 to see thumbnail image */
    24182419#if 1
    24192420    [self vboxPresentToViewCS:pCompositor];
     
    24532454{
    24542455    NSRect r = [self frame];
    2455     COCOA_LOG_FLOW(("%s: self=%p - r={%d,%d %d,%d}\n", __PRETTY_FUNCTION__, (void *)self, 
     2456    COCOA_LOG_FLOW(("%s: self=%p - r={%d,%d %d,%d}\n", __PRETTY_FUNCTION__, (void *)self,
    24562457                    (int)r.origin.x, (int)r.origin.y, (int)r.size.width, (int)r.size.height));
    24572458
     
    24792480    /* Clear background to transparent */
    24802481    glClear(GL_COLOR_BUFFER_BIT);
    2481    
     2482
    24822483    m_fDataVisible = false;
    2483    
     2484
    24842485# ifndef IN_VMSVGA3D
    24852486    float xStretch;
    24862487    float yStretch;
    24872488    CrVrScrCompositorGetStretching(pCompositor, &xStretch, &yStretch);
    2488        
     2489
    24892490    VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR CIter;
    24902491    const VBOXVR_SCR_COMPOSITOR_ENTRY *pEntry;
     
    25012502            rc = CrBltEnter(m_pBlitter);
    25022503            if (RT_SUCCESS(rc))
    2503             {                   
     2504            {
    25042505                uint32_t i;
    25052506                for (i = 0; i < cRegions; ++i)
     
    25132514                    vboxNSRectToRect(&m_RootRect, &RestrictDstRect);
    25142515                    VBoxRectIntersected(&RestrictDstRect, pDstRect, &DstRect);
    2515                    
     2516
    25162517                    if (VBoxRectIsZero(&DstRect))
    25172518                        continue;
     
    25202521
    25212522                    vboxNSRectToRectUnstretched(&m_RootRect, &RestrictSrcRect, xStretch / backingStretchFactor, yStretch / backingStretchFactor);
    2522                     VBoxRectTranslate(&RestrictSrcRect, 
    2523                                       -CrVrScrCompositorEntryRectGet(pEntry)->xLeft, 
     2523                    VBoxRectTranslate(&RestrictSrcRect,
     2524                                      -CrVrScrCompositorEntryRectGet(pEntry)->xLeft,
    25242525                                      -CrVrScrCompositorEntryRectGet(pEntry)->yTop);
    25252526                    VBoxRectIntersected(&RestrictSrcRect, pSrcRect, &SrcRect);
    2526                    
     2527
    25272528                    if (VBoxRectIsZero(&SrcRect))
    25282529                        continue;
     
    25302531                    pSrcRect = &SrcRect;
    25312532                    pDstRect = &DstRect;
    2532                    
     2533
    25332534                    pTexData = CrVrScrCompositorEntryTexGet(pEntry);
    2534                    
     2535
    25352536                    CrBltBlitTexMural(m_pBlitter, true, CrTdTexGet(pTexData), pSrcRect, pDstRect, 1, fFlags | CRBLT_F_NOALPHA);
    2536                    
     2537
    25372538                    m_fDataVisible = true;
    25382539                }
     
    25772578    CR_BLITTER_WINDOW   WinInfo;
    25782579    NSRect              r;
    2579    
     2580
    25802581    if (!m_pBlitter)
    25812582        return;
    2582        
     2583
    25832584    RT_ZERO(WinInfo);
    2584    
     2585
    25852586    r = [self frame];
    25862587    WinInfo.width = r.size.width;
    25872588    WinInfo.height = r.size.height;
    2588    
     2589
    25892590    Assert(WinInfo.width == m_RootRect.size.width);
    25902591    Assert(WinInfo.height == m_RootRect.size.height);
    25912592
    25922593    /*CrBltMuralSetCurrentInfo(m_pBlitter, NULL);*/
    2593    
     2594
    25942595    CrBltMuralSetCurrentInfo(m_pBlitter, &WinInfo);
    25952596    CrBltCheckUpdateViewport(m_pBlitter);
     
    26122613    if ([m_DockTileView thumbBitmap] != nil)
    26132614    {
    2614         /* 
     2615        /*
    26152616         * Only update after at least 200 ms, cause glReadPixels is
    2616          * heavy performance wise. 
    2617          */ 
     2617         * heavy performance wise.
     2618         */
    26182619        uint64_t                                msTS = RTTimeSystemMilliTS();
    26192620        VBOXVR_SCR_COMPOSITOR_CONST_ITERATOR    CIter;
    26202621        const VBOXVR_SCR_COMPOSITOR_ENTRY      *pEntry;
    2621        
     2622
    26222623        if (msTS - m_msDockUpdateTS > 200)
    26232624        {
    26242625            m_msDockUpdateTS = msTS;
    26252626# if 0
    2626             /* todo: check this for optimization */
     2627            /** @todo check this for optimization */
    26272628            glBindTexture(GL_TEXTURE_RECTANGLE_ARB, myTextureName);
    26282629            glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_STORAGE_HINT_APPLE,
     
    26462647
    26472648            rr = [m_DockTileView frame];
    2648            
     2649
    26492650            CrVrScrCompositorGetStretching(pCompositor, &xStretch, &yStretch);
    2650            
     2651
    26512652            CrVrScrCompositorConstIterInit(pCompositor, &CIter);
    26522653            while ((pEntry = CrVrScrCompositorConstIterNext(&CIter)) != NULL)
     
    26612662                    rc = CrBltEnter(m_pBlitter);
    26622663                    if (RT_SUCCESS(rc))
    2663                     {                   
     2664                    {
    26642665                        uint32_t i;
    26652666                        for (i = 0; i < cRegions; ++i)
     
    26702671                            RTRECT   DstRect, RestrictDstRect;
    26712672                            RTRECT   SrcRect, RestrictSrcRect;
    2672                    
     2673
    26732674                            vboxNSRectToRect(&m_RootRect, &RestrictDstRect);
    26742675                            VBoxRectIntersected(&RestrictDstRect, pDstRect, &DstRect);
    2675                            
     2676
    26762677                            VBoxRectTranslate(&DstRect, -RestrictDstRect.xLeft, -RestrictDstRect.yTop);
    2677                            
     2678
    26782679                            VBoxRectScale(&DstRect, m_FBOThumbScaleX, m_FBOThumbScaleY);
    2679                    
     2680
    26802681                            if (VBoxRectIsZero(&DstRect))
    26812682                                continue;
    2682                        
     2683
    26832684                            vboxNSRectToRectUnstretched(&m_RootRect, &RestrictSrcRect, xStretch, yStretch);
    2684                             VBoxRectTranslate(&RestrictSrcRect, 
    2685                                               -CrVrScrCompositorEntryRectGet(pEntry)->xLeft, 
     2685                            VBoxRectTranslate(&RestrictSrcRect,
     2686                                              -CrVrScrCompositorEntryRectGet(pEntry)->xLeft,
    26862687                                              -CrVrScrCompositorEntryRectGet(pEntry)->yTop);
    26872688                            VBoxRectIntersected(&RestrictSrcRect, pSrcRect, &SrcRect);
    2688                    
     2689
    26892690                            if (VBoxRectIsZero(&SrcRect))
    26902691                                continue;
     
    26922693                            pSrcRect = &SrcRect;
    26932694                            pDstRect = &DstRect;
    2694                            
     2695
    26952696                            pTexData = CrVrScrCompositorEntryTexGet(pEntry);
    2696                            
     2697
    26972698                            CrBltBlitTexMural(m_pBlitter, true, CrTdTexGet(pTexData), pSrcRect, pDstRect, 1, fFlags);
    26982699                        }
     
    27132714                }
    27142715            }
    2715            
     2716
    27162717            glFinish();
    27172718
     
    27282729                         [[m_DockTileView thumbBitmap] bitmapData]);
    27292730            [m_DockTileView unlock];
    2730            
     2731
    27312732# ifdef VBOX_WITH_CRDUMPER_THUMBNAIL
    27322733            ++g_cVBoxTgaCtr;
    2733             crDumpNamedTGAF((GLint)rr.size.width, (GLint)rr.size.height, 
     2734            crDumpNamedTGAF((GLint)rr.size.width, (GLint)rr.size.height,
    27342735                [[m_DockTileView thumbBitmap] bitmapData], "/Users/leo/vboxdumps/dump%d.tga", g_cVBoxTgaCtr);
    2735 # endif               
     2736# endif
    27362737
    27372738            pDT = [[NSApplication sharedApplication] dockTile];
    27382739
    27392740            /* Send a display message to the dock tile in the main thread */
    2740             [[[NSApplication sharedApplication] dockTile] performSelectorOnMainThread:@selector(display) withObject:nil 
     2741            [[[NSApplication sharedApplication] dockTile] performSelectorOnMainThread:@selector(display) withObject:nil
    27412742                                                                        waitUntilDone:NO];
    27422743        }
     
    27622763        return GL_TRUE;
    27632764    }
    2764    
     2765
    27652766    return GL_FALSE;
    27662767}
     
    27842785        m_cClipRects  = cRects;
    27852786    }
    2786    
     2787
    27872788    COCOA_LOG_FLOW(("%s: returns\n", __PRETTY_FUNCTION__));
    27882789}
     
    27962797    NSView *pScreenContent = nil;
    27972798
    2798     /* 
     2799    /*
    27992800     * First try the new variant which checks if this window is within the
    2800      * screen which is previewed in the dock. 
    2801      */ 
     2801     * screen which is previewed in the dock.
     2802     */
    28022803    if ([pContentView respondsToSelector:@selector(screenContentWithParentView:)])
    28032804        pScreenContent = [pContentView performSelector:@selector(screenContentWithParentView:) withObject:(id)m_pParentView];
    2804     /* 
     2805    /*
    28052806     * If it fails, fall back to the old variant (VBox...).
    28062807     */
    28072808    else if ([pContentView respondsToSelector:@selector(screenContent)])
    28082809        pScreenContent = [pContentView performSelector:@selector(screenContent)];
    2809    
     2810
    28102811    COCOA_LOG_FLOW(("%s: returns %p (pContentView=%p)\n", __PRETTY_FUNCTION__, (void *)pScreenContent, (void *)pContentView));
    28112812    return pScreenContent;
     
    28262827        m_FBOThumbScaleX = (float)dockFrame.size.width / parentFrame.size.width;
    28272828        m_FBOThumbScaleY = (float)dockFrame.size.height / parentFrame.size.height;
    2828         newFrame = NSMakeRect((int)(m_Pos.x * m_FBOThumbScaleX), 
    2829                               (int)(dockFrame.size.height - (m_Pos.y + m_Size.height - m_yInvRootOffset) * m_FBOThumbScaleY), 
    2830                               (int)(m_Size.width * m_FBOThumbScaleX), 
     2829        newFrame = NSMakeRect((int)(m_Pos.x * m_FBOThumbScaleX),
     2830                              (int)(dockFrame.size.height - (m_Pos.y + m_Size.height - m_yInvRootOffset) * m_FBOThumbScaleY),
     2831                              (int)(m_Size.width * m_FBOThumbScaleX),
    28312832                              (int)(m_Size.height * m_FBOThumbScaleY));
    28322833        /*
     
    28372838        [m_DockTileView setFrame: newFrame];
    28382839    }
    2839     COCOA_LOG_FLOW(("%s: returns - newFrame={%d,%d %d,%d} pView=%d\n", __PRETTY_FUNCTION__,  (int)newFrame.origin.x, 
     2840    COCOA_LOG_FLOW(("%s: returns - newFrame={%d,%d %d,%d} pView=%d\n", __PRETTY_FUNCTION__,  (int)newFrame.origin.x,
    28402841                    (int)newFrame.origin.y, (int)newFrame.size.width, (int)newFrame.size.height, (void *)pView));
    28412842}
     
    29022903
    29032904    /* Create our worker view. */
    2904     OverlayView *pView = [[OverlayView alloc] initWithFrame:NSZeroRect 
    2905                                                      thread:RTThreadSelf() 
    2906                                                  parentView:pParentView 
     2905    OverlayView *pView = [[OverlayView alloc] initWithFrame:NSZeroRect
     2906                                                     thread:RTThreadSelf()
     2907                                                 parentView:pParentView
    29072908                                                    winInfo:pWinInfo
    29082909                                                 fVisParams:fVisParams];
     
    29162917        return pView;
    29172918    }
    2918    
     2919
    29192920    COCOA_LOG_FLOW(("vboxViewCreate: returns NULL\n"));
    29202921    return NULL;
     
    29432944void cocoaViewCreate(NativeNSViewRef *ppView, WindowInfo *pWinInfo, NativeNSViewRef pParentView, GLbitfield fVisParams)
    29442945{
    2945     COCOA_LOG_FLOW(("cocoaViewCreate: ppView=%p pWinInfo=%p pParentView=%p fVisParams=%#x\n", 
     2946    COCOA_LOG_FLOW(("cocoaViewCreate: ppView=%p pWinInfo=%p pParentView=%p fVisParams=%#x\n",
    29462947                    (void *)ppView, (void *)pWinInfo, (void *)pParentView, fVisParams));
    29472948    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
     
    29502951    VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
    29512952    [pRunner runTasksSyncIfPossible];
    2952    
     2953
    29532954#ifndef IN_VMSVGA3D
    29542955    renderspuWinRetain(pWinInfo);
     
    29762977#endif
    29772978    }
    2978    
     2979
    29792980#ifndef IN_VMSVGA3D
    29802981    if (!*ppView)
    29812982        renderspuWinRelease(pWinInfo);
    29822983#endif
    2983    
     2984
    29842985    [pPool release];
    29852986    COCOA_LOG_FLOW(("cocoaViewCreate: returns *ppView=%p\n", (void *)*ppView));
     
    30763077    CR_RCD_GETGEOMETRY *pGetGeometry = (CR_RCD_GETGEOMETRY *)pvUser;
    30773078    pGetGeometry->rect = [[pGetGeometry->pView window] frame];
    3078     COCOA_LOG_FLOW(("vboxRcdGetGeomerty: (x,y)=(%d,%d) (cx,cy)=(%d,%d)\n", pGetGeometry->rect.origin.x, pGetGeometry->rect.origin.y, 
     3079    COCOA_LOG_FLOW(("vboxRcdGetGeomerty: (x,y)=(%d,%d) (cx,cy)=(%d,%d)\n", pGetGeometry->rect.origin.x, pGetGeometry->rect.origin.y,
    30793080                    pGetGeometry->rect.size.width, pGetGeometry->rect.size.height));
    30803081}
     
    30823083void cocoaViewGetGeometry(NativeNSViewRef pView, int *px, int *py, int *pcx, int *pcy)
    30833084{
    3084     COCOA_LOG_FLOW(("cocoaViewGetGeometry: pView=%p px=%p py=%p pcx=%p pcy=%p\n", 
     3085    COCOA_LOG_FLOW(("cocoaViewGetGeometry: pView=%p px=%p py=%p pcx=%p pcy=%p\n",
    30853086                    (void *)pView, (void *)px, (void *)py, (void *)pcx, (void *)pcy));
    30863087    NSAutoreleasePool *pPool;
     
    30903091    VBoxMainThreadTaskRunner *pRunner = [VBoxMainThreadTaskRunner globalInstance];
    30913092    [pRunner runTasksSyncIfPossible];
    3092    
     3093
    30933094    NSRect frame;
    30943095#ifndef IN_VMSVGA3D
     
    31063107        frame = [[pView window] frame];
    31073108    }
    3108    
     3109
    31093110    *px  = frame.origin.x;
    31103111    *py  = frame.origin.y;
     
    31343135        {
    31353136            DEBUG_WARN(("renderspuDefaultSharedContextAcquire returned NULL"));
    3136            
     3137
    31373138            [pPool release];
    31383139            DEBUG_FUNC_LEAVE();
    31393140            return;
    31403141        }
    3141        
     3142
    31423143        pCtx = pCtxInfo->context;
    3143        
     3144
    31443145        [(OverlayView *)pView setGLCtx:pCtx];
    31453146    }
    31463147# endif
    3147    
     3148
    31483149    [(OverlayView *)pView presentComposition:pChangedEntry];
    31493150
     
    31763177        }
    31773178#endif
    3178         [NSOpenGLContext clearCurrentContext];
     3179        [NSOpenGLContext clearCurrentContext];
    31793180    }
    31803181
     
    32723273    DEBUG_FUNC_ENTER();
    32733274    NSAutoreleasePool *pPool = [[NSAutoreleasePool alloc] init];
    3274    
     3275
    32753276    Assert([(OverlayView *)pView glCtx] == pCtx);
    32763277    Assert([pCtx view] == pView);
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_config.c

    • Property svn:keywords changed from Id to Id Revision
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_glx.c

    • Property svn:keywords changed from Id to Id Revision
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_init.c

    • Property svn:keywords changed from Id to Id Revision
    r62088 r69390  
    243243    if (pcpwSetting)
    244244    {
    245         /* TODO: need proper blitter synchronization, do not use so far!
     245        /** @todo need proper blitter synchronization, do not use so far!
    246246         * the problem is that rendering can be done in multiple thread: the main command (hgcm) thread and the redraw thread
    247247         * we currently use per-window synchronization, while we'll need a per-blitter synchronization if one blitter is used for multiple windows
  • trunk/src/VBox/HostServices/SharedOpenGL/render/renderspu_wgl.c

    • Property svn:keywords changed from Id to Id Revision
    r62679 r69390  
    13911391             */
    13921392
    1393             /*@todo Chromium has no correct code to remove window ids and associated info from
     1393            /** @todo Chromium has no correct code to remove window ids and associated info from
    13941394             * various tables. This is hack which just hides the root case.
    13951395             */
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette