Changeset 51200 in vbox for trunk

Timestamp:

May 6, 2014 5:21:16 PM (11 years ago)

Author:

vboxsync

svn:sync-xref-src-repo-rev:

93582

Message:

crOpenGL: getAttribLocations

Location:

trunk/src/VBox

Files:

• Additions/common/crOpenGL/getprocaddress.py (modified) (1 diff)
• Additions/common/crOpenGL/pack/packspu.h (modified) (1 diff)
• Additions/common/crOpenGL/pack/packspu_glsl.c (modified) (2 diffs)
• Additions/common/crOpenGL/pack/packspu_net.c (modified) (2 diffs)
• Additions/common/crOpenGL/pack/packspu_special (modified) (1 diff)
• Additions/common/crOpenGL/windows_getprocaddress.py (modified) (1 diff)
• GuestHost/OpenGL/glapi_parser/APIspec.txt (modified) (1 diff)
• GuestHost/OpenGL/include/cr_protocol.h (modified) (1 diff)
• GuestHost/OpenGL/include/state/cr_glsl.h (modified) (2 diffs)
• GuestHost/OpenGL/packer/pack_shaders.c (modified) (1 diff)
• GuestHost/OpenGL/packer/packer_special (modified) (1 diff)
• GuestHost/OpenGL/state_tracker/state_glsl.c (modified) (9 diffs)
• GuestHost/OpenGL/state_tracker/state_special (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_config.c (modified) (4 diffs)
• HostServices/SharedOpenGL/crserverlib/server_getshaders.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_special (modified) (1 diff)
• HostServices/SharedOpenGL/unpacker/unpack_shaders.c (modified) (1 diff)
• HostServices/SharedOpenGL/unpacker/unpacker_special (modified) (1 diff)

trunk/src/VBox/Additions/common/crOpenGL/getprocaddress.py ¶

@@ -59 +59 @@
         if (func_name == "Writeback" or
                 func_name == "BoundsInfoCR" or
-                func_name == "GetUniformsLocations"):
+                func_name == "GetUniformsLocations" or
+                func_name == "GetAttribsLocations"):
                 continue
         if apiutil.Category(func_name) == "Chromium":

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu.h ¶

@@ -23 +23 @@
 # include "cr_dump.h"
 #endif
+
+extern uint32_t g_u32VBoxHostCaps;
 
 typedef struct thread_info_t ThreadInfo;

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_glsl.c ¶

@@ -115 +115 @@
 }
 
+GLint PACKSPU_APIENTRY packspu_GetAttribLocationUnchached( GLuint program, const char * name )
+{
+    GET_THREAD(thread);
+    int writeback = 1;
+    GLint return_val = (GLint) 0;
+    if (!CRPACKSPU_IS_WDDM_CRHGSMI() && !(pack_spu.thread[pack_spu.idxThreadInUse].netServer.conn->actual_network))
+    {
+        crError( "packspu_GetAttribLocation doesn't work when there's no actual network involved!\nTry using the simplequery SPU in your chain!" );
+    }
+    if (pack_spu.swap)
+    {
+        crPackGetAttribLocationSWAP( program, name, &return_val, &writeback );
+    }
+    else
+    {
+        crPackGetAttribLocation( program, name, &return_val, &writeback );
+    }
+    packspuFlush( (void *) thread );
+    CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
+    if (pack_spu.swap)
+    {
+        return_val = (GLint) SWAP32(return_val);
+    }
+    return return_val;
+}
+
+GLint PACKSPU_APIENTRY packspu_GetAttribLocation(GLuint program, const char * name)
+{
+    if (!(CR_VBOX_CAP_GETATTRIBSLOCATIONS & g_u32VBoxHostCaps))
+        return packspu_GetAttribLocationUnchached(program, name);
+
+    if (!crStateIsProgramAttribsCached(program))
+    {
+        GET_THREAD(thread);
+        int writeback = 1;
+        GLsizei maxcbData;
+        GLsizei *pData;
+        GLint mu;
+
+        packspu_GetIntegerv(GL_MAX_VERTEX_ATTRIBS, &mu);
+        maxcbData = 4*32*mu*sizeof(char);
+
+        pData = (GLsizei *) crAlloc(maxcbData+sizeof(GLsizei));
+        if (!pData)
+        {
+            crWarning("packspu_GetAttribLocation: not enough memory, fallback to single query");
+            return packspu_GetAttribLocationUnchached(program, name);
+        }
+
+        crPackGetAttribsLocations(program, maxcbData, pData, NULL, &writeback);
+
+        packspuFlush((void *) thread);
+        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
+
+        crStateGLSLProgramCacheAttribs(program, pData[0], &pData[1]);
+
+        CRASSERT(crStateIsProgramAttribsCached(program));
+
+        crFree(pData);
+    }
+
+    /*crDebug("packspu_GetAttribLocation(%d, %s)=%i", program, name, crStateGetAttribLocation(program, name));*/
+    return crStateGetAttribLocation(program, name);
+}
+
 void PACKSPU_APIENTRY packspu_GetUniformsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData)
 {
@@ -121 +186 @@
     (void) cbData;
     (void) pData;
-    crWarning("packspu_GetUniformsLocations shouldn't be called directly");
+    WARN(("packspu_GetUniformsLocations shouldn't be called directly"));
+}
+
+void PACKSPU_APIENTRY packspu_GetAttribsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData)
+{
+    (void) program;
+    (void) maxcbData;
+    (void) cbData;
+    (void) pData;
+    WARN(("packspu_GetAttribsLocations shouldn't be called directly"));
 }
 

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_net.c ¶

@@ -13 +13 @@
 #include "packspu.h"
 #include "packspu_proto.h"
+
+uint32_t g_u32VBoxHostCaps = 0;
 
 static void
@@ -244 +246 @@
     if (server->conn)
     {
-        uint32_t u32HostCaps = crNetHostCapsGet();
-        if (u32HostCaps & CR_VBOX_CAP_CMDBLOCKS)
+        g_u32VBoxHostCaps = crNetHostCapsGet();
+        if (g_u32VBoxHostCaps & CR_VBOX_CAP_CMDBLOCKS)
             crPackCmdBlocksEnable();
     }

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

@@ -84 +84 @@
 DeleteProgram
 GetUniformLocation
+GetAttribLocation
 GetUniformsLocations
+GetAttribsLocations
 BindFramebufferEXT
 DeleteObjectARB

trunk/src/VBox/Additions/common/crOpenGL/windows_getprocaddress.py ¶

@@ -71 +71 @@
     if (func_name == "Writeback" or
         func_name == "BoundsInfoCR" or
-        func_name == "GetUniformsLocations"):
+        func_name == "GetUniformsLocations" or
+        func_name == "GetAttribsLocations"):
         continue
     if apiutil.Category(func_name) == "Chromium":

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

@@ -8385 +8385 @@
 chrelopcode 0
 
+# custom
+name        GetAttribsLocations
+return      void
+param       program     GLuint
+param       maxcbData   GLsizei
+param       cbData      GLsizei *
+param       pData       GLvoid *
+category    Chromium
+props       get
+chromium    extpack
+chrelopcode 1
+
 name        WindowShow
 return      void

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

@@ -38 +38 @@
  */
 #define CR_VBOX_CAP_CMDBLOCKS            0x00000004
+/* GetAttribsLocations support */
+#define CR_VBOX_CAP_GETATTRIBSLOCATIONS  0x00000008
+
+#define CR_VBOX_CAPS_ALL                 0x0000000f
 
 

trunk/src/VBox/GuestHost/OpenGL/include/state/cr_glsl.h ¶

@@ -72 +72 @@
     GLuint              cUniforms;
 #ifdef IN_GUEST
+    CRGLSLAttrib        *pAttribs;
+    GLuint              cAttribs;
     GLboolean           bUniformsSynced; /*uniforms info is updated since last link program call.*/
+    GLboolean           bAttribsSynced; /*attribs info is updated since last link program call.*/
 #endif
 } CRGLSLProgram;
@@ -103 +106 @@
 
 DECLEXPORT(GLboolean) STATE_APIENTRY crStateIsProgramUniformsCached(GLuint program);
+DECLEXPORT(GLboolean) STATE_APIENTRY crStateIsProgramAttribsCached(GLuint program);
 
 #ifdef IN_GUEST
 DECLEXPORT(void) STATE_APIENTRY crStateGLSLProgramCacheUniforms(GLuint program, GLsizei cbData, GLvoid *pData);
+DECLEXPORT(void) STATE_APIENTRY crStateGLSLProgramCacheAttribs(GLuint program, GLsizei cbData, GLvoid *pData);
 #else
 DECLEXPORT(void) STATE_APIENTRY crStateGLSLProgramCacheUniforms(GLuint program, GLsizei maxcbData, GLsizei *cbData, GLvoid *pData);
+DECLEXPORT(void) STATE_APIENTRY crStateGLSLProgramCacheAttribs(GLuint program, GLsizei maxcbData, GLsizei *cbData, GLvoid *pData);
 #endif
 

trunk/src/VBox/GuestHost/OpenGL/packer/pack_shaders.c ¶

@@ -568 +568 @@
 }
 
+void PACK_APIENTRY crPackGetAttribsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData, int * writeback)
+{
+    CR_GET_PACKER_CONTEXT(pc);
+    unsigned char *data_ptr;
+    (void) pData;
+    CR_GET_BUFFERED_POINTER(pc, 32);
+    WRITE_DATA(0, GLint, 32);
+    WRITE_DATA(4, GLenum, CR_GETATTRIBSLOCATIONS_EXTEND_OPCODE);
+    WRITE_DATA(8, GLuint, program);
+    WRITE_DATA(12, GLsizei, maxcbData);
+    WRITE_NETWORK_POINTER(16, (void *) cbData);
+    WRITE_NETWORK_POINTER(24, (void *) writeback);
+    WRITE_OPCODE(pc, CR_EXTEND_OPCODE);
+    CR_UNLOCK_PACKER_CONTEXT(pc);
+}
+
 void PACK_APIENTRY crPackGetAttribLocation(GLuint program, const char * name, GLint * return_value, int * writeback)
 {

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

@@ -171 +171 @@
 LockArraysEXT
 GetUniformsLocations
+GetAttribsLocations
 UniformMatrix2x3fv
 UniformMatrix3x2fv

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

@@ -58 +58 @@
 }
 
+#ifdef IN_GUEST
+static void crStateFreeProgramAttribsLocationCache(CRGLSLProgram* pProgram)
+{
+    if (pProgram->pAttribs) crFree(pProgram->pAttribs);
+
+    pProgram->pAttribs = NULL;
+    pProgram->cAttribs = 0;
+}
+#endif
+
 static void crStateFreeProgramAttribs(CRGLSLProgram* pProgram)
 {
@@ -77 +87 @@
     if (pProgram->currentState.pAttribs)
         crFree(pProgram->currentState.pAttribs);
+
+#ifdef IN_GUEST
+    crStateFreeProgramAttribsLocationCache(pProgram);
+
+    pProgram->bAttribsSynced = GL_FALSE;
+#endif
+
 }
 
@@ -361 +378 @@
     pProgram->pUniforms = NULL;
     pProgram->cUniforms = 0;
+
 #ifdef IN_GUEST
+    pProgram->pAttribs = NULL;
+    pProgram->cAttribs = 0;
+
     pProgram->bUniformsSynced = GL_FALSE;
+    pProgram->bAttribsSynced = GL_FALSE;
 #endif
 
@@ -600 +622 @@
         pProgram->activeState.pAttribs[i].name = crStrdup(pProgram->currentState.pAttribs[i].name);
     }
+
+#ifdef IN_GUEST
+    crStateFreeProgramAttribsLocationCache(pProgram);
+#endif
 
     crStateFreeProgramUniforms(pProgram);
@@ -770 +796 @@
     if (!pProgram)
     {
-        crWarning("Unknown program %d", program);
+        WARN(("Unknown program %d", program));
         return GL_FALSE;
     }
@@ -777 +803 @@
     return pProgram->bUniformsSynced;
 #else
-    crWarning("crStateIsProgramUniformsCached called on host side!!");
+    WARN(("crStateIsProgramUniformsCached called on host side!!"));
+    return GL_FALSE;
+#endif
+}
+
+DECLEXPORT(GLboolean) STATE_APIENTRY crStateIsProgramAttribsCached(GLuint program)
+{
+    CRGLSLProgram *pProgram = crStateGetProgramObj(program);
+
+    if (!pProgram)
+    {
+        WARN(("Unknown program %d", program));
+        return GL_FALSE;
+    }
+
+#ifdef IN_GUEST
+    return pProgram->bAttribsSynced;
+#else
+    WARN(("crStateIsProgramAttribsCached called on host side!!"));
     return GL_FALSE;
 #endif
@@ -856 +900 @@
 
     pProgram->bUniformsSynced = GL_TRUE;
+
+    CRASSERT((pCurrent-((char*)pData))==cbRead);
+    CRASSERT(cbRead==cbData);
+}
+
+DECLEXPORT(void) STATE_APIENTRY
+crStateGLSLProgramCacheAttribs(GLuint program, GLsizei cbData, GLvoid *pData)
+{
+    CRGLSLProgram *pProgram = crStateGetProgramObj(program);
+    char *pCurrent = pData;
+    GLsizei cbRead, cbName;
+    GLuint i;
+
+    if (!pProgram)
+    {
+        WARN(("Unknown program %d", program));
+        return;
+    }
+
+    if (pProgram->bAttribsSynced)
+    {
+        WARN(("crStateGLSLProgramCacheAttribs: this shouldn't happen!"));
+        crStateFreeProgramAttribsLocationCache(pProgram);
+    }
+
+    if (cbData<sizeof(GLsizei))
+    {
+        WARN(("crStateGLSLProgramCacheAttribs: data too short"));
+        return;
+    }
+
+    pProgram->cAttribs = ((GLsizei*)pCurrent)[0];
+    pCurrent += sizeof(GLsizei);
+    cbRead = sizeof(GLsizei);
+
+    crDebug("crStateGLSLProgramCacheAttribs: %i active attribs", pProgram->cAttribs);
+
+    if (pProgram->cAttribs)
+    {
+        pProgram->pAttribs = crAlloc(pProgram->cAttribs*sizeof(CRGLSLAttrib));
+        if (!pProgram->pAttribs)
+        {
+            WARN(("crStateGLSLProgramCacheAttribs: no memory"));
+            pProgram->cAttribs = 0;
+            return;
+        }
+    }
+
+    for (i=0; i<pProgram->cAttribs; ++i)
+    {
+        cbRead += sizeof(GLuint)+sizeof(GLsizei);
+        if (cbRead>cbData)
+        {
+            crWarning("crStateGLSLProgramCacheAttribs: out of data reading attrib %i", i);
+            return;
+        }
+        pProgram->pAttribs[i].index = ((GLint*)pCurrent)[0];
+        pCurrent += sizeof(GLint);
+        cbName = ((GLsizei*)pCurrent)[0];
+        pCurrent += sizeof(GLsizei);
+
+        cbRead += cbName;
+        if (cbRead>cbData)
+        {
+            crWarning("crStateGLSLProgramCacheAttribs: out of data reading attrib's name %i", i);
+            return;
+        }
+
+        pProgram->pAttribs[i].name = crStrndup(pCurrent, cbName);
+        pCurrent += cbName;
+
+        crDebug("crStateGLSLProgramCacheAttribs: attribs[%i]=%d, %s", i, pProgram->pAttribs[i].index, pProgram->pAttribs[i].name);
+    }
+
+    pProgram->bAttribsSynced = GL_TRUE;
 
     CRASSERT((pCurrent-((char*)pData))==cbRead);
@@ -991 +1110 @@
     CRASSERT((pCurrent-((char*)pData))==cbWritten);
 }
+
+static GLboolean crStateGLSLProgramCacheOneAttrib(GLuint location, GLsizei cbName, GLchar *pName,
+                                                   char **pCurrent, GLsizei *pcbWritten, GLsizei maxcbData)
+{
+    *pcbWritten += sizeof(GLint)+sizeof(GLsizei)+cbName;
+    if (*pcbWritten>maxcbData)
+    {
+        WARN(("crStateGLSLProgramCacheOneAttrib: buffer too small"));
+        crFree(pName);
+        return GL_FALSE;
+    }
+
+    crDebug("crStateGLSLProgramCacheOneAttrib: attrib[%i]=%s.", location, pName);
+
+    ((GLint*)*pCurrent)[0] = location;
+    *pCurrent += sizeof(GLint);
+    ((GLsizei*)*pCurrent)[0] = cbName;
+    *pCurrent += sizeof(GLsizei);
+    crMemcpy(*pCurrent, pName, cbName);
+    *pCurrent += cbName;
+
+    return GL_TRUE;
+}
+
+DECLEXPORT(void) STATE_APIENTRY
+crStateGLSLProgramCacheAttribs(GLuint program, GLsizei maxcbData, GLsizei *cbData, GLvoid *pData)
+{
+    CRGLSLProgram *pProgram = crStateGetProgramObj(program);
+    GLint maxAttribLen, activeAttribs=0, fakeAttribsCount, i, j;
+    char *pCurrent = pData;
+    GLsizei cbWritten;
+
+    if (!pProgram)
+    {
+        crWarning("Unknown program %d", program);
+        return;
+    }
+
+    diff_api.GetProgramiv(pProgram->hwid, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, &maxAttribLen);
+    diff_api.GetProgramiv(pProgram->hwid, GL_ACTIVE_ATTRIBUTES, &activeAttribs);
+
+    *cbData = 0;
+
+    cbWritten = sizeof(GLsizei);
+    if (cbWritten>maxcbData)
+    {
+        crWarning("crStateGLSLProgramCacheAttribs: buffer too small");
+        return;
+    }
+    ((GLsizei*)pCurrent)[0] = activeAttribs;
+    fakeAttribsCount = activeAttribs;
+    pCurrent += sizeof(GLsizei);
+
+    crDebug("crStateGLSLProgramCacheAttribs: %i active attribs", activeAttribs);
+
+    if (activeAttribs>0)
+    {
+        /*+8 to make sure our array attribs with higher indices and [] will fit in as well*/
+        GLchar *name = (GLchar *) crAlloc(maxAttribLen+8);
+        GLenum type;
+        GLint size;
+        GLsizei cbName;
+        GLint location;
+
+        if (!name)
+        {
+            crWarning("crStateGLSLProgramCacheAttribs: no memory");
+            return;
+        }
+
+        for (i=0; i<activeAttribs; ++i)
+        {
+            diff_api.GetActiveAttrib(pProgram->hwid, i, maxAttribLen, &cbName, &size, &type, name);
+            location = diff_api.GetAttribLocation(pProgram->hwid, name);
+
+            if (!crStateGLSLProgramCacheOneAttrib(location, cbName, name, &pCurrent, &cbWritten, maxcbData))
+                return;
+
+            /* Only one active attrib variable will be reported for a attrib array by glGetActiveAttrib,
+             * so we insert fake elements for other array elements.
+             */
+            if (size!=1)
+            {
+                char *pIndexStr = crStrchr(name, '[');
+                GLint firstIndex=1;
+                fakeAttribsCount += size;
+
+                crDebug("crStateGLSLProgramCacheAttribs: expanding array attrib, size=%i", size);
+
+                /*For array attribs it's valid to query location of 1st element as both attrib and attrib[0].
+                 *The name returned by glGetActiveAttrib is driver dependent,
+                 *atleast it's with [0] on win/ati and without [0] on linux/nvidia.
+                 */
+                if (!pIndexStr)
+                {
+                    pIndexStr = name+cbName;
+                    firstIndex=0;
+                }
+                else
+                {
+                    cbName = pIndexStr-name;
+                    if (!crStateGLSLProgramCacheOneAttrib(location, cbName, name, &pCurrent, &cbWritten, maxcbData))
+                        return;
+                }
+
+                for (j=firstIndex; j<size; ++j)
+                {
+                    sprintf(pIndexStr, "[%i]", j);
+                    cbName = crStrlen(name);
+
+                    location = diff_api.GetAttribLocation(pProgram->hwid, name);
+
+                    if (!crStateGLSLProgramCacheOneAttrib(location, cbName, name, &pCurrent, &cbWritten, maxcbData))
+                        return;
+                }
+            }
+        }
+
+        crFree(name);
+    }
+
+    if (fakeAttribsCount!=activeAttribs)
+    {
+        ((GLsizei*)pData)[0] = fakeAttribsCount;
+        crDebug("FakeCount %i", fakeAttribsCount);
+    }
+
+    *cbData = cbWritten;
+
+    CRASSERT((pCurrent-((char*)pData))==cbWritten);
+}
 #endif
 
@@ -1024 +1274 @@
 #else
     crWarning("crStateGetUniformLocation called on host side!!");
+    return -1;
+#endif
+}
+
+DECLEXPORT(GLint) STATE_APIENTRY crStateGetAttribLocation(GLuint program, const char * name)
+{
+#ifdef IN_GUEST
+    CRGLSLProgram *pProgram = crStateGetProgramObj(program);
+    GLint result=-1;
+    GLuint i;
+
+    if (!pProgram)
+    {
+        WARN(("Unknown program %d", program));
+        return -1;
+    }
+
+    if (!pProgram->bAttribsSynced)
+    {
+        WARN(("crStateGetAttribLocation called for uncached attribs"));
+        return -1;
+    }
+
+    for (i=0; i<pProgram->cAttribs; ++i)
+    {
+        if (!crStrcmp(name, pProgram->pAttribs[i].name))
+        {
+            result = pProgram->pAttribs[i].index;
+            break;
+        }
+    }
+
+    return result;
+#else
+    crWarning("crStateGetAttribLocation called on host side!!");
     return -1;
 #endif

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

@@ -377 +377 @@
 ValidateProgram
 BindAttribLocation
+GetAttribLocation
 GetUniformLocation
 CopyTexImage2D

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

@@ -226 +226 @@
     {
         cr_server.u32Caps = crServerVBoxParseNumerics(env, 0);
-        cr_server.u32Caps &= ~(CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA | CR_VBOX_CAP_CMDBLOCKS);
+        cr_server.u32Caps &= CR_VBOX_CAPS_ALL;
     }
     else
@@ -233 +233 @@
                 | CR_VBOX_CAP_CMDVBVA
                 | CR_VBOX_CAP_CMDBLOCKS
+#ifdef DEBUG_misha
+                | CR_VBOX_CAP_GETATTRIBSLOCATIONS
+#endif
                 ;
 
@@ -376 +379 @@
     {
         cr_server.u32Caps = crServerVBoxParseNumerics(env, 0);
-        cr_server.u32Caps &= ~(CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA | CR_VBOX_CAP_CMDBLOCKS);
+        cr_server.u32Caps &= CR_VBOX_CAPS_ALL;
     }
     else
@@ -383 +386 @@
                 | CR_VBOX_CAP_CMDVBVA
                 | CR_VBOX_CAP_CMDBLOCKS
+#ifdef DEBUG_misha
+                | CR_VBOX_CAP_GETATTRIBSLOCATIONS
+#endif
                 ;
     }

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_getshaders.c ¶

@@ -224 +224 @@
 }
 
+void SERVER_DISPATCH_APIENTRY
+crServerDispatchGetAttribsLocations(GLuint program, GLsizei maxcbData, GLsizei * cbData, GLvoid * pData)
+{
+    GLsizei *pLocal;
+
+    (void) cbData;
+    (void) pData;
+
+    pLocal = (GLsizei*) crAlloc(maxcbData+sizeof(GLsizei));
+    if (!pLocal)
+    {
+        GLsizei zero=0;
+        crServerReturnValue(&zero, sizeof(zero));
+    }
+
+    /* initial (fallback )value */
+    *pLocal = 0;
+    crStateGLSLProgramCacheAttribs(program, maxcbData, pLocal, (char*)&pLocal[1]);
+
+    crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
+    crFree(pLocal);
+}
+
 static GLint __GetUniformSize(GLuint program, GLint location)
 {

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

@@ -221 +221 @@
 DeleteObjectARB
 GetUniformsLocations
+GetAttribsLocations
 GetPolygonStipple
 Flush

trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.c ¶

@@ -336 +336 @@
         cr_unpackDispatch.GetUniformsLocations(program, maxcbData, NULL, NULL);
 }
+
+void crUnpackExtendGetAttribsLocations(void)
+{
+    GLuint program = READ_DATA(8, GLuint);
+    GLsizei maxcbData = READ_DATA(12, GLsizei);
+    SET_RETURN_PTR(16);
+    SET_WRITEBACK_PTR(24);
+    cr_unpackDispatch.GetAttribsLocations(program, maxcbData, NULL, NULL);
+}

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

@@ -169 +169 @@
 UnlockArraysEXT
 GetUniformsLocations
+GetAttribsLocations
 GetTexImage
 GetCompressedTexImageARB