VirtualBox

Changeset 27889 in vbox


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
Files:
29 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_get.py

    r26048 r27889  
    122122                {
    123123                    crWarning("Incorrect local state in %s for %%x param %%i", pname, i);
     124                    crWarning("Expected %%i but got %%i", (int)localparams[i], (int)params[i]);
    124125                }
    125126            }

  • trunk/src/VBox/Frontends/VirtualBox/src/settings/vm/VBoxVMSettingsDisplay.cpp

    r27413 r27889  
    304304        mCb2DVideo->setChecked(false);
    305305#endif /* VBOX_WITH_VIDEOHWACCEL */
     306#ifdef Q_WS_MAC
    306307        mCb3D->setChecked(false);
     308#endif
    307309    }
    308310#ifdef VBOX_WITH_VIDEOHWACCEL
    309311    mCb2DVideo->setEnabled(cVal == 1 && VBoxGlobal::isAcceleration2DVideoAvailable());
    310312#endif /* VBOX_WITH_VIDEOHWACCEL */
     313#ifdef Q_WS_MAC
    311314    mCb3D->setEnabled(cVal == 1 && vboxGlobal().virtualBox().GetHost().GetAcceleration3DAvailable());
     315#else
     316    mCb3D->setEnabled(vboxGlobal().virtualBox().GetHost().GetAcceleration3DAvailable());
     317#endif
    312318
    313319    /* The memory requirements have changed too. */

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

    r20635 r27889  
    680680#ifndef GL_CR_real_vendor_strings
    681681#define GL_CR_real_vendor_strings 1
    682 #define GL_REAL_VENDOR   0x8B23
    683 #define GL_REAL_VERSION  0x8B24
    684 #define GL_REAL_RENDERER 0x8B25
     682#define GL_REAL_VENDOR     0x8B23
     683#define GL_REAL_VERSION    0x8B24
     684#define GL_REAL_RENDERER   0x8B25
     685#define GL_REAL_EXTENSIONS 0x8B26
    685686#endif
    686687

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

    r27708 r27889  
    3131/*@todo must match MaxGuestMonitors from SchemaDefs.h*/
    3232#define CR_MAX_GUEST_MONITORS 8
     33
     34typedef DECLCALLBACKPTR(void, PFNCRSERVERPRESENTFBO) (void *data, int32_t screenId, int32_t x, int32_t y, uint32_t w, uint32_t h);
    3335
    3436typedef struct {
    … …  
    4951 */
    5052typedef struct {
    51     int width, height;
    52     CRrecti imagespace;                /**< the whole mural rectangle */
    53     int curExtent;
    54     int numExtents;                    /**< number of tiles */
    55     CRExtent extents[CR_MAX_EXTENTS];  /**< per-tile info */
    56     int maxTileHeight;                 /**< the tallest tile's height */
    57 
    58     /** optimized, hash-based tile bucketing */
    59     int optimizeBucket;
    60     struct BucketingInfo *bucketInfo;
    61 
    62     unsigned int underlyingDisplay[4]; /**< needed for laying out the extents */
    63 
    64     GLboolean viewportValidated;
    65 
    66     int spuWindow;                     /**< the SPU's corresponding window ID */
     53    GLuint width, height;
     54    GLint gX, gY;            /*guest coordinates*/
     55    GLint hX, hY;            /*host coordinates, screenID related*/
     56   
     57    int spuWindow;           /*the SPU's corresponding window ID */
    6758
    6859    int screenId;
     60
     61    GLboolean bVisible;      /*guest window is visible*/
     62    GLboolean bUseFBO;       /*redirect to FBO instead of real host window*/
     63
     64    GLuint idFBO, idColorTex, idDepthStencilRB;
     65    GLuint fboWidth, fboHeight;
    6966} CRMuralInfo;
    7067
    … …  
    8380    GLint contextList[CR_MAX_CONTEXTS];
    8481} CRClient;
    85 
    8682
    8783typedef struct CRPoly_t {
    … …  
    215211
    216212    GLuint currentSerialNo;
     213
     214    PFNCRSERVERPRESENTFBO pfnPresentFBO;
    217215} CRServer;
    218216
    … …  
    241239
    242240extern DECLEXPORT(int32_t) crVBoxServerSetRootVisibleRegion(GLint cRects, GLint *pRects);
     241
     242extern DECLEXPORT(void) crVBoxServerSetPresentFBOCB(PFNCRSERVERPRESENTFBO pfnPresentFBO);
     243
    243244#ifdef __cplusplus
    244245}

  • trunk/src/VBox/GuestHost/OpenGL/include/state/cr_framebuffer.h

    r23694 r27889  
    9292DECLEXPORT(void) STATE_APIENTRY crStateGenerateMipmapEXT(GLenum target);
    9393
     94DECLEXPORT(GLuint) STATE_APIENTRY crStateFBOHWIDtoID(GLuint hwid);
     95DECLEXPORT(GLuint) STATE_APIENTRY crStateRBOHWIDtoID(GLuint hwid);
     96
    9497#ifdef IN_GUEST
    9598DECLEXPORT(GLenum) STATE_APIENTRY crStateCheckFramebufferStatusEXT(GLenum target);

  • trunk/src/VBox/GuestHost/OpenGL/spu_loader/glloader.py

    r24229 r27889  
    6868#endif
    6969
    70 /*#define CR_NO_GL_SYSTEM_PATH 1*/
     70#define CR_NO_GL_SYSTEM_PATH 1
    7171
    7272/*

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state.h

    r15532 r27889  
    1212#include "cr_threads.h"
    1313#endif
     14
     15typedef struct _crCheckIDHWID {
     16    GLuint id, hwid;
     17} crCheckIDHWID_t;
    1418
    1519extern SPUDispatchTable diff_api;

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_framebuffer.c

    r24569 r27889  
    768768}
    769769
     770static void crStateCheckFBOHWIDCB(unsigned long key, void *data1, void *data2)
     771{
     772    CRFramebufferObject *pFBO = (CRFramebufferObject *) data1;
     773    crCheckIDHWID_t *pParms = (crCheckIDHWID_t*) data2;
     774    (void) key;
     775
     776    if (pFBO->hwid==pParms->hwid)
     777        pParms->id = pFBO->id;
     778}
     779
     780static void crStateCheckRBOHWIDCB(unsigned long key, void *data1, void *data2)
     781{
     782    CRRenderbufferObject *pRBO = (CRRenderbufferObject *) data1;
     783    crCheckIDHWID_t *pParms = (crCheckIDHWID_t*) data2;
     784    (void) key;
     785
     786    if (pRBO->hwid==pParms->hwid)
     787        pParms->id = pRBO->id;
     788}
     789
     790DECLEXPORT(GLuint) STATE_APIENTRY crStateFBOHWIDtoID(GLuint hwid)
     791{
     792    CRContext *g = GetCurrentContext();
     793    crCheckIDHWID_t parms;
     794
     795    parms.id = hwid;
     796    parms.hwid = hwid;
     797
     798    crHashtableWalk(g->framebufferobject.framebuffers, crStateCheckFBOHWIDCB, &parms);
     799    return parms.id;
     800}
     801
     802DECLEXPORT(GLuint) STATE_APIENTRY crStateRBOHWIDtoID(GLuint hwid)
     803{
     804    CRContext *g = GetCurrentContext();
     805    crCheckIDHWID_t parms;
     806
     807    parms.id = hwid;
     808    parms.hwid = hwid;
     809
     810    crHashtableWalk(g->framebufferobject.renderbuffers, crStateCheckRBOHWIDCB, &parms);
     811    return parms.id;
     812}
     813
    770814#ifdef IN_GUEST
    771815DECLEXPORT(GLenum) STATE_APIENTRY crStateCheckFramebufferStatusEXT(GLenum target)

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_glsl.c

    r26031 r27889  
    196196}
    197197
    198 typedef struct _crCheckIDHWID {
    199     GLuint id, hwid;
    200 } crCheckIDHWID_t;
    201 
    202198static void crStateCheckShaderHWIDCB(unsigned long key, void *data1, void *data2)
    203199{

  • trunk/src/VBox/HostServices/SharedOpenGL/Makefile.kmk

    r27710 r27889  
    129129        crserverlib/server_readpixels.c \
    130130        crserverlib/server_stream.c \
    131         crserverlib/server_tiles.c \
    132131        crserverlib/server_viewport.c \
    133132        crserverlib/server_window.c \
    … …  
    137136        crserverlib/server_framebuffer.c \
    138137        crserverlib/server_glsl.c \
     138        crserverlib/server_muralfbo.c \
    139139        $(VBOX_PATH_CROGL_GENFILES)/server_dispatch.c \
    140140        $(VBOX_PATH_CROGL_GENFILES)/server_retval.c \

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

    r27708 r27889  
    6969
    7070static const char* gszVBoxOGLSSMMagic = "***OpenGL state data***";
    71 #define SHCROGL_SSM_VERSION 16
     71#define SHCROGL_SSM_VERSION 17
    7272
    7373static DECLCALLBACK(int) svcUnload (void *)
    … …  
    196196}
    197197
     198static DECLCALLBACK(void) svcPresentFBO(void *data, int32_t screenId, int32_t x, int32_t y, uint32_t w, uint32_t h)
     199{
     200#if 0
     201    ComPtr<IDisplay> pDisplay;
     202    BYTE *data;
     203    int i,j;
     204    CHECK_ERROR(g_pConsole, COMGETTER(Display)(pDisplay.asOutParam()));
     205
     206    data = (BYTE*) RTMemTmpAllocZ(100*100*4);
     207
     208    for (i=0; i<100; i+=2)
     209    {
     210        for (j=0; j<100; ++j)
     211        {
     212            *(data+i*100*4+j*4+0) = 0xFF;
     213            *(data+i*100*4+j*4+1) = 0xFF;
     214            *(data+i*100*4+j*4+2) = 0xFF;
     215            *(data+i*100*4+j*4+3) = 0xFF;
     216        }
     217    }
     218
     219    CHECK_ERROR(pDisplay, DrawToScreen(data, 0, 0, 100, 100));
     220
     221    RTMemTmpFree(data);
     222#endif
     223    HRESULT rc;
     224    ComPtr<IDisplay> pDisplay;
     225
     226    CHECK_ERROR(g_pConsole, COMGETTER(Display)(pDisplay.asOutParam()));
     227    CHECK_ERROR(pDisplay, DrawToScreen((BYTE*)data, x, y, w, h));
     228}
     229
    198230static DECLCALLBACK(void) svcCall (void *, VBOXHGCMCALLHANDLE callHandle, uint32_t u32ClientID, void *pvClient, uint32_t u32Function, uint32_t cParms, VBOXHGCMSVCPARM paParms[])
    199231{
    … …  
    332364                paParms[2].u.uint32 = cbWriteback;
    333365            }
     366
    334367            break;
    335368        }
    … …  
    621654            if (!crVBoxServerInit())
    622655                return VERR_NOT_SUPPORTED;
     656
     657            crVBoxServerSetPresentFBOCB(svcPresentFBO);
    623658        }
    624659    }

  • 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);

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

    r27708 r27889  
    10341034    else if (pname == GL_REAL_RENDERER)
    10351035        return render_spu.ws.glGetString(GL_RENDERER);
     1036    else if (pname == GL_REAL_EXTENSIONS)
     1037        return render_spu.ws.glGetString(GL_EXTENSIONS);
    10361038#endif
    10371039    else

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

    r27708 r27889  
    871871            }
    872872
    873             crDebug("MakeCurrent 0x%x, 0x%x", window->device_context, context->hRC);
     873            /*crDebug("MakeCurrent 0x%x, 0x%x", window->device_context, context->hRC);*/
    874874            if (!render_spu.ws.wglMakeCurrent(window->device_context, context->hRC))
    875875            {

  • trunk/src/VBox/Main/DisplayImpl.cpp

    r27754 r27889  
    951951        LogFlowFunc (("Calling VRDP\n"));
    952952        mParent->consoleVRDPServer()->SendResize();
     953
     954#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
     955        {
     956            BOOL is3denabled;
     957            mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     958
     959            if (is3denabled)
     960            {
     961                VBOXHGCMSVCPARM parm;
     962
     963                parm.type = VBOX_HGCM_SVC_PARM_32BIT;
     964                parm.u.uint32 = uScreenId;
     965
     966                mParent->getVMMDev()->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED,
     967                                                   SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
     968            }
     969        }
     970#endif /* VBOX_WITH_CROGL */
    953971    }
    954972}
    … …  
    34343452        /* @todo May be framebuffer/display should be notified in this case. */
    34353453    }
     3454
     3455#if defined(VBOX_WITH_HGCM) && defined(VBOX_WITH_CROGL)
     3456    if (fNewOrigin && !fResize)
     3457    {
     3458        BOOL is3denabled;
     3459        pThis->mParent->machine()->COMGETTER(Accelerate3DEnabled)(&is3denabled);
     3460
     3461        if (is3denabled)
     3462        {
     3463            VBOXHGCMSVCPARM parm;
     3464
     3465            parm.type = VBOX_HGCM_SVC_PARM_32BIT;
     3466            parm.u.uint32 = pScreen->u32ViewIndex;
     3467
     3468            pThis->mParent->getVMMDev()->hgcmHostCall("VBoxSharedCrOpenGL", SHCRGL_HOST_FN_SCREEN_CHANGED,
     3469                                                      SHCRGL_CPARMS_SCREEN_CHANGED, &parm);
     3470        }
     3471    }
     3472#endif /* VBOX_WITH_CROGL */
    34363473
    34373474    if (!fResize)
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