VirtualBox

Changeset 22284 in vbox for trunk/src/VBox/GuestHost


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

crOpenGL: add compiled vertex array support

Location:
trunk/src/VBox/GuestHost/OpenGL
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • 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
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