VirtualBox

Changeset 22284 in vbox


Ignore:
Timestamp:
Aug 17, 2009 8:44:47 AM (16 years ago)
Author:
vboxsync
Message:

crOpenGL: add compiled vertex array support

Location:
trunk/src/VBox
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_client.c

    r21564 r22284  
    137137}
    138138
     139void PACKSPU_APIENTRY packspu_IndexPointer( GLenum type, GLsizei stride, const GLvoid *pointer )
     140{
     141#if CR_ARB_vertex_buffer_object
     142    GET_CONTEXT(ctx);
     143    if (ctx->clientState->extensions.ARB_vertex_buffer_object) {
     144        if (pack_spu.swap)
     145            crPackIndexPointerSWAP( type, stride, pointer );
     146        else
     147            crPackIndexPointer( type, stride, pointer );
     148    }
     149#endif
     150    crStateIndexPointer(type, stride, pointer);
     151}
     152
    139153void PACKSPU_APIENTRY packspu_GetPointerv( GLenum pname, GLvoid **params )
    140154{
    … …  
    175189
    176190    if (serverArrays) {
     191        GET_CONTEXT(ctx);
     192        CRClientState *clientState = &(ctx->clientState->client);
     193
     194        /*Note the comment in packspu_LockArraysEXT*/
     195        if (clientState->array.locked && !clientState->array.synced)
     196        {
     197            crPackLockArraysEXT(clientState->array.lockFirst, clientState->array.lockCount);
     198            clientState->array.synced = GL_TRUE;
     199        }
     200
    177201        /* Send the DrawArrays command over the wire */
    178202        if (pack_spu.swap)
    … …  
    211235
    212236    if (serverArrays) {
     237        GET_CONTEXT(ctx);
     238        CRClientState *clientState = &(ctx->clientState->client);
     239
     240        /*Note the comment in packspu_LockArraysEXT*/
     241        if (clientState->array.locked && !clientState->array.synced)
     242        {
     243            crPackLockArraysEXT(clientState->array.lockFirst, clientState->array.lockCount);
     244            clientState->array.synced = GL_TRUE;
     245        }
     246       
    213247        /* Send the DrawArrays command over the wire */
    214248        if (pack_spu.swap)
    … …  
    246280
    247281    if (serverArrays) {
     282        GET_CONTEXT(ctx);
     283        CRClientState *clientState = &(ctx->clientState->client);
     284
     285        /*Note the comment in packspu_LockArraysEXT*/
     286        if (clientState->array.locked && !clientState->array.synced)
     287        {
     288            crPackLockArraysEXT(clientState->array.lockFirst, clientState->array.lockCount);
     289            clientState->array.synced = GL_TRUE;
     290        }
     291
    248292        /* Send the DrawRangeElements command over the wire */
    249293        if (pack_spu.swap)
    … …  
    279323
    280324    if (serverArrays) {
     325        GET_CONTEXT(ctx);
     326        CRClientState *clientState = &(ctx->clientState->client);
     327
     328        /*Note the comment in packspu_LockArraysEXT*/
     329        if (clientState->array.locked && !clientState->array.synced)
     330        {
     331            crPackLockArraysEXT(clientState->array.lockFirst, clientState->array.lockCount);
     332            clientState->array.synced = GL_TRUE;
     333        }
     334
    281335        /* Send the DrawArrays command over the wire */
    282336        if (pack_spu.swap)
    … …  
    402456    crPackPopClientAttrib();
    403457}
     458
     459void PACKSPU_APIENTRY packspu_LockArraysEXT(GLint first, GLint count)
     460{
     461    if (first>=0 && count>0)
     462    {
     463        crStateLockArraysEXT(first, count);
     464        /*Note: this is a workaround for quake3 based apps.
     465          It's modifying vertex data between glLockArraysEXT and glDrawElements calls,
     466          so we'd pass data to host right before the glDrawSomething call.
     467        */
     468        /*crPackLockArraysEXT(first, count);*/
     469    }
     470    else crDebug("Ignoring packspu_LockArraysEXT: first:%i, count:%i", first, count);
     471}
     472
     473void PACKSPU_APIENTRY packspu_UnlockArraysEXT()
     474{
     475    crStateUnlockArraysEXT();
     476    crPackUnlockArraysEXT();
     477}

  • trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_special

    r21308 r22284  
    2222TexCoordPointer
    2323EdgeFlagPointer
     24IndexPointer
    2425ArrayElement
    2526DrawArrays
    … …  
    7778GetBufferSubDataARB
    7879IsEnabled
     80LockArraysEXT
     81UnlockArraysEXT

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

    r22155 r22284  
    1020410204chromium    extpack
    1020510205
     10206# GL_EXT_compiled_vertex_array
     10207
     10208name        LockArraysEXT
     10209return      void
     10210param       first           GLint
     10211param       count           GLint
     10212category    GL_EXT_compiled_vertex_array
     10213chromium    extpack
     10214
     10215name        UnlockArraysEXT
     10216return      void
     10217category    GL_EXT_compiled_vertex_array
     10218chromium    extpack
     10219
    1020610220# end of file sentinel
    1020710221

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

    r22155 r22284  
    1919 */
    2020static const char *crExtensions =
     21#ifdef CR_EXT_texture_compression_s3tc
     22    "GL_EXT_texture_compression_s3tc "
     23#endif
     24#ifdef CR_EXT_draw_range_elements
     25    "GL_EXT_draw_range_elements "
     26#endif
     27#ifdef CR_EXT_framebuffer_object
     28    "GL_EXT_framebuffer_object "
     29#endif
     30#ifdef CR_EXT_compiled_vertex_array
     31    "GL_EXT_compiled_vertex_array "
     32#endif
    2133#ifdef CR_ARB_depth_texture
    2234        "GL_ARB_depth_texture "
    … …  
    194206#endif
    195207#ifdef CR_ARB_fragment_shader
    196     "GL_ARB_fragment_shader "
    197 #endif
    198 #ifdef CR_EXT_texture_compression_s3tc
    199     "GL_EXT_texture_compression_s3tc "
    200 #endif
    201 #ifdef CR_EXT_draw_range_elements
    202     "GL_EXT_draw_range_elements "
    203 #endif
    204 #ifdef CR_EXT_framebuffer_object
    205     "GL_EXT_framebuffer_object"
     208    "GL_ARB_fragment_shader"
    206209#endif
    207210        "";
    208 
    209211
    210212/*

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

    r22155 r22284  
    1616/*For now guest is allowed to connect host opengl service if protocol version matches exactly*/
    1717/*Note: that after any change to this file, or glapi_parser\apispec.txt version should be changed*/
    18 #define CR_PROTOCOL_VERSION_MAJOR 2
     18#define CR_PROTOCOL_VERSION_MAJOR 3
    1919#define CR_PROTOCOL_VERSION_MINOR 1
    2020

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

    r22155 r22284  
    120120
    121121#define CR_EXT_framebuffer_object 1
     122#define CR_EXT_compiled_vertex_array 1
    122123
    123124#endif /* CR_VERSION_H */

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

    r15532 r22284  
    6666    CRBufferObject *buffer;
    6767#endif
     68#ifdef CR_EXT_compiled_vertex_array
     69    GLboolean locked;
     70    unsigned char *prevPtr;
     71    GLint   prevStride;
     72#endif
    6873} CRClientPointer;
    6974
    … …  
    8691    GLuint arrayRangeLength;
    8792#endif
     93#ifdef CR_EXT_compiled_vertex_array
     94    GLint lockFirst;
     95    GLint lockCount;
     96    GLboolean locked;
     97# ifdef IN_GUEST
     98    GLboolean synced;
     99# endif
     100#endif
    88101} CRVertexArrays;
     102
     103#define CRSTATECLIENT_MAX_VERTEXARRAYS (7+CR_MAX_TEXTURE_UNITS+CR_MAX_VERTEX_ATTRIBS)
    89104
    90105typedef struct {
    … …  
    117132DECLEXPORT(GLboolean) crStateUseServerArrays(void);
    118133DECLEXPORT(GLboolean) crStateUseServerArrayElements(void);
     134DECLEXPORT(CRClientPointer*) crStateGetClientPointerByIndex(int index, CRVertexArrays *array);
    119135
    120136#ifdef __cplusplus

  • trunk/src/VBox/GuestHost/OpenGL/packer/pack_client.c

    r21911 r22284  
    304304    const CRVertexArrays *array = &(c->array);
    305305    const GLboolean vpEnabled = crStateGetCurrent()->program.vpEnabled;
     306
     307    crDebug("crPackExpandArrayElement(%i)", index);
    306308
    307309    if (array->n.enabled && !(vpEnabled && array->a[VERT_ATTRIB_NORMAL].enabled))
    … …  
    936938void
    937939crPackExpandMultiDrawElementsEXT( GLenum mode, const GLsizei *count,
    938                                                                     GLenum type, const GLvoid **indices,
    939                                                                     GLsizei primcount, CRClientState *c )
     940                                  GLenum type, const GLvoid **indices,
     941                                  GLsizei primcount, CRClientState *c )
    940942{
    941943   GLint i;
    … …  
    947949}
    948950#endif /* CR_EXT_multi_draw_arrays */
     951
     952static int crPack_GetNumEnabledArrays(CRClientState *c, int *size)
     953{
     954    int i, count=0;
     955
     956    *size = 0;
     957   
     958    if (c->array.v.enabled)
     959    {
     960        count++;
     961        *size += c->array.v.bytesPerIndex;
     962    }
     963
     964    if (c->array.c.enabled)
     965    {
     966        count++;
     967        *size += c->array.c.bytesPerIndex;
     968    }
     969
     970    if (c->array.f.enabled)
     971    {
     972        count++;
     973        *size += c->array.f.bytesPerIndex;
     974    }
     975
     976    if (c->array.s.enabled)
     977    {
     978        count++;
     979        *size += c->array.s.bytesPerIndex;
     980    }
     981
     982    if (c->array.e.enabled)
     983    {
     984        count++;
     985        *size += c->array.e.bytesPerIndex;
     986    }
     987
     988    if (c->array.i.enabled)
     989    {
     990        count++;
     991        *size += c->array.i.bytesPerIndex;
     992    }
     993
     994    if (c->array.n.enabled)
     995    {
     996        count++;
     997        *size += c->array.n.bytesPerIndex;
     998    }
     999
     1000    for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++)
     1001    {
     1002        if (c->array.t[i].enabled)
     1003        {
     1004            count++;
     1005            *size += c->array.t[i].bytesPerIndex;
     1006        }
     1007    }
     1008
     1009    for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++)
     1010    {
     1011        if (c->array.a[i].enabled)
     1012        {
     1013            count++;
     1014            *size += c->array.a[i].bytesPerIndex;
     1015        }
     1016    }
     1017
     1018    return count;
     1019}
     1020
     1021static void crPackLockClientPointer(GLint first, GLint count, unsigned char **ppData, int index, CRClientState *c)
     1022{
     1023    CRClientPointer *cp;
     1024    unsigned char *data_ptr = *ppData, *cptr;
     1025    GLint i;
     1026
     1027    cp = crStateGetClientPointerByIndex(index, &c->array);
     1028
     1029    if (cp->enabled)
     1030    {
     1031        if (cp->buffer && cp->buffer->name)
     1032        {
     1033            crWarning("crPackLockClientPointer called when there's VBO enabled!");
     1034        }
     1035
     1036        WRITE_DATA_AI(int, index);
     1037        cptr = cp->p + first*cp->bytesPerIndex;
     1038        if (cp->bytesPerIndex==cp->stride)
     1039        {
     1040            crMemcpy(data_ptr, cptr, count*cp->bytesPerIndex);
     1041            data_ptr += count*cp->bytesPerIndex;
     1042        }
     1043        else
     1044        {
     1045            for (i=0; i<count; ++i)
     1046            {
     1047                crMemcpy(data_ptr, cptr, cp->bytesPerIndex);
     1048                data_ptr += cp->bytesPerIndex;
     1049                cptr += cp->stride;
     1050            }
     1051        }
     1052        *ppData = data_ptr;
     1053    }
     1054}
     1055
     1056void PACK_APIENTRY crPackLockArraysEXT(GLint first, GLint count)
     1057{
     1058    CRContext *g = crStateGetCurrent();
     1059    CRClientState *c = &g->client;
     1060    unsigned char *data_ptr, *start_ptr;
     1061    int packet_length = sizeof(int); /*extopcode*/
     1062    int vertex_size, i, numenabled;
     1063
     1064    packet_length += sizeof(first) + sizeof(count); /*params*/
     1065    numenabled = crPack_GetNumEnabledArrays(c, &vertex_size);
     1066    packet_length += sizeof(int) + numenabled*sizeof(int); /*numenabled + indices*/
     1067    packet_length += vertex_size * count; /*vertices data*/
     1068
     1069    start_ptr = data_ptr = (unsigned char *) crPackAlloc(packet_length);
     1070    WRITE_DATA_AI(GLenum, CR_LOCKARRAYSEXT_EXTEND_OPCODE );
     1071    WRITE_DATA_AI(GLint, first);
     1072    WRITE_DATA_AI(GLint, count);
     1073    WRITE_DATA_AI(int, numenabled);
     1074    for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i)
     1075    {
     1076        crPackLockClientPointer(first, count, &data_ptr, i, c);
     1077    }
     1078    crHugePacket(CR_EXTEND_OPCODE, start_ptr);
     1079    crPackFree(start_ptr);
     1080}

  • trunk/src/VBox/GuestHost/OpenGL/packer/packer_special

    r22155 r22284  
    169169DeleteFramebuffersEXT
    170170DeleteRenderbuffersEXT
     171LockArraysEXT

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

    r21765 r22284  
    5454}
    5555
     56static void crStateUnlockClientPointer(CRClientPointer* cp)
     57{
     58    if (cp->locked)
     59    {
     60#ifndef IN_GUEST
     61        if (cp->p) crFree(cp->p);
     62#endif
     63        cp->locked = GL_FALSE;
     64    }
     65}
     66
    5667void crStateClientDestroy(CRClientState *c)
    5768{
     69#ifdef CR_EXT_compiled_vertex_array
     70    if (c->array.locked)
     71    {
     72        unsigned int i;
     73
     74        crStateUnlockClientPointer(&c->array.v);
     75        crStateUnlockClientPointer(&c->array.c);
     76        crStateUnlockClientPointer(&c->array.f);
     77        crStateUnlockClientPointer(&c->array.s);
     78        crStateUnlockClientPointer(&c->array.e);
     79        crStateUnlockClientPointer(&c->array.i);
     80        crStateUnlockClientPointer(&c->array.n);
     81        for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++)
     82        {
     83            crStateUnlockClientPointer(&c->array.t[i]);
     84        }
     85        for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++)
     86        {
     87            crStateUnlockClientPointer(&c->array.a[i]);
     88        }
     89    }
     90#endif
    5891}
    5992
    … …  
    83116    c->curClientTextureUnit = 0;
    84117
     118#ifdef CR_EXT_compiled_vertex_array
     119    c->array.lockFirst = 0;
     120    c->array.lockCount = 0;
     121    c->array.locked = GL_FALSE;
     122# ifdef IN_GUEST
     123    c->array.synced = GL_FALSE;
     124# endif
     125#endif
     126
    85127    /* vertex array */
    86128    c->array.v.p = NULL;
    … …  
    92134    c->array.v.buffer = g->bufferobject.vertexBuffer;
    93135#endif
     136#ifdef CR_EXT_compiled_vertex_array
     137    c->array.v.locked = GL_FALSE;
     138    c->array.v.prevPtr = NULL;
     139    c->array.v.prevStride = 0;
     140#endif
    94141
    95142    /* color array */
    … …  
    102149    c->array.c.buffer = g->bufferobject.vertexBuffer;
    103150#endif
     151#ifdef CR_EXT_compiled_vertex_array
     152    c->array.c.locked = GL_FALSE;
     153    c->array.c.prevPtr = NULL;
     154    c->array.c.prevStride = 0;
     155#endif
    104156
    105157    /* fog array */
    … …  
    112164    c->array.f.buffer = g->bufferobject.vertexBuffer;
    113165#endif
     166#ifdef CR_EXT_compiled_vertex_array
     167    c->array.f.locked = GL_FALSE;
     168    c->array.f.prevPtr = NULL;
     169    c->array.f.prevStride = 0;
     170#endif
    114171
    115172    /* secondary color array */
    … …  
    122179    c->array.s.buffer = g->bufferobject.vertexBuffer;
    123180#endif
     181#ifdef CR_EXT_compiled_vertex_array
     182    c->array.s.locked = GL_FALSE;
     183    c->array.s.prevPtr = NULL;
     184    c->array.s.prevStride = 0;
     185#endif
    124186
    125187    /* edge flag array */
    … …  
    132194    c->array.e.buffer = g->bufferobject.vertexBuffer;
    133195#endif
     196#ifdef CR_EXT_compiled_vertex_array
     197    c->array.e.locked = GL_FALSE;
     198    c->array.e.prevPtr = NULL;
     199    c->array.e.prevStride = 0;
     200#endif
    134201
    135202    /* color index array */
    … …  
    142209    c->array.i.buffer = g->bufferobject.vertexBuffer;
    143210#endif
     211#ifdef CR_EXT_compiled_vertex_array
     212    c->array.i.locked = GL_FALSE;
     213    c->array.i.prevPtr = NULL;
     214    c->array.i.prevStride = 0;
     215#endif
    144216
    145217    /* normal array */
    … …  
    152224    c->array.n.buffer = g->bufferobject.vertexBuffer;
    153225#endif
     226#ifdef CR_EXT_compiled_vertex_array
     227    c->array.n.locked = GL_FALSE;
     228    c->array.n.prevPtr = NULL;
     229    c->array.n.prevStride = 0;
     230#endif
    154231
    155232    /* texcoord arrays */
    … …  
    163240#ifdef CR_ARB_vertex_buffer_object2
    164241        c->array.t[i].buffer = g->bufferobject.vertexBuffer;
     242#endif
     243#ifdef CR_EXT_compiled_vertex_array
     244        c->array.t[i].locked = GL_FALSE;
     245        c->array.t[i].prevPtr = NULL;
     246        c->array.t[i].prevStride = 0;
    165247#endif
    166248    }
    … …  
    175257#ifdef CR_ARB_vertex_buffer_object2
    176258        c->array.a[i].buffer = g->bufferobject.vertexBuffer;
     259#endif
     260#ifdef CR_EXT_compiled_vertex_array
     261        c->array.a[i].locked = GL_FALSE;
     262        c->array.a[i].prevPtr = NULL;
     263        c->array.a[i].prevStride = 0;
    177264#endif
    178265    }
    … …  
    466553    CRContext *g = GetCurrentContext();
    467554
     555#ifdef CR_EXT_compiled_vertex_array
     556    crStateUnlockClientPointer(cp);
     557    cp->prevPtr = cp->p;
     558    cp->prevStride = cp->stride;
     559#endif
     560
    468561    cp->p = (unsigned char *) pointer;
    469562    cp->size = size;
    … …  
    855948void STATE_APIENTRY crStateGetVertexAttribPointervARB(GLuint index, GLenum pname, GLvoid **pointer)
    856949{
    857         crStateGetVertexAttribPointervNV(index, pname, pointer);
     950    crStateGetVertexAttribPointervNV(index, pname, pointer);
    858951}
    859952
    … …  
    9231016    cp->enabled = GL_TRUE;
    9241017
     1018#ifdef CR_EXT_compiled_vertex_array
     1019    crStateUnlockClientPointer(cp);
     1020#endif
     1021
    9251022    switch (format)
    9261023    {
    … …  
    9991096    cp->enabled = GL_TRUE;
    10001097    cp->stride = stride;
     1098#ifdef CR_EXT_compiled_vertex_array
     1099    crStateUnlockClientPointer(cp);
     1100#endif
     1101
    10011102    switch (format)
    10021103    {
    … …  
    10461147    cp->enabled = GL_TRUE;
    10471148    cp->stride = stride;
     1149#ifdef CR_EXT_compiled_vertex_array
     1150    crStateUnlockClientPointer(cp);
     1151#endif
     1152
    10481153    switch (format)
    10491154    {
    … …  
    11161221    cp->enabled = GL_TRUE;
    11171222    cp->stride = stride;
     1223#ifdef CR_EXT_compiled_vertex_array
     1224    crStateUnlockClientPointer(cp);
     1225#endif
     1226
    11181227    switch (format)
    11191228    {
    … …  
    13071416}
    13081417
     1418static void crStateLockClientPointer(CRClientPointer* cp)
     1419{
     1420    crStateUnlockClientPointer(cp);
     1421    if (cp->enabled)
     1422    {
     1423        cp->locked = GL_TRUE;
     1424    }
     1425}
     1426
     1427void STATE_APIENTRY crStateLockArraysEXT(GLint first, GLint count)
     1428{
     1429    CRContext *g = GetCurrentContext();
     1430    CRClientState *c = &(g->client);
     1431    unsigned int i;
     1432
     1433    c->array.locked = GL_TRUE;
     1434    c->array.lockFirst = first;
     1435    c->array.lockCount = count;
     1436#ifdef IN_GUEST
     1437    c->array.synced = GL_FALSE;
     1438#endif
     1439
     1440    crStateLockClientPointer(&c->array.v);
     1441    crStateLockClientPointer(&c->array.c);
     1442    crStateLockClientPointer(&c->array.f);
     1443    crStateLockClientPointer(&c->array.s);
     1444    crStateLockClientPointer(&c->array.e);
     1445    crStateLockClientPointer(&c->array.i);
     1446    crStateLockClientPointer(&c->array.n);
     1447    for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++)
     1448    {
     1449        crStateLockClientPointer(&c->array.t[i]);
     1450    }
     1451    for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++)
     1452    {
     1453        crStateLockClientPointer(&c->array.a[i]);
     1454    }
     1455}
     1456
     1457void STATE_APIENTRY crStateUnlockArraysEXT()
     1458{
     1459    CRContext *g = GetCurrentContext();
     1460    CRClientState *c = &(g->client);
     1461    unsigned int i;
     1462
     1463    c->array.locked = GL_FALSE;
     1464#ifdef IN_GUEST
     1465    c->array.synced = GL_FALSE;
     1466#endif
     1467
     1468    crStateUnlockClientPointer(&c->array.v);
     1469    crStateUnlockClientPointer(&c->array.c);
     1470    crStateUnlockClientPointer(&c->array.f);
     1471    crStateUnlockClientPointer(&c->array.s);
     1472    crStateUnlockClientPointer(&c->array.e);
     1473    crStateUnlockClientPointer(&c->array.i);
     1474    crStateUnlockClientPointer(&c->array.n);
     1475    for (i = 0 ; i < CR_MAX_TEXTURE_UNITS ; i++)
     1476    {
     1477        crStateUnlockClientPointer(&c->array.t[i]);
     1478    }
     1479    for (i = 0; i < CR_MAX_VERTEX_ATTRIBS; i++)
     1480    {
     1481        crStateUnlockClientPointer(&c->array.a[i]);
     1482    }
     1483}
    13091484
    13101485void STATE_APIENTRY crStateVertexArrayRangeNV(GLsizei length, const GLvoid *pointer)
    … …  
    13221497
    13231498/*Returns if the given clientpointer could be used on server side directly*/
    1324 #define CRSTATE_IS_SERVER_CP(cp) (!(cp).enabled || !(cp).p || ((cp).buffer && (cp).buffer->name))
     1499#define CRSTATE_IS_SERVER_CP(cp) (!(cp).enabled || !(cp).p || ((cp).buffer && (cp).buffer->name) || ((cp).locked))
    13251500
    13261501static void crStateDumpClientPointer(CRClientPointer *cp, const char *name, int i)
    … …  
    13281503  if (i<0 && cp->enabled)
    13291504  {
    1330     crDebug("CP(%s): enabled:%d ptr:%p buffer:%p buffer.name:%i %s",
    1331             name, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1,
     1505    crDebug("CP(%s): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i",
     1506            name, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1, (int)cp->locked,
    13321507            CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!");
    13331508  }
    13341509  else if (0==i || cp->enabled)
    13351510  {
    1336     crDebug("CP(%s%i): enabled:%d ptr:%p buffer:%p buffer.name:%i %s",
    1337             name, i, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1,
     1511    crDebug("CP(%s%i): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i",
     1512            name, i, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1, (int)cp->locked,
    13381513            CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!");
    13391514  }
    … …  
    13601535          && CRSTATE_IS_SERVER_CP(c->array.f);
    13611536
    1362     for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++)
    1363         if (!CRSTATE_IS_SERVER_CP(c->array.t[i]))
    1364         {
    1365             res = GL_FALSE;
    1366             break;   
    1367         }
    1368 
    1369     for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++)
    1370         if (!CRSTATE_IS_SERVER_CP(c->array.a[i]))
    1371         {
    1372             res = GL_FALSE;
    1373             break;   
    1374         }
    1375 
    1376 #ifdef DEBUG
     1537    if (res)
     1538    {
     1539        for (i = 0; (unsigned int)i < g->limits.maxTextureUnits; i++)
     1540            if (!CRSTATE_IS_SERVER_CP(c->array.t[i]))
     1541            {
     1542                res = GL_FALSE;
     1543                break;   
     1544            }
     1545    }
     1546
     1547    if (res)
     1548    {
     1549        for (i = 0; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++)
     1550            if (!CRSTATE_IS_SERVER_CP(c->array.a[i]))
     1551            {
     1552                res = GL_FALSE;
     1553                break;   
     1554            }
     1555    }
     1556
     1557#if defined(DEBUG) && 0
    13771558    if (!res)
    13781559    {
    … …  
    18101991    }
    18111992}
     1993
     1994CRClientPointer* crStateGetClientPointerByIndex(int index, CRVertexArrays *array)
     1995{
     1996    CRASSERT(array && index>=0 && index<CRSTATECLIENT_MAX_VERTEXARRAYS);
     1997
     1998    if (index<7)
     1999    {
     2000        switch (index)
     2001        {
     2002            case 0: return &array->v;
     2003            case 1: return &array->c;
     2004            case 2: return &array->f;
     2005            case 3: return &array->s;
     2006            case 4: return &array->e;
     2007            case 5: return &array->i;
     2008            case 6: return &array->n;
     2009        }
     2010    }
     2011    else if (index<(7+CR_MAX_TEXTURE_UNITS))
     2012    {
     2013        return &array->t[index-7];
     2014    }
     2015    else
     2016    {
     2017        return &array->a[index-7-CR_MAX_TEXTURE_UNITS];
     2018    }
     2019
     2020    /*silence the compiler warning*/
     2021    CRASSERT(false);
     2022    return NULL;
     2023}

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_get.txt

    r22155 r22284  
    304304GLint GL_FRAMEBUFFER_BINDING_EXT (g->framebufferobject.framebuffer?g->framebufferobject.framebuffer->id:0)
    305305GLint GL_RENDERBUFFER_BINDING_EXT (g->framebufferobject.renderbuffer?g->framebufferobject.renderbuffer->id:0)
     306
     307#CVA
     308GLint GL_ARRAY_ELEMENT_LOCK_FIRST_EXT g->client.array.lockFirst
     309GLint GL_ARRAY_ELEMENT_LOCK_COUNT_EXT g->client.array.lockCount

  • trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_special

    r22155 r22284  
    363363GetFramebufferAttachmentParameterivEXT
    364364GenerateMipmapEXT
     365LockArraysEXT
     366UnlockArraysEXT

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

    r22155 r22284  
    172172        $(VBOX_PATH_CROGL_GENFILES)/spu_dispatch_table.h \
    173173        $(VBOX_PATH_CROGL_GENFILES)/cr_opcodes.h \
    174         $(VBOX_PATH_CROGL_GENFILES)/unpack_extend.h
     174        $(VBOX_PATH_CROGL_GENFILES)/unpack_extend.h \
     175        $(VBOX_PATH_CROGL_GENFILES)/state/cr_currentpointers.h \
     176        $(VBOX_PATH_CROGL_GENFILES)/state/cr_statefuncs.h
    175177VBoxOGLcrunpacker_SOURCES  = \
    176178        unpacker/unpack_arrays.c \

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

    r22165 r22284  
    7171
    7272static const char* gszVBoxOGLSSMMagic = "***OpenGL state data***";
    73 #define SHCROGL_SSM_VERSION 5
     73#define SHCROGL_SSM_VERSION 6
    7474
    7575typedef struct

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_arrays.c

    r21423 r22284  
    88#include "unpack_extend.h"
    99#include "unpacker.h"
     10#include "cr_glstate.h"
    1011/**
    1112 * \mainpage Unpacker
    … …  
    158159    crError( "Can't decode MultiDrawElementsEXT" );
    159160}
     161
     162static void crUnpackSetClientPointerByIndex(int index, GLint size,
     163                                            GLenum type, GLboolean normalized,
     164                                            GLsizei stride, const GLvoid *pointer, CRClientState *c)
     165{
     166    if (index<7)
     167    {
     168        switch (index)
     169        {
     170            case 0:
     171                cr_unpackDispatch.VertexPointer(size, type, stride, pointer);
     172                break;
     173            case 1:
     174                cr_unpackDispatch.ColorPointer(size, type, stride, pointer);
     175                break;
     176            case 2:
     177                cr_unpackDispatch.FogCoordPointerEXT(type, stride, pointer);
     178                break;
     179            case 3:
     180                cr_unpackDispatch.SecondaryColorPointerEXT(size, type, stride, pointer);
     181                break;
     182            case 4:
     183                cr_unpackDispatch.EdgeFlagPointer(stride, pointer);
     184                break;
     185            case 5:
     186                cr_unpackDispatch.IndexPointer(type, stride, pointer);
     187                break;
     188            case 6:
     189                cr_unpackDispatch.NormalPointer(type, stride, pointer);
     190                break;
     191        }
     192    }
     193    else if (index<(7+CR_MAX_TEXTURE_UNITS))
     194    {
     195        int curTexUnit = c->curClientTextureUnit;
     196        if ((index-7)!=curTexUnit)
     197        {
     198            cr_unpackDispatch.ClientActiveTextureARB(GL_TEXTURE0_ARB+index-7);
     199        }
     200        cr_unpackDispatch.TexCoordPointer(size, type, stride, pointer);
     201        if ((index-7)!=curTexUnit)
     202        {
     203            cr_unpackDispatch.ClientActiveTextureARB(GL_TEXTURE0_ARB+curTexUnit);
     204        }
     205    }
     206    else
     207    {
     208        cr_unpackDispatch.VertexAttribPointerARB(index-7-CR_MAX_TEXTURE_UNITS,
     209                                                 size, type, normalized, stride, pointer);
     210    }
     211}
     212
     213void crUnpackExtendLockArraysEXT(void)
     214{
     215    GLint first    = READ_DATA(sizeof(int) + 4, GLint);
     216    GLint count    = READ_DATA(sizeof(int) + 8, GLint);
     217    int numenabled = READ_DATA(sizeof(int) + 12, int);
     218
     219    CRContext *g = crStateGetCurrent();
     220    CRClientState *c = &g->client;
     221    CRClientPointer *cp;
     222    int i, index, offset;
     223    unsigned char *data;
     224   
     225    offset = 2*sizeof(int)+12;
     226
     227    for (i=0; i<numenabled; ++i)
     228    {
     229        index = READ_DATA(offset, int);
     230        offset += sizeof(int);
     231        cp = crStateGetClientPointerByIndex(index, &c->array);
     232        CRASSERT(cp && cp->enabled && (!cp->buffer || !cp->buffer->name));
     233        data = crAlloc((first+count)*cp->bytesPerIndex);
     234        crMemcpy(data+first*cp->bytesPerIndex, DATA_POINTER(offset, GLvoid), count*cp->bytesPerIndex);
     235        offset += count*cp->bytesPerIndex;
     236        crUnpackSetClientPointerByIndex(index, cp->size, cp->type, cp->normalized, 0, data, c);
     237    }
     238    cr_unpackDispatch.LockArraysEXT(first, count);
     239}
     240
     241void crUnpackExtendUnlockArraysEXT(void)
     242{
     243    int i;
     244    CRContext *g = crStateGetCurrent();
     245    CRClientState *c = &g->client;
     246    CRClientPointer *cp;
     247
     248    cr_unpackDispatch.UnlockArraysEXT();
     249
     250    for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i)
     251    {
     252        cp = crStateGetClientPointerByIndex(i, &c->array);
     253        if (cp->enabled)
     254        {
     255            crUnpackSetClientPointerByIndex(i, cp->size, cp->type, cp->normalized, cp->prevStride, cp->prevPtr, c);
     256        }
     257    }
     258}

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpacker_special

    r22155 r22284  
    166166DeleteFramebuffersEXT
    167167DeleteRenderbuffersEXT
     168LockArraysEXT
     169UnlockArraysEXT
Note: See TracChangeset for help on using the changeset viewer.

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