VirtualBox

Ignore:
Timestamp:
Mar 31, 2010 12:57:09 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
59577
Message:

crOpenGL: more code for multiscreen support

Location:
trunk/src/VBox/HostServices/SharedOpenGL/crserverlib
Files:
15 edited

Legend:

Unmodified
Added
Removed

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

    r17964 r27889  
    5555void crServerSetVBoxConfiguration();
    5656void crServerSetVBoxConfigurationHGCM();
    57 void crServerInitializeTiling(CRMuralInfo *mural);
    5857void crServerInitDispatch(void);
    5958void crServerReturnValue( const void *payload, unsigned int payload_len );
    … …  
    7170
    7271GLboolean crServerInitializeBucketing(CRMuralInfo *mural);
    73 
    74 void crServerNewMuralTiling(CRMuralInfo *mural, GLint muralWidth, GLint muralHeight, GLint numTiles, const GLint *tileBounds);
    7572
    7673void crComputeOverlapGeom(double *quads, int nquad, CRPoly ***res);
    … …  
    9390GLuint crServerTranslateProgramID(GLuint id);
    9491
     92void crServerCheckMuralGeometry(CRMuralInfo *mural);
     93GLboolean crServerSupportRedirMuralFBO(void);
     94void crServerRedirMuralFBO(CRMuralInfo *mural, GLboolean redir);
     95void crServerCreateMuralFBO(CRMuralInfo *mural);
     96void crServerDeleteMuralFBO(CRMuralInfo *mural);
     97void crServerPresentFBO(CRMuralInfo *mural);
     98GLboolean crServerIsRedirectedToFBO();
     99
    95100#endif /* CR_SERVER_H */

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_boundsinfo.c

    r15532 r27889  
    4040fillBucketingHash(CRMuralInfo *mural)
    4141{
     42#if 0
    4243        int i, j, k, m;
    4344        int r_len = 0;
    … …  
    164165
    165166        mural->bucketInfo = bucketInfo;
     167#endif
    166168        return GL_TRUE;
    167169}
    … …  
    175177crServerInitializeBucketing(CRMuralInfo *mural)
    176178{
     179#if 0
    177180        int optTileWidth = 0, optTileHeight = 0;
    178181        int i;
    … …  
    217220                }
    218221        }
    219 
     222#endif
    220223        return fillBucketingHash(mural);
    221224}
    … …  
    238241        /* Save current unpacker state */
    239242        crUnpackPush();
    240 
     243#if 0
    241244        /* pass bounds info to first SPU */
    242245        {
    … …  
    319322                }
    320323        }
    321 
     324#endif
    322325        /* Restore previous unpacker state */
    323326        crUnpackPop();

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_clear.c

    r15532 r27889  
    3030        }
    3131
    32         if (mural->numExtents == 0)
    33         {
    34                 cr_server.head_spu->dispatch_table.Clear( mask );
    35         }
    36         else
    37         {
    38                 int scissor_on, i;
    39 
    40                 if (!mural->viewportValidated) {
    41                         crServerComputeViewportBounds(&(cr_server.curClient->currentCtx->viewport), mural);
    42                 }
    43 
    44 
    45                 scissor_on = q->client->currentCtx->viewport.scissorTest;
    46 
    47                 if (!scissor_on)
    48                 {
    49                         cr_server.head_spu->dispatch_table.Enable( GL_SCISSOR_TEST );
    50                 }
    51 
    52                 for ( i = 0; i < mural->numExtents; i++ )
    53                 {
    54                         crServerSetOutputBounds( mural, i );
    55                         cr_server.head_spu->dispatch_table.Clear( mask );
    56                 }
    57                 if (!scissor_on)
    58                 {
    59                         cr_server.head_spu->dispatch_table.Disable( GL_SCISSOR_TEST );
    60                 }
    61         }
     32        cr_server.head_spu->dispatch_table.Clear( mask );
    6233}
    6334
    … …  
    9768        }
    9869
     70#if 0
    9971        if (cr_server.overlapBlending)
    10072        {
    … …  
    278250                cr_server.head_spu->dispatch_table.Color4f(col.r, col.g, col.b, col.a);
    279251        }
     252#endif
    280253
    281254        /* Check if using a file network */
    … …  
    283256                window = 0;
    284257
    285         cr_server.head_spu->dispatch_table.SwapBuffers( mural->spuWindow, flags );
    286 }
     258    if (crServerIsRedirectedToFBO())
     259    {
     260        crServerPresentFBO(mural);
     261    }
     262    else
     263    {
     264        cr_server.head_spu->dispatch_table.SwapBuffers( mural->spuWindow, flags );
     265    }
     266}
     267
     268void SERVER_DISPATCH_APIENTRY
     269crServerDispatchFlush(void)
     270{
     271    cr_server.head_spu->dispatch_table.Flush();
     272
     273    if (crServerIsRedirectedToFBO())
     274    {
     275        crServerPresentFBO(cr_server.curClient->currentMural);
     276    }
     277}
     278
     279void SERVER_DISPATCH_APIENTRY
     280crServerDispatchFinish(void)
     281{
     282    cr_server.head_spu->dispatch_table.Finish();
     283
     284    if (crServerIsRedirectedToFBO())
     285    {
     286        crServerPresentFBO(cr_server.curClient->currentMural);
     287    }
     288}

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_config.c

    r27708 r27889  
    7676    char hostname[1024];
    7777    char **clientchain, **clientlist;
     78    GLint dims[4];
    7879
    7980    defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
    … …  
    154155    /* Need to do this as early as possible */
    155156
    156     /* XXX DMX get window size instead? */
    157     cr_server.head_spu->dispatch_table.GetIntegerv(GL_VIEWPORT,
    158                                                    (GLint *) defaultMural->underlyingDisplay);
     157    cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_POSITION_CR, 0, GL_INT, 2, &dims[0]);
     158    cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_SIZE_CR, 0, GL_INT, 2, &dims[2]);
     159   
     160    defaultMural->gX = dims[0];
     161    defaultMural->gY = dims[1];
     162    defaultMural->width = dims[2];
     163    defaultMural->height = dims[3];
    159164
    160165    crFree(spu_ids);
    … …  
    246251    char *spu_dir = NULL;
    247252    int i;
     253    GLint dims[4];
    248254
    249255    defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
    … …  
    260266        return;
    261267
    262     /* XXX DMX get window size instead? */
    263     cr_server.head_spu->dispatch_table.GetIntegerv(GL_VIEWPORT,
    264                                                    (GLint *) defaultMural->underlyingDisplay);
     268    cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_POSITION_CR, 0, GL_INT, 2, &dims[0]);
     269    cr_server.head_spu->dispatch_table.GetChromiumParametervCR(GL_WINDOW_SIZE_CR, 0, GL_INT, 2, &dims[2]);
     270   
     271    defaultMural->gX = dims[0];
     272    defaultMural->gY = dims[1];
     273    defaultMural->width = dims[2];
     274    defaultMural->height = dims[3];
     275
    265276    cr_server.mtu = 1024 * 250;
    266277

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_context.c

    r21576 r27889  
    229229
    230230    /* check if being made current for first time, update viewport */
     231#if 0
    231232    if (ctx) {
    232233        /* initialize the viewport */
    … …  
    238239        }
    239240    }
     241#endif
    240242
    241243    /*
    … …  
    260262        cr_server.currentWindow = window;
    261263        cr_server.currentNativeWindow = nativeWindow;
    262 
    263         /* Set initial raster/window position for this context.
    264          * The position has to be translated according to the tile origin.
    265          */
    266         if (mural->numExtents > 0)
    267         {
    268             GLint x = -mural->extents[0].imagewindow.x1;
    269             GLint y = -mural->extents[0].imagewindow.y1;
    270             cr_server.head_spu->dispatch_table.WindowPos2iARB(x, y);
    271             /* This MakeCurrent is a bit redundant (we do it again below)
    272              * but it's only done the first time we activate a context.
    273              */
    274             crStateMakeCurrent(ctx);
    275             crStateWindowPos2iARB(x, y);
    276         }
    277264    }
    278265
    279266    /* This used to be earlier, after crStateUpdateColorBits() call */
    280267    crStateMakeCurrent( ctx );
    281 
    282     /* This is pessimistic - we really don't have to invalidate the viewport
    283      * info every time we MakeCurrent, but play it safe for now.
    284      */
    285     mural->viewportValidated = GL_FALSE;
    286 }
    287 
     268}
     269

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_framebuffer.c

    r23094 r27889  
    8484{
    8585        crStateBindFramebufferEXT(target, framebuffer);
    86         cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, crStateGetFramebufferHWID(framebuffer));
     86
     87    if (0==framebuffer && crServerIsRedirectedToFBO())
     88    {
     89        cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, cr_server.curClient->currentMural->idFBO);
     90    }
     91    else
     92    {
     93        cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, crStateGetFramebufferHWID(framebuffer));
     94    }
    8795}
    8896

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_lists.c

    r21033 r27889  
    8787    if (cr_server.curClient->currentCtx->lists.mode == 0) {
    8888        /* we're not compiling, so execute the list now */
    89         CRMuralInfo *mural = cr_server.curClient->currentMural;
    90         int i;
    91 
    92         if (!mural->viewportValidated) {
    93             crServerComputeViewportBounds(&(cr_server.curClient->currentCtx->viewport), mural);
    94         }
    95 
    96         if (mural->numExtents == 0) {
    97             /* Issue the list as-is */
    98             cr_server.head_spu->dispatch_table.CallList( list );
    99         }
    100         else {
    101             /* Loop over the extents (tiles) calling glCallList() */
    102             for ( i = 0; i < mural->numExtents; i++ )   {
    103                 if (cr_server.run_queue->client->currentCtx)
    104                     crServerSetOutputBounds( mural, i );
    105                 cr_server.head_spu->dispatch_table.CallList( list );
    106             }
    107         }
     89        /* Issue the list as-is */
     90        cr_server.head_spu->dispatch_table.CallList( list );
    10891    }
    10992    else {
    … …  
    231214    if (cr_server.curClient->currentCtx->lists.mode == 0) {
    232215        /* we're not compiling, so execute the list now */
    233         CRMuralInfo *mural = cr_server.curClient->currentMural;
    234         int i;
    235 
    236         if (!mural->viewportValidated) {
    237             crServerComputeViewportBounds(&(cr_server.curClient->currentCtx->viewport), mural);
    238         }
    239 
    240         if (mural->numExtents == 0) {
    241             /* Issue the list as-is */
    242             cr_server.head_spu->dispatch_table.CallLists( n, type, lists );
    243         }
    244         else {
    245             /* Loop over the extents (tiles) calling glCallList() */
    246             for ( i = 0; i < mural->numExtents; i++ ) {
    247                 if (cr_server.run_queue->client->currentCtx)
    248                     crServerSetOutputBounds( mural, i );
    249                 cr_server.head_spu->dispatch_table.CallLists( n, type, lists );
    250             }
    251         }
     216        /* Issue the list as-is */
     217        cr_server.head_spu->dispatch_table.CallLists( n, type, lists );
    252218    }
    253219    else {

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

    r27708 r27889  
    853853
    854854        /* Restore windows geometry info */
    855         crServerDispatchWindowSize(key, muralInfo.underlyingDisplay[2], muralInfo.underlyingDisplay[3]);
    856         crServerDispatchWindowPosition(key, muralInfo.underlyingDisplay[0], muralInfo.underlyingDisplay[1]);
     855        crServerDispatchWindowSize(key, muralInfo.width, muralInfo.height);
     856        crServerDispatchWindowPosition(key, muralInfo.gX, muralInfo.gY);
    857857    }
    858858
    … …  
    10181018}
    10191019
     1020static void crVBoxServerCheckMuralCB(unsigned long key, void *data1, void *data2)
     1021{
     1022    CRMuralInfo *pMI = (CRMuralInfo*) data1;
     1023    (void) data2;
     1024
     1025    crServerCheckMuralGeometry(pMI);
     1026}
     1027
    10201028DECLEXPORT(int32_t) crVBoxServerSetScreenCount(int sCount)
    10211029{
    … …  
    10681076        return VERR_INVALID_PARAMETER;
    10691077
    1070     if (MAPPED(SCREEN(sIndex)))
     1078    if (MAPPED(SCREEN(sIndex)) && SCREEN(sIndex).winID!=winID)
    10711079    {
    10721080        crWarning("Mapped screen[%i] is being remapped.", sIndex);
     1081        crVBoxServerUnmapScreen(sIndex);
    10731082    }
    10741083
    … …  
    10801089
    10811090    renderspuSetWindowId(SCREEN(sIndex).winID);
    1082 
    10831091    crHashtableWalk(cr_server.muralTable, crVBoxServerReparentMuralCB, &sIndex);
    1084 
    10851092    renderspuSetWindowId(SCREEN(0).winID);
     1093
     1094    crHashtableWalk(cr_server.muralTable, crVBoxServerCheckMuralCB, NULL);
     1095   
    10861096    return VINF_SUCCESS;
    10871097}
    … …  
    10931103    return VINF_SUCCESS;
    10941104}
     1105
     1106DECLEXPORT(void) crVBoxServerSetPresentFBOCB(PFNCRSERVERPRESENTFBO pfnPresentFBO)
     1107{
     1108    cr_server.pfnPresentFBO = pfnPresentFBO;
     1109}

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_misc.c

    r15532 r27889  
    8383            CRASSERT(tiles == numTiles);
    8484            tileBounds += 4; /* skip over header values */
    85             crServerNewMuralTiling(mural, muralWidth, muralHeight, numTiles, tileBounds);
    86             mural->viewportValidated = GL_FALSE;
     85            /*crServerNewMuralTiling(mural, muralWidth, muralHeight, numTiles, tileBounds);
     86            mural->viewportValidated = GL_FALSE;*/
    8787        }
    8888        break;

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_projmatrix.c

    r15532 r27889  
    4747    crStateLoadMatrixf( m );
    4848
    49     if (matMode == GL_PROJECTION && mural->numExtents > 0) {
    50         /* we're loading a matrix onto the projection stack -- better put the base
    51          * projection there first! */
    52         crServerApplyBaseProjection(&(mural->extents[mural->curExtent].
    53                                                                     baseProjection));
    54     }
    55     else if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
     49    if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
    5650        int eye = crServerGetCurrentEye();
    5751        crServerApplyViewMatrix(&cr_server.viewMatrix[eye]);
    … …  
    7064    crStateLoadMatrixd( m );
    7165
    72     if (matMode == GL_PROJECTION && mural->numExtents > 0) {
    73         /* we're loading a matrix onto the projection stack -- better put the base
    74          * projection there first! */
    75         crServerApplyBaseProjection(&(mural->extents[mural->curExtent].
    76                                                                     baseProjection));
    77     }
    78     else if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
     66    if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
    7967        int eye = crServerGetCurrentEye();
    8068        crServerApplyViewMatrix(&cr_server.viewMatrix[eye]);
    … …  
    128116    crStateLoadIdentity();
    129117
    130     if (matMode == GL_PROJECTION && mural->numExtents > 0) {
    131         /* we're loading a matrix onto the projection stack -- better put the base
    132          * projection there first! */
    133         crServerApplyBaseProjection(&(mural->extents[mural->curExtent].
    134                                                                     baseProjection));
    135     }
    136     else if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
     118    if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
    137119        int eye = crServerGetCurrentEye();
    138120        crServerApplyViewMatrix(&cr_server.viewMatrix[eye]);
    … …  
    207189crServerDispatchProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
    208190{
     191#if 0
    209192    if (target == GL_VERTEX_PROGRAM_ARB) {
    210193        CRServerProgram *prog = LookupProgram(cr_server.currentProgram);
    … …  
    240223        }
    241224    }
     225#endif
    242226
    243227    /* if we get here, pass the call through unchanged */
    … …  
    256240crServerDispatchProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
    257241{
     242#if 0
    258243    if (target == GL_VERTEX_PROGRAM_NV) {
    259244        CRServerProgram *prog = LookupProgram(cr_server.currentProgram);
    … …  
    289274        }
    290275    }
     276#endif
    291277
    292278    /* if we get here, pass the call through unchanged */

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_simpleget.py

    r26407 r27889  
    7373        *get_values = (%s) crStateGLSLProgramHWIDtoID(programid);
    7474    }
    75     """ % (types[index], types[index], types[index], types[index])
     75    else if (GL_FRAMEBUFFER_BINDING_EXT==pname
     76             ||GL_READ_FRAMEBUFFER_BINDING==pname)
     77    {
     78        GLuint fboid;
     79        CRASSERT(tablesize/sizeof(%s)==1);
     80        fboid = crStateFBOHWIDtoID((GLuint) *get_values);
     81        if (crServerIsRedirectedToFBO()
     82            && fboid==cr_server.curClient->currentMural->idFBO)
     83        {
     84            fboid = 0;
     85        }
     86        *get_values = (%s) fboid;
     87    }
     88    else if (GL_RENDERBUFFER_BINDING_EXT==pname)
     89    {
     90        GLuint rbid;
     91        CRASSERT(tablesize/sizeof(%s)==1);
     92        rbid = (GLuint) *get_values;
     93        *get_values = (%s) crStateRBOHWIDtoID(rbid);
     94    }
     95    """ % (types[index], types[index], types[index], types[index], types[index], types[index], types[index], types[index])
    7696    print '\tcrServerReturnValue( get_values, tablesize );'
    7797    print '\tcrFree(get_values);'

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_special

    r27091 r27889  
    221221GetUniformsLocations
    222222GetPolygonStipple
     223Flush
     224Finish

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_viewport.c

    r20028 r27889  
    6363crServerComputeViewportBounds(const CRViewportState *v, CRMuralInfo *mural)
    6464{
     65#if 0
    6566        static GLuint serialNo = 1;
    6667        int i;
    … …  
    182183        }
    183184        mural->viewportValidated = GL_TRUE;
     185#endif
    184186}
    185187
    … …  
    193195crServerSetOutputBounds( const CRMuralInfo *mural, int extNum )
    194196{
     197#if 0
    195198        const CRExtent *extent = mural->extents + extNum;
    196199        CRASSERT(mural->viewportValidated);
    … …  
    219222                cr_server.currentSerialNo = extent->serialNo;
    220223        }               
     224#endif
    221225}
    222226
    … …  
    278282                        * process of decoding the BoundsInfo packet, so no worries. */
    279283                 crStateViewport( x, y, width, height );
    280 
    281                  if (mural) mural->viewportValidated = GL_FALSE;
    282284        }
    283285

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

    r23840 r27889  
    7474        CRMuralInfo *defaultMural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, 0);
    7575        CRASSERT(defaultMural);
    76         mural->width = defaultMural->width;
    77         mural->height = defaultMural->height;
    78         mural->optimizeBucket = 0; /* might get enabled later */
    79         mural->numExtents = defaultMural->numExtents;
    80         mural->curExtent = 0;
    81         crMemcpy(mural->extents, defaultMural->extents,
    82                  defaultMural->numExtents * sizeof(CRExtent));
    83         mural->underlyingDisplay[0] = 0;
    84         mural->underlyingDisplay[1] = 0;
    85         mural->underlyingDisplay[2] = dims[0];
    86         mural->underlyingDisplay[3] = dims[1];
     76        mural->gX = 0;
     77        mural->gY = 0;
     78        mural->width = dims[0];
     79        mural->height = dims[1];
    8780
    8881        mural->spuWindow = spuWindow;
    89         crServerInitializeTiling(mural);
     82        mural->screenId = 0;
     83        mural->bVisible = GL_FALSE;
     84        mural->bUseFBO = GL_FALSE;
    9085
    9186        /* generate ID for this new window/mural (special-case for file conns) */
    … …  
    193188crServerDispatchWindowSize( GLint window, GLint width, GLint height )
    194189{
    195   CRMuralInfo *mural;
     190    CRMuralInfo *mural;
    196191
    197192    /*  crDebug("CRServer: Window %d size %d x %d", window, width, height);*/
    … …  
    203198         return;
    204199    }
    205     mural->underlyingDisplay[2] = width;
    206     mural->underlyingDisplay[3] = height;
    207     crServerInitializeTiling(mural);
    208 
    209     cr_server.head_spu->dispatch_table.WindowSize(mural->spuWindow, width, height);
     200    mural->width = width;
     201    mural->height = height;
     202
     203    crServerCheckMuralGeometry(mural);
     204
     205    if (!mural->bUseFBO)
     206    {
     207        cr_server.head_spu->dispatch_table.WindowSize(mural->spuWindow, width, height);
     208    }
    210209}
    211210
    … …  
    214213crServerDispatchWindowPosition( GLint window, GLint x, GLint y )
    215214{
    216   CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
     215    CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
    217216    /*  crDebug("CRServer: Window %d pos %d, %d", window, x, y);*/
    218217    if (!mural) {
    … …  
    222221         return;
    223222    }
    224     mural->underlyingDisplay[0] = x;
    225     mural->underlyingDisplay[1] = y;
    226 
    227 #if EXTRA_WARN /* don't believe this is needed */
    228     crServerInitializeTiling(mural);
    229 #endif
    230     cr_server.head_spu->dispatch_table.WindowPosition(mural->spuWindow, x, y);
     223    mural->gX = x;
     224    mural->gY = y;
     225
     226    crServerCheckMuralGeometry(mural);
    231227}
    232228
    … …  
    234230crServerDispatchWindowVisibleRegion( GLint window, GLint cRects, GLint *pRects )
    235231{
    236   CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
     232    CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
    237233    if (!mural) {
    238234#if EXTRA_WARN
    … …  
    241237         return;
    242238    }
    243 #if EXTRA_WARN /* don't believe this is needed */
    244     crServerInitializeTiling(mural);
    245 #endif
    246239    cr_server.head_spu->dispatch_table.WindowVisibleRegion(mural->spuWindow, cRects, pRects);
    247240}
    … …  
    252245crServerDispatchWindowShow( GLint window, GLint state )
    253246{
    254   CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
     247    CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, window);
    255248    if (!mural) {
    256249#if EXTRA_WARN
    … …  
    259252         return;
    260253    }
    261     cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, state);
     254
     255    if (!mural->bUseFBO)
     256    {
     257        cr_server.head_spu->dispatch_table.WindowShow(mural->spuWindow, state);
     258    }
     259
     260    mural->bVisible = state;
    262261}
    263262
    … …  
    266265crServerSPUWindowID(GLint serverWindow)
    267266{
    268   CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, serverWindow);
     267    CRMuralInfo *mural = (CRMuralInfo *) crHashtableSearch(cr_server.muralTable, serverWindow);
    269268    if (!mural) {
    270269#if EXTRA_WARN

  • trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_winpos.c

    r15532 r27889  
    66/**
    77 * All glWindowPos commands go through here.
    8  * The (x,y,z) coordinate is in mural-space window coords.
    9  * We need to bias by the current tile's position.
    10  * Remember that the state differencer (used in the tilesort SPU) uses
    11  * glWindowPos to update the raster position on the servers, so that takes
    12  * care of proper position for tilesorting.
    13  * Also, this helps with sort-last rendering: if images are being sent to a
    14  * server that has tiles, the images will be correctly positioned too.
    15  * This also solves Eric Mueller's "tilesort-->readback trouble" issue.
    16  *
    17  * glRasterPos commands will go through unmodified; they're transformed
    18  * by the modelview/projection matrix which is already modified per-tile.
    198 */
    209static void crServerWindowPos( GLfloat x, GLfloat y, GLfloat z )
    2110{
    22         CRMuralInfo *mural = cr_server.curClient->currentMural;
    23         x -= (float) mural->extents[mural->curExtent].imagewindow.x1;
    24         y -= (float) mural->extents[mural->curExtent].imagewindow.y1;
    2511        crStateWindowPos3fARB(x, y, z);
    2612        cr_server.head_spu->dispatch_table.WindowPos3fARB(x, y, z);
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