Changeset 31808 in vbox for trunk

Timestamp:

Aug 20, 2010 9:40:40 AM (15 years ago)

Author:

vboxsync

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

65002

Message:

crOpenGL: resource sharing between contexts

Location:

trunk/src/VBox

Files:

• GuestHost/OpenGL/include/chromium.h (modified) (1 diff)
• GuestHost/OpenGL/include/cr_glstate.h (modified) (3 diffs)
• GuestHost/OpenGL/include/state/cr_bufferobject.h (modified) (4 diffs)
• GuestHost/OpenGL/include/state/cr_framebuffer.h (modified) (1 diff)
• GuestHost/OpenGL/include/state/cr_texture.h (modified) (2 diffs)
• GuestHost/OpenGL/packer/pack_client.c (modified) (3 diffs)
• GuestHost/OpenGL/state_tracker/state.h (modified) (1 diff)
• GuestHost/OpenGL/state_tracker/state_attrib.c (modified) (2 diffs)
• GuestHost/OpenGL/state_tracker/state_bufferobject.c (modified) (27 diffs)
• GuestHost/OpenGL/state_tracker/state_client.c (modified) (4 diffs)
• GuestHost/OpenGL/state_tracker/state_extensions_get.txt (modified) (2 diffs)
• GuestHost/OpenGL/state_tracker/state_framebuffer.c (modified) (19 diffs)
• GuestHost/OpenGL/state_tracker/state_get.txt (modified) (1 diff)
• GuestHost/OpenGL/state_tracker/state_init.c (modified) (5 diffs)
• GuestHost/OpenGL/state_tracker/state_snapshot.c (modified) (23 diffs)
• GuestHost/OpenGL/state_tracker/state_texdiff.c (modified) (6 diffs)
• GuestHost/OpenGL/state_tracker/state_texture.c (modified) (3 diffs)
• GuestHost/OpenGL/util/hash.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserver/crservice.cpp (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/get_components.py (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server.h (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_bufferobject.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_framebuffer.c (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_gentextures.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_get.py (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_glsl.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_lists.c (modified) (5 diffs)
• HostServices/SharedOpenGL/crserverlib/server_main.c (modified) (3 diffs)
• HostServices/SharedOpenGL/crserverlib/server_misc.c (modified) (1 diff)
• HostServices/SharedOpenGL/crserverlib/server_muralfbo.c (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_simpleget.py (modified) (2 diffs)
• HostServices/SharedOpenGL/crserverlib/server_special (modified) (1 diff)
• HostServices/SharedOpenGL/unpacker/unpack_arrays.c (modified) (1 diff)

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

@@ -684 +684 @@
 #define GL_REAL_RENDERER   0x8B25
 #define GL_REAL_EXTENSIONS 0x8B26
+
+/*Global resource ids sharing*/
+#define GL_SHARE_CONTEXT_RESOURCES_CR 0x8B27
 #endif
 

trunk/src/VBox/GuestHost/OpenGL/include/cr_glstate.h

@@ -98 +98 @@
     CRHashTable *textureTable;  /* all texture objects */
     CRHashTable *dlistTable;    /* all display lists */
+    CRHashTable *buffersTable;  /* vbo/pbo */
+    CRHashTable *fbTable;       /* frame buffers */
+    CRHashTable *rbTable;       /* render buffers */
+
     GLint refCount;
+    GLint id;                   /*unique shared state id, it's not always matching some existing context id!*/
+    GLint saveCount;
 } CRSharedState;
 
@@ -196 +202 @@
 #ifndef IN_GUEST
 DECLEXPORT(int32_t) crStateSaveContext(CRContext *pContext, PSSMHANDLE pSSM);
-DECLEXPORT(int32_t) crStateLoadContext(CRContext *pContext, PSSMHANDLE pSSM);
+DECLEXPORT(int32_t) crStateLoadContext(CRContext *pContext, CRHashTable * pCtxTable, PSSMHANDLE pSSM);
+DECLEXPORT(void)    crStateFreeShared(CRSharedState *s);
 #endif
 
@@ -219 +226 @@
                    GLenum format, GLenum type, GLvoid *pixels );
 
+DECLEXPORT(void) STATE_APIENTRY crStateShareContext(GLboolean value);
 #ifdef __cplusplus
 }

trunk/src/VBox/GuestHost/OpenGL/include/state/cr_bufferobject.h

@@ -10 +10 @@
 #include "cr_hash.h"
 #include "state/cr_statetypes.h"
+#include "state/cr_statefuncs.h"
 
 #ifdef __cplusplus
@@ -30 +31 @@
 typedef struct {
         GLuint refCount;
-        GLuint name;
+        GLuint id;
+    GLuint hwid;
         GLenum usage;
         GLenum access;
@@ -51 +53 @@
         CRBufferObject *nullBuffer;  /* name = 0 */
 
-        CRHashTable *buffers;
-
     GLboolean   bResyncNeeded;
 } CRBufferObjectState;
@@ -59 +59 @@
 DECLEXPORT(GLboolean) crStateIsBufferBound(GLenum target);
 
+DECLEXPORT(GLuint) STATE_APIENTRY crStateBufferHWIDtoID(GLuint hwid);
+DECLEXPORT(GLuint) STATE_APIENTRY crStateGetBufferHWID(GLuint id);
+
 #ifdef __cplusplus
 }

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

@@ -62 +62 @@
     CRFramebufferObject     *readFB, *drawFB;
     CRRenderbufferObject    *renderbuffer;
-    CRHashTable             *framebuffers;
-    CRHashTable             *renderbuffers;
 
     /* Indicates that we have to resend FBO data to GPU on first glMakeCurrent call with owning context */

trunk/src/VBox/GuestHost/OpenGL/include/state/cr_texture.h

@@ -61 +61 @@
 typedef struct {
     GLenum                 target;
-    GLuint                 name;
+    GLuint                 id;
+    GLuint                 hwid;
 
     /* The mipmap levels */
@@ -237 +238 @@
 DECLEXPORT(void) crStateDeleteTextureObject(CRTextureObj *tobj);
 
+DECLEXPORT(GLuint) STATE_APIENTRY crStateTextureHWIDtoID(GLuint hwid);
+DECLEXPORT(GLuint) STATE_APIENTRY crStateGetTextureHWID(GLuint id);
+DECLEXPORT(GLuint) STATE_APIENTRY crStateGetTextureObjHWID(CRTextureObj *tobj);
 
 #ifdef __cplusplus

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

@@ -662 +662 @@
     CRBufferObject *elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer;
     packet_length += sizeof(GLint);
-    if (elementsBuffer && elementsBuffer->name)
+    if (elementsBuffer && elementsBuffer->id)
     {
         /*@todo not sure it's possible, and not sure what to do*/
@@ -709 +709 @@
     CRBufferObject *elementsBuffer = crStateGetCurrent()->bufferobject.elementsBuffer;
     packet_length += sizeof(GLint);
-    if (elementsBuffer && elementsBuffer->name)
+    if (elementsBuffer && elementsBuffer->id)
     {
         /*@todo not sure it's possible, and not sure what to do*/
@@ -1029 +1029 @@
     if (cp->enabled)
     {
-        if (cp->buffer && cp->buffer->name)
+        if (cp->buffer && cp->buffer->id)
         {
             crWarning("crPackLockClientPointer called when there's VBO enabled!");

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

@@ -41 +41 @@
 
 void crStateBufferObjectDiff(CRBufferObjectBits *bb, CRbitvalue *bitID,
-                                                                                                                 CRContext *fromCtx, CRContext *toCtx);
+                             CRContext *fromCtx, CRContext *toCtx);
 
 void crStateBufferObjectSwitch(CRBufferObjectBits *bb, CRbitvalue *bitID, 
-                                                                                                                         CRContext *fromCtx, CRContext *toCtx);
-
+                               CRContext *fromCtx, CRContext *toCtx);
 
 /* These would normally be in cr_client.h */
 
 void crStateClientDiff(CRClientBits *cb, CRbitvalue *bitID, CRContext *from, CRContext *to);
-                                                                                         
-void crStateClientSwitch(CRClientBits *cb, CRbitvalue *bitID,   CRContext *from, CRContext *to);
+                                             
+void crStateClientSwitch(CRClientBits *cb, CRbitvalue *bitID,   CRContext *from, CRContext *to);
 
+void crStateGetTextureObjectAndImage(CRContext *g, GLenum texTarget, GLint level,
+                                     CRTextureObj **obj, CRTextureLevel **img);
 
-void
-crStateGetTextureObjectAndImage(CRContext *g, GLenum texTarget, GLint level,
-                                                                                                                                CRTextureObj **obj, CRTextureLevel **img);
-
+void crStateFreeBufferObject(void *data);
+void crStateFreeFBO(void *data);
+void crStateFreeRBO(void *data);
 #endif

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_attrib.c

@@ -83 +83 @@
 
 static void
-copy_texobj(CRTextureObj *dest, const CRTextureObj *src, GLboolean copyName)
+copy_texobj(CRTextureObj *dest, CRTextureObj *src, GLboolean copyName)
 {
     if (copyName)
-        dest->name = src->name;
+    {
+        dest->id = src->id;
+        dest->hwid = crStateGetTextureObjHWID(src);
+    }
+
     dest->borderColor = src->borderColor;
     dest->wrapS = src->wrapS;
@@ -1061 +1065 @@
             copy_texunit(&g->texture.unit[i], &tState->unit[i]);
             /* first, restore the bindings! */
-            g->texture.unit[i].currentTexture1D = crStateTextureGet(GL_TEXTURE_1D, tState->unit[i].Saved1D.name);
+            g->texture.unit[i].currentTexture1D = crStateTextureGet(GL_TEXTURE_1D, tState->unit[i].Saved1D.id);
             copy_texobj(g->texture.unit[i].currentTexture1D, &tState->unit[i].Saved1D, GL_FALSE);
-            g->texture.unit[i].currentTexture2D = crStateTextureGet(GL_TEXTURE_2D, tState->unit[i].Saved2D.name);
+            g->texture.unit[i].currentTexture2D = crStateTextureGet(GL_TEXTURE_2D, tState->unit[i].Saved2D.id);
             copy_texobj(g->texture.unit[i].currentTexture2D, &tState->unit[i].Saved2D, GL_FALSE);
 #ifdef CR_OPENGL_VERSION_1_2
-            g->texture.unit[i].currentTexture3D = crStateTextureGet(GL_TEXTURE_3D, tState->unit[i].Saved3D.name);
+            g->texture.unit[i].currentTexture3D = crStateTextureGet(GL_TEXTURE_3D, tState->unit[i].Saved3D.id);
             copy_texobj(g->texture.unit[i].currentTexture3D, &tState->unit[i].Saved3D, GL_FALSE);
 #endif
 #ifdef CR_ARB_texture_cube_map
-            g->texture.unit[i].currentTextureCubeMap = crStateTextureGet(GL_TEXTURE_CUBE_MAP_ARB, tState->unit[i].SavedCubeMap.name);
+            g->texture.unit[i].currentTextureCubeMap = crStateTextureGet(GL_TEXTURE_CUBE_MAP_ARB, tState->unit[i].SavedCubeMap.id);
             copy_texobj(g->texture.unit[i].currentTextureCubeMap, &tState->unit[i].SavedCubeMap, GL_FALSE);
 #endif
 #ifdef CR_NV_texture_rectangle
-            g->texture.unit[i].currentTextureRect = crStateTextureGet(GL_TEXTURE_CUBE_MAP_ARB, tState->unit[i].SavedRect.name);
+            g->texture.unit[i].currentTextureRect = crStateTextureGet(GL_TEXTURE_CUBE_MAP_ARB, tState->unit[i].SavedRect.id);
             copy_texobj(g->texture.unit[i].currentTextureRect, &tState->unit[i].SavedRect, GL_FALSE);
 #endif

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_bufferobject.c

@@ -18 +18 @@
     if (b) {
         b->refCount = 1;
-        b->name = name;
+        b->id = name;
+        b->hwid = name;
         b->usage = GL_STATIC_DRAW_ARB;
         b->access = GL_READ_WRITE_ARB;
@@ -34 +35 @@
     {
         case GL_ARRAY_BUFFER_ARB:
-            return b->arrayBuffer->name!=0;
+            return b->arrayBuffer->id!=0;
         case GL_ELEMENT_ARRAY_BUFFER_ARB:
-            return b->elementsBuffer->name!=0;
+            return b->elementsBuffer->id!=0;
 #ifdef CR_ARB_pixel_buffer_object
         case GL_PIXEL_PACK_BUFFER_ARB:
-            return b->packBuffer->name!=0;
+            return b->packBuffer->id!=0;
         case GL_PIXEL_UNPACK_BUFFER_ARB:
-            return b->unpackBuffer->name!=0;
+            return b->unpackBuffer->id!=0;
 #endif
         default:
@@ -97 +98 @@
 #endif
 
-    b->buffers = crAllocHashtable();
-
     b->bResyncNeeded = GL_FALSE;
 }
 
-
-static void crStateFreeBufferObject(void *data)
+void crStateFreeBufferObject(void *data)
 {
     CRBufferObject *pObj = (CRBufferObject *)data;
@@ -111 +109 @@
     if (diff_api.DeleteBuffersARB)
     {
-        diff_api.DeleteBuffersARB(1, &pObj->name);
+        diff_api.DeleteBuffersARB(1, &pObj->hwid);
     }
 #endif
@@ -121 +119 @@
 {
     CRBufferObjectState *b = &ctx->bufferobject;
-    crFreeHashtable(b->buffers, crStateFreeBufferObject);
     crFree(b->nullBuffer);
+}
+
+static void crStateCheckBufferHWIDCB(unsigned long key, void *data1, void *data2)
+{
+    CRBufferObject *pObj = (CRBufferObject *) data1;
+    crCheckIDHWID_t *pParms = (crCheckIDHWID_t*) data2;
+    (void) key;
+
+    if (pObj->hwid==pParms->hwid)
+        pParms->id = pObj->id;
+}
+
+DECLEXPORT(GLuint) STATE_APIENTRY crStateBufferHWIDtoID(GLuint hwid)
+{
+    CRContext *g = GetCurrentContext();
+    crCheckIDHWID_t parms;
+
+    parms.id = hwid;
+    parms.hwid = hwid;
+
+    crHashtableWalk(g->shared->buffersTable, crStateCheckBufferHWIDCB, &parms);
+    return parms.id;
+}
+
+DECLEXPORT(GLuint) STATE_APIENTRY crStateGetBufferHWID(GLuint id)
+{
+    CRContext *g = GetCurrentContext();
+    CRBufferObject *pObj = (CRBufferObject *) crHashtableSearch(g->shared->buffersTable, id);
+
+    return pObj ? pObj->hwid : 0;
 }
 
@@ -153 +180 @@
     }
     else {
-        newObj = (CRBufferObject *) crHashtableSearch(b->buffers, buffer);
+        newObj = (CRBufferObject *) crHashtableSearch(g->shared->buffersTable, buffer);
         if (!newObj) {
             newObj = AllocBufferObject(buffer);
@@ -160 +187 @@
                 return;
             }
-            crHashtableAdd( b->buffers, buffer, newObj );
+            crHashtableAdd( g->shared->buffersTable, buffer, newObj );
         }
     }
@@ -199 +226 @@
         /*we shouldn't reach this point*/
         CRASSERT(false);
-        crHashtableDelete(b->buffers, (unsigned long) oldObj->name, crStateFreeBufferObject);
+        crHashtableDelete(g->shared->buffersTable, (unsigned long) oldObj->id, crStateFreeBufferObject);
     }
 
@@ -236 +263 @@
         if (buffers[i]) {
             CRBufferObject *obj = (CRBufferObject *)
-                crHashtableSearch(b->buffers, buffers[i]);
+                crHashtableSearch(g->shared->buffersTable, buffers[i]);
             if (obj) {
                 if (obj == b->arrayBuffer) 
@@ -270 +297 @@
                 /* @todo check bindings with the vertex arrays */
 
-                crHashtableDelete(b->buffers, buffers[i], crStateFreeBufferObject);
+                crHashtableDelete(g->shared->buffersTable, buffers[i], crStateFreeBufferObject);
             }
         }
@@ -298 +325 @@
     }
 
-    start = crHashtableAllocKeys(b->buffers, n);
+    start = crHashtableAllocKeys(g->shared->buffersTable, n);
     if (start) {
         GLint i;
@@ -324 +351 @@
     }
 
-    if (buffer && crHashtableSearch(b->buffers, buffer))
+    if (buffer && crHashtableSearch(g->shared->buffersTable, buffer))
         return GL_TRUE;
     else
@@ -379 +406 @@
     }
 
-    if (obj->name == 0) {
+    if (obj->id == 0) {
         crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glBufferDataARB");
         return;
@@ -441 +468 @@
     }
 
-    if (obj->name == 0) {
+    if (obj->id == 0) {
         crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
                                  "glBufferSubDataARB");
@@ -495 +522 @@
     }
 
-    if (obj->name == 0) {
+    if (obj->id == 0) {
         crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION,
                                  "glGetBufferSubDataARB");
@@ -541 +568 @@
     }
 
-    if (obj->name == 0) {
+    if (obj->id == 0) {
         crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glMapBufferARB");
         return GL_FALSE;
@@ -589 +616 @@
     }
 
-    if (obj->name == 0) {
+    if (obj->id == 0) {
         crStateError(__LINE__, __FILE__, GL_INVALID_OPERATION, "glUnmapBufferARB");
         return GL_FALSE;
@@ -735 +762 @@
         if (from->arrayBuffer != to->arrayBuffer)
         {
-            GLuint bufferID = to->arrayBuffer ? to->arrayBuffer->name : 0;
+            GLuint bufferID = to->arrayBuffer ? to->arrayBuffer->hwid : 0;
             diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, bufferID);
             if (bSwitch)
@@ -778 +805 @@
         if (from->elementsBuffer != to->elementsBuffer)
         {
-            GLuint bufferID = to->elementsBuffer ? to->elementsBuffer->name : 0;
+            GLuint bufferID = to->elementsBuffer ? to->elementsBuffer->hwid : 0;
             diff_api.BindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, bufferID);
             if (bSwitch)
@@ -822 +849 @@
         if (from->packBuffer != to->packBuffer)
         {
-            GLuint bufferID = to->packBuffer ? to->packBuffer->name : 0;
+            GLuint bufferID = to->packBuffer ? to->packBuffer->hwid : 0;
             diff_api.BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, bufferID);
             if (bSwitch)
@@ -865 +892 @@
         if (from->unpackBuffer != to->unpackBuffer)
         {
-            GLuint bufferID = to->unpackBuffer ? to->unpackBuffer->name : 0;
+            GLuint bufferID = to->unpackBuffer ? to->unpackBuffer->hwid : 0;
             diff_api.BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, bufferID);
             if (bSwitch)
@@ -921 +948 @@
     CRBufferObject *pBufferObj = (CRBufferObject *) data1;
     CRBufferObjectState *pState = (CRBufferObjectState *) data2;
+
+    if (pBufferObj->id && !pBufferObj->hwid)
+    {
+        diff_api.GenBuffersARB(1, &pBufferObj->hwid);
+        CRASSERT(pBufferObj->hwid);
+    }
 
     if (pBufferObj->data)
@@ -931 +964 @@
           hurt performance." 
          */
-        diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, pBufferObj->name);
+        diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, pBufferObj->hwid);
         diff_api.BufferDataARB(GL_ARRAY_BUFFER_ARB, pBufferObj->size, pBufferObj->data, pBufferObj->usage);
 
@@ -946 +979 @@
  */
 void crStateBufferObjectSwitch(CRBufferObjectBits *bb, CRbitvalue *bitID, 
-                                                             CRContext *fromCtx, CRContext *toCtx)
+                               CRContext *fromCtx, CRContext *toCtx)
 {
     const CRBufferObjectState *from = &(fromCtx->bufferobject);
@@ -960 +993 @@
         GLboolean locked = toCtx->client.array.locked;
 
-        crHashtableWalk(to->buffers, crStateBufferObjectSyncCB, to);
+        crHashtableWalk(toCtx->shared->buffersTable, crStateBufferObjectSyncCB, to);
         to->bResyncNeeded = GL_FALSE;
 
         /*@todo, move to state_client.c*/
         cp = &toCtx->client.array.v;
-        if (cp->buffer->name || locked)
-        {
-            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+        if (cp->buffer->id || locked)
+        {
+            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
             diff_api.VertexPointer(cp->size, cp->type, cp->stride, cp->p);
         }
 
         cp = &toCtx->client.array.c;
-        if (cp->buffer->name || locked)
-        {
-            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+        if (cp->buffer->id || locked)
+        {
+            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
             diff_api.ColorPointer(cp->size, cp->type, cp->stride, cp->p);
         }
 
         cp = &toCtx->client.array.f;
-        if (cp->buffer->name || locked)
-        {
-            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+        if (cp->buffer->id || locked)
+        {
+            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
             diff_api.FogCoordPointerEXT(cp->type, cp->stride, cp->p);
         }
 
         cp = &toCtx->client.array.s;
-        if (cp->buffer->name || locked)
-        {
-            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+        if (cp->buffer->id || locked)
+        {
+            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
             diff_api.SecondaryColorPointerEXT(cp->size, cp->type, cp->stride, cp->p);
         }
 
         cp = &toCtx->client.array.e;
-        if (cp->buffer->name || locked)
-        {
-            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+        if (cp->buffer->id || locked)
+        {
+            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
             diff_api.EdgeFlagPointer(cp->stride, cp->p);
         }
 
         cp = &toCtx->client.array.i;
-        if (cp->buffer->name || locked)
-        {
-            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+        if (cp->buffer->id || locked)
+        {
+            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
             diff_api.IndexPointer(cp->type, cp->stride, cp->p);
         }
 
         cp = &toCtx->client.array.n;
-        if (cp->buffer->name || locked)
-        {
-            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+        if (cp->buffer->id || locked)
+        {
+            diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
             diff_api.NormalPointer(cp->type, cp->stride, cp->p);
         }
@@ -1016 +1049 @@
         {
             cp = &toCtx->client.array.t[i];
-            if (cp->buffer->name || locked)
+            if (cp->buffer->id || locked)
             {
                 if (diff_api.ActiveTextureARB)
                     diff_api.ActiveTextureARB(i+GL_TEXTURE0_ARB);
-                diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+                diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
                 diff_api.TexCoordPointer(cp->size, cp->type, cp->stride, cp->p);
             }
@@ -1032 +1065 @@
         {
             cp = &toCtx->client.array.a[i];
-            if (cp->buffer->name || locked)
+            if (cp->buffer->id || locked)
             {
-                diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->name);
+                diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, cp->buffer->hwid);
                 diff_api.VertexAttribPointerARB(i, cp->size, cp->type, cp->normalized, cp->stride, cp->p);
             }
         }
 #endif
-        diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, to->arrayBuffer->name);
-        diff_api.BindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, to->elementsBuffer->name);
+        diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, to->arrayBuffer->hwid);
+        diff_api.BindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, to->elementsBuffer->hwid);
 #ifdef CR_ARB_pixel_buffer_object
-        diff_api.BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, to->packBuffer->name);
-        diff_api.BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, to->unpackBuffer->name);
+        diff_api.BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, to->packBuffer->hwid);
+        diff_api.BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, to->unpackBuffer->hwid);
 #endif
     }

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

@@ -1517 +1517 @@
 
 /*Returns if the given clientpointer could be used on server side directly*/
-#define CRSTATE_IS_SERVER_CP(cp) (!(cp).enabled || !(cp).p || ((cp).buffer && (cp).buffer->name) || ((cp).locked))
+#define CRSTATE_IS_SERVER_CP(cp) (!(cp).enabled || !(cp).p || ((cp).buffer && (cp).buffer->id) || ((cp).locked))
 
 static void crStateDumpClientPointer(CRClientPointer *cp, const char *name, int i)
@@ -1524 +1524 @@
   {
     crDebug("CP(%s): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i %s",
-            name, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1, (int)cp->locked,
+            name, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->id:-1, (int)cp->locked,
             CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!");
   }
@@ -1530 +1530 @@
   {
     crDebug("CP(%s%i): enabled:%d ptr:%p buffer:%p buffer.name:%i locked: %i %s",
-            name, i, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->name:-1, (int)cp->locked,
+            name, i, cp->enabled, cp->p, cp->buffer, cp->buffer? cp->buffer->id:-1, (int)cp->locked,
             CRSTATE_IS_SERVER_CP(*cp) ? "":"!FAIL!");
   }
@@ -1612 +1612 @@
     CRContext *g = GetCurrentContext();
     if (g->bufferobject.elementsBuffer &&
-            g->bufferobject.elementsBuffer->name > 0)
+            g->bufferobject.elementsBuffer->id > 0)
         return GL_TRUE;
     else

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_extensions_get.txt

@@ -56 +56 @@
 
 GLboolean GL_TEXTURE_CUBE_MAP_ARB GL_ARB_texture_cube_map g->texture.unit[g->texture.curTextureUnit].enabledCubeMap
-GLint GL_TEXTURE_BINDING_CUBE_MAP_ARB GL_ARB_texture_cube_map g->texture.unit[g->texture.curTextureUnit].currentTextureCubeMap->name
+GLint GL_TEXTURE_BINDING_CUBE_MAP_ARB GL_ARB_texture_cube_map g->texture.unit[g->texture.curTextureUnit].currentTextureCubeMap->id
 GLint GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB GL_ARB_texture_cube_map g->limits.maxCubeMapTextureSize
 
 # GL_NV_texture_rectangle
 GLboolean GL_TEXTURE_RECTANGLE_NV GL_NV_texture_rectangle g->texture.unit[g->texture.curTextureUnit].enabledRect
-GLint GL_TEXTURE_BINDING_RECTANGLE_NV GL_NV_texture_rectangle g->texture.unit[g->texture.curTextureUnit].currentTextureRect->name
+GLint GL_TEXTURE_BINDING_RECTANGLE_NV GL_NV_texture_rectangle g->texture.unit[g->texture.curTextureUnit].currentTextureRect->id
 GLint GL_MAX_RECTANGLE_TEXTURE_SIZE_NV GL_NV_texture_rectangle g->limits.maxRectTextureSize
 
@@ -131 +131 @@
 
 # GL_ARB_vertex_buffer_object
-GLuint GL_ARRAY_BUFFER_BINDING_ARB GL_ARB_vertex_buffer_object g->bufferobject.arrayBuffer->name
-GLuint GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB GL_ARB_vertex_buffer_object g->bufferobject.elementsBuffer->name
+GLuint GL_ARRAY_BUFFER_BINDING_ARB GL_ARB_vertex_buffer_object g->bufferobject.arrayBuffer->id
+GLuint GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB GL_ARB_vertex_buffer_object g->bufferobject.elementsBuffer->id
 
 # GL_ARB_pixel_buffer_object
-GLuint GL_PIXEL_PACK_BUFFER_BINDING_ARB GL_ARB_pixel_buffer_object g->bufferobject.packBuffer->name
-GLuint GL_PIXEL_UNPACK_BUFFER_BINDING_ARB GL_ARB_pixel_buffer_object g->bufferobject.unpackBuffer->name
+GLuint GL_PIXEL_PACK_BUFFER_BINDING_ARB GL_ARB_pixel_buffer_object g->bufferobject.packBuffer->id
+GLuint GL_PIXEL_UNPACK_BUFFER_BINDING_ARB GL_ARB_pixel_buffer_object g->bufferobject.unpackBuffer->id

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

@@ -37 +37 @@
     fbo->drawFB = NULL;
     fbo->renderbuffer = NULL;
-    fbo->framebuffers = crAllocHashtable();
-    fbo->renderbuffers = crAllocHashtable();
     fbo->bResyncNeeded = GL_FALSE;
 }
 
-static void crStateFreeFBO(void *data)
+void crStateFreeFBO(void *data)
 {
     CRFramebufferObject *pObj = (CRFramebufferObject *)data;
@@ -56 +54 @@
 }
 
-static void crStateFreeRBO(void *data)
+void crStateFreeRBO(void *data)
 {
     CRRenderbufferObject *pObj = (CRRenderbufferObject *)data;
@@ -78 +76 @@
     fbo->drawFB = NULL;
     fbo->renderbuffer = NULL;
-
-    crFreeHashtable(fbo->framebuffers, crStateFreeFBO);
-    crFreeHashtable(fbo->renderbuffers, crStateFreeRBO);
 }
 
@@ -94 +89 @@
     if (renderbuffer)
     {
-        fbo->renderbuffer = (CRRenderbufferObject*) crHashtableSearch(fbo->renderbuffers, renderbuffer);
+        fbo->renderbuffer = (CRRenderbufferObject*) crHashtableSearch(g->shared->rbTable, renderbuffer);
         if (!fbo->renderbuffer)
         {
@@ -102 +97 @@
             fbo->renderbuffer->hwid = renderbuffer;
             fbo->renderbuffer->internalformat = GL_RGBA;
-            crHashtableAdd(fbo->renderbuffers, renderbuffer, fbo->renderbuffer);
+            crHashtableAdd(g->shared->rbTable, renderbuffer, fbo->renderbuffer);
         }
     }
@@ -161 +156 @@
         {
             CRRenderbufferObject *rbo;
-            rbo = (CRRenderbufferObject*) crHashtableSearch(fbo->renderbuffers, renderbuffers[i]);
+            rbo = (CRRenderbufferObject*) crHashtableSearch(g->shared->rbTable, renderbuffers[i]);
             if (rbo)
             {
@@ -173 +168 @@
                 crStateCheckFBOAttachments(fbo->drawFB, renderbuffers[i], GL_DRAW_FRAMEBUFFER);
 
-                crHashtableDelete(fbo->renderbuffers, renderbuffers[i], crStateFreeRBO);
+                crHashtableDelete(g->shared->rbTable, renderbuffers[i], crStateFreeRBO);
             }
         }
@@ -291 +286 @@
     if (framebuffer)
     {
-        pFBO = (CRFramebufferObject*) crHashtableSearch(fbo->framebuffers, framebuffer);
+        pFBO = (CRFramebufferObject*) crHashtableSearch(g->shared->fbTable, framebuffer);
         if (!pFBO)
         {
@@ -299 +294 @@
             pFBO->hwid = framebuffer;
             crStateInitFrameBuffer(pFBO);
-            crHashtableAdd(fbo->framebuffers, framebuffer, pFBO);
+            crHashtableAdd(g->shared->fbTable, framebuffer, pFBO);
         }
     }
@@ -338 +333 @@
         {
             CRFramebufferObject *fb;
-            fb = (CRFramebufferObject*) crHashtableSearch(fbo->framebuffers, framebuffers[i]);
+            fb = (CRFramebufferObject*) crHashtableSearch(g->shared->fbTable, framebuffers[i]);
             if (fb)
             {
@@ -349 +344 @@
                     fbo->drawFB = NULL;
                 }
-                crHashtableDelete(fbo->framebuffers, framebuffers[i], crStateFreeFBO);
+                crHashtableDelete(g->shared->fbTable, framebuffers[i], crStateFreeFBO);
             }
         }
@@ -555 +550 @@
     }
 
-    rb = (CRRenderbufferObject*) crHashtableSearch(fbo->renderbuffers, renderbuffer);
+    rb = (CRRenderbufferObject*) crHashtableSearch(g->shared->rbTable, renderbuffer);
     CRSTATE_FBO_CHECKERR(!rb, GL_INVALID_OPERATION, "rb doesn't exist");
 
@@ -639 +634 @@
             if (tobj)
             {
+                CRASSERT(!tobj->id || tobj->hwid);
+
                 switch (tobj->target)
                 {
                     case GL_TEXTURE_1D:
-                        diff_api.FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT, ap, tobj->target, pAP->name, pAP->level);
+                        diff_api.FramebufferTexture1DEXT(GL_FRAMEBUFFER_EXT, ap, tobj->target, crStateGetTextureObjHWID(tobj), pAP->level);
                         break;
                     case GL_TEXTURE_2D:
                     case GL_TEXTURE_RECTANGLE_ARB:
-                        diff_api.FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, ap, tobj->target, pAP->name, pAP->level);
+                        diff_api.FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, ap, tobj->target, crStateGetTextureObjHWID(tobj), pAP->level);
                         break;
                     case GL_TEXTURE_CUBE_MAP_ARB:
-                        diff_api.FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, ap, pAP->face, pAP->name, pAP->level);
+                        diff_api.FramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, ap, pAP->face, crStateGetTextureObjHWID(tobj), pAP->level);
                         break;
                     case GL_TEXTURE_3D:
-                        diff_api.FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT, ap, tobj->target, pAP->name, pAP->level, pAP->zoffset);
+                        diff_api.FramebufferTexture3DEXT(GL_FRAMEBUFFER_EXT, ap, tobj->target, crStateGetTextureObjHWID(tobj), pAP->level, pAP->zoffset);
                         break;
                     default:
@@ -664 +661 @@
             break;
         case GL_RENDERBUFFER_EXT:
-            pRBO = (CRRenderbufferObject*) crHashtableSearch(ctx->framebufferobject.renderbuffers, pAP->name);
+            pRBO = (CRRenderbufferObject*) crHashtableSearch(ctx->shared->rbTable, pAP->name);
             diff_api.FramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, ap, GL_RENDERBUFFER_EXT, pRBO->hwid);
             break;
@@ -700 +697 @@
         to->framebufferobject.bResyncNeeded = GL_FALSE;
 
-        crHashtableWalk(to->framebufferobject.renderbuffers, crStateSyncRenderbuffersCB, NULL);
-        crHashtableWalk(to->framebufferobject.framebuffers, crStateSyncFramebuffersCB, to);
+        crHashtableWalk(to->shared->rbTable, crStateSyncRenderbuffersCB, NULL);
+        crHashtableWalk(to->shared->fbTable, crStateSyncFramebuffersCB, to);
 
         if (to->framebufferobject.drawFB==to->framebufferobject.readFB)
@@ -751 +748 @@
 {
     CRContext *g = GetCurrentContext();
-    CRFramebufferObject *pFBO = (CRFramebufferObject*) crHashtableSearch(g->framebufferobject.framebuffers, id);
+    CRFramebufferObject *pFBO = (CRFramebufferObject*) crHashtableSearch(g->shared->fbTable, id);
 
     return pFBO ? pFBO->hwid : 0;
@@ -759 +756 @@
 {
     CRContext *g = GetCurrentContext();
-    CRRenderbufferObject *pRBO = (CRRenderbufferObject*) crHashtableSearch(g->framebufferobject.renderbuffers, id);
+    CRRenderbufferObject *pRBO = (CRRenderbufferObject*) crHashtableSearch(g->shared->rbTable, id);
 
     return pRBO ? pRBO->hwid : 0;
@@ -792 +789 @@
     parms.hwid = hwid;
 
-    crHashtableWalk(g->framebufferobject.framebuffers, crStateCheckFBOHWIDCB, &parms);
+    crHashtableWalk(g->shared->fbTable, crStateCheckFBOHWIDCB, &parms);
     return parms.id;
 }
@@ -804 +801 @@
     parms.hwid = hwid;
 
-    crHashtableWalk(g->framebufferobject.renderbuffers, crStateCheckRBOHWIDCB, &parms);
+    crHashtableWalk(g->shared->rbTable, crStateCheckRBOHWIDCB, &parms);
     return parms.id;
 }

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

@@ -171 +171 @@
 GLenum    GL_PERSPECTIVE_CORRECTION_HINT  g->hint.perspectiveCorrection
 
-GLint     GL_TEXTURE_BINDING_1D g->texture.unit[g->texture.curTextureUnit].currentTexture1D->name
-GLint     GL_TEXTURE_BINDING_2D g->texture.unit[g->texture.curTextureUnit].currentTexture2D->name
-GLint     GL_TEXTURE_BINDING_3D g->texture.unit[g->texture.curTextureUnit].currentTexture3D->name
+GLint     GL_TEXTURE_BINDING_1D g->texture.unit[g->texture.curTextureUnit].currentTexture1D->id
+GLint     GL_TEXTURE_BINDING_2D g->texture.unit[g->texture.curTextureUnit].currentTexture2D->id
+GLint     GL_TEXTURE_BINDING_3D g->texture.unit[g->texture.curTextureUnit].currentTexture3D->id
 GLenum    GL_TEXTURE_ENV_MODE   g->texture.unit[g->texture.curTextureUnit].envMode
 

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_init.c

@@ -19 +19 @@
 GLboolean g_availableContexts[CR_MAX_CONTEXTS];
 
+static CRSharedState *gSharedState=NULL;
+
 static CRContext *defaultContext = NULL;
 
@@ -34 +36 @@
         s->textureTable = crAllocHashtable();
         s->dlistTable = crAllocHashtable();
+        s->buffersTable = crAllocHashtable();
+        s->fbTable = crAllocHashtable();
+        s->rbTable = crAllocHashtable();
         s->refCount = 1; /* refcount is number of contexts using this state */
+        s->saveCount = 0;
     }
     return s;
@@ -48 +54 @@
 {
 #ifndef IN_GUEST
-    diff_api.DeleteTextures(1, &((CRTextureObj *)texObj)->name);
+    diff_api.DeleteTextures(1, &((CRTextureObj *)texObj)->hwid);
 #endif
     crStateDeleteTextureObject((CRTextureObj *) texObj);
 }
-
 
 /**
  * Decrement shared state's refcount and delete when it hits zero.
  */
-static void
+DECLEXPORT(void)
 crStateFreeShared(CRSharedState *s)
 {
     s->refCount--;
     if (s->refCount <= 0) {
+        if (s==gSharedState)
+        {
+            gSharedState = NULL;
+        }
         crFreeHashtable(s->textureTable, DeleteTextureCallback);
         crFreeHashtable(s->dlistTable, crFree); /* call crFree for each entry */
+        crFreeHashtable(s->buffersTable, crStateFreeBufferObject);
+        crFreeHashtable(s->fbTable, crStateFreeFBO);
+        crFreeHashtable(s->rbTable, crStateFreeRBO);
         crFree(s);
     }
 }
 
+DECLEXPORT(void) STATE_APIENTRY
+crStateShareContext(GLboolean value)
+{
+    CRContext *pCtx = GetCurrentContext();
+    CRASSERT(pCtx && pCtx->shared);
+
+    if (value)
+    {
+        if (pCtx->shared == gSharedState)
+        {
+            return;
+        }
+
+        crDebug("Context(%i) shared", pCtx->id);
+
+        if (!gSharedState)
+        {
+            gSharedState = pCtx->shared;
+        }
+        else
+        {
+            crStateFreeShared(pCtx->shared);
+            pCtx->shared = gSharedState;
+            gSharedState->refCount++;
+        }
+    }
+    else
+    {
+        if (pCtx->shared != gSharedState)
+        {
+            return;
+        }
+
+        crDebug("Context(%i) unshared", pCtx->id);
+
+        if (gSharedState->refCount==1)
+        {
+            gSharedState = NULL;
+        }
+        else
+        {
+            pCtx->shared = crStateAllocShared();
+            pCtx->shared->id = pCtx->id;
+            crStateFreeShared(gSharedState);
+        }
+    }
+}
 
 /*
@@ -101 +160 @@
     else {
         ctx->shared = crStateAllocShared();
+        ctx->shared->id = ctx->id;
     }
 
@@ -179 +239 @@
     }
 
+/*
+    if (ctx->id>0)
+    {
+        crStateShareContext(GL_TRUE);
+    }
+*/
+
     return ctx;
 }

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_snapshot.c

@@ -69 +69 @@
     CRASSERT(pTexture && pSSM);
 
-    crDebug("crStateSaveTextureObjData %u. START", pTexture->name);
+    crDebug("crStateSaveTextureObjData %u. START", pTexture->id);
 
     for (face = 0; face < 6; face++) {
@@ -98 +98 @@
                 if (!bound)
                 {
-                    diff_api.BindTexture(pTexture->target, pTexture->name);
+                    diff_api.BindTexture(pTexture->target, pTexture->hwid);
                     bound = GL_TRUE;
                 }
@@ -164 +164 @@
     }
 
-    crDebug("crStateSaveTextureObjData %u. END", pTexture->name);
+    crDebug("crStateSaveTextureObjData %u. END", pTexture->id);
 
     return VINF_SUCCESS;
@@ -251 +251 @@
      */
     if (pTexture)
-        return SSMR3PutU32(pSSM, pTexture->name);
+        return SSMR3PutU32(pSSM, pTexture->id);
     else
         return VINF_SUCCESS;
@@ -488 +488 @@
         CRASSERT(rc == VINF_SUCCESS);
     }
-    else if (pBufferObj->name!=0 && pBufferObj->size>0)
-    {
-        diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, pBufferObj->name);
+    else if (pBufferObj->id!=0 && pBufferObj->size>0)
+    {
+        diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, pBufferObj->hwid);
         pBufferObj->pointer = diff_api.MapBufferARB(GL_ARRAY_BUFFER_ARB, GL_READ_ONLY_ARB);
         rc = SSMR3PutMem(pSSM, &pBufferObj->pointer, sizeof(pBufferObj->pointer));
@@ -856 +856 @@
     cp = crStateGetClientPointerByIndex(index, pArrays);
 
-    rc = SSMR3PutU32(pSSM, cp->buffer->name);
+    rc = SSMR3PutU32(pSSM, cp->buffer->id);
     AssertRCReturn(rc, rc);
 
@@ -881 +881 @@
     rc = SSMR3GetU32(pSSM, &ui);
     AssertRCReturn(rc, rc);
-    cp->buffer = ui==0 ? pContext->bufferobject.nullBuffer : crHashtableSearch(pContext->bufferobject.buffers, ui);
+    cp->buffer = ui==0 ? pContext->bufferobject.nullBuffer : crHashtableSearch(pContext->shared->buffersTable, ui);
 
 #ifdef CR_EXT_compiled_vertex_array
@@ -1011 +1011 @@
     int32_t rc, i;
     uint32_t ui32, j;
+    GLboolean bSaveShared = GL_TRUE;
 
     CRASSERT(pContext && pSSM);
@@ -1022 +1023 @@
     if (crHashtableNumElements(pContext->program.programHash)>0)
         crDebug("Saving state with %d programs", crHashtableNumElements(pContext->program.programHash));
+
+    rc = SSMR3PutS32(pSSM, pContext->shared->id);
+    if (pContext->shared->refCount>1)
+    {
+        bSaveShared = pContext->shared->saveCount==0;
+
+        ++pContext->shared->saveCount;
+        if (pContext->shared->saveCount == pContext->shared->refCount)
+        {
+            pContext->shared->saveCount=0;
+        }
+    }
 
     /* Save transform state */
@@ -1071 +1084 @@
 
     /* Save shared textures */
-    CRASSERT(pContext->shared && pContext->shared->textureTable);
-    ui32 = crHashtableNumElements(pContext->shared->textureTable);
-    rc = SSMR3PutU32(pSSM, ui32);
-    AssertRCReturn(rc, rc);
-    crHashtableWalk(pContext->shared->textureTable, crStateSaveSharedTextureCB, pSSM);
+    if (bSaveShared)
+    {
+        CRASSERT(pContext->shared && pContext->shared->textureTable);
+        ui32 = crHashtableNumElements(pContext->shared->textureTable);
+        rc = SSMR3PutU32(pSSM, ui32);
+        AssertRCReturn(rc, rc);
+        crHashtableWalk(pContext->shared->textureTable, crStateSaveSharedTextureCB, pSSM);
 
 #ifdef CR_STATE_NO_TEXTURE_IMAGE_STORE
-    /* Restore previous texture bindings via diff_api */
-    if (ui32)
-    {
-        CRTextureUnit *pTexUnit;
-
-        pTexUnit = &pContext->texture.unit[pContext->texture.curTextureUnit];
-
-        diff_api.BindTexture(GL_TEXTURE_1D, pTexUnit->currentTexture1D->name);
-        diff_api.BindTexture(GL_TEXTURE_2D, pTexUnit->currentTexture2D->name);
-        diff_api.BindTexture(GL_TEXTURE_3D, pTexUnit->currentTexture3D->name);
+        /* Restore previous texture bindings via diff_api */
+        if (ui32)
+        {
+            CRTextureUnit *pTexUnit;
+
+            pTexUnit = &pContext->texture.unit[pContext->texture.curTextureUnit];
+
+            diff_api.BindTexture(GL_TEXTURE_1D, pTexUnit->currentTexture1D->hwid);
+            diff_api.BindTexture(GL_TEXTURE_2D, pTexUnit->currentTexture2D->hwid);
+            diff_api.BindTexture(GL_TEXTURE_3D, pTexUnit->currentTexture3D->hwid);
 #ifdef CR_ARB_texture_cube_map
-        diff_api.BindTexture(GL_TEXTURE_CUBE_MAP_ARB, pTexUnit->currentTextureCubeMap->name);
+            diff_api.BindTexture(GL_TEXTURE_CUBE_MAP_ARB, pTexUnit->currentTextureCubeMap->hwid);
 #endif
 #ifdef CR_NV_texture_rectangle
-        diff_api.BindTexture(GL_TEXTURE_RECTANGLE_NV, pTexUnit->currentTextureRect->name);
-#endif
-    }
-#endif
+            diff_api.BindTexture(GL_TEXTURE_RECTANGLE_NV, pTexUnit->currentTextureRect->hwid);
+#endif
+        }
+#endif
+    }
 
     /* Save current texture pointers */
@@ -1168 +1184 @@
 #ifdef CR_ARB_vertex_buffer_object
     /* Save buffer objects */
-    ui32 = crHashtableNumElements(pContext->bufferobject.buffers);
+    ui32 = bSaveShared? crHashtableNumElements(pContext->shared->buffersTable):0;
     rc = SSMR3PutU32(pSSM, ui32);
     AssertRCReturn(rc, rc);
+
     /* Save default one*/
     crStateSaveBufferObjectCB(0, pContext->bufferobject.nullBuffer, pSSM);
-    /* Save all the rest */
-    crHashtableWalk(pContext->bufferobject.buffers, crStateSaveBufferObjectCB, pSSM);
+
+    if (bSaveShared)
+    {
+        /* Save all the rest */
+        crHashtableWalk(pContext->shared->buffersTable, crStateSaveBufferObjectCB, pSSM);
+    }
+
     /* Restore binding */
-    diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, pContext->bufferobject.arrayBuffer->name);
+    diff_api.BindBufferARB(GL_ARRAY_BUFFER_ARB, pContext->bufferobject.arrayBuffer->hwid);
+
     /* Save pointers */
-    rc = SSMR3PutU32(pSSM, pContext->bufferobject.arrayBuffer->name);
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutU32(pSSM, pContext->bufferobject.elementsBuffer->name);
+    rc = SSMR3PutU32(pSSM, pContext->bufferobject.arrayBuffer->id);
+    AssertRCReturn(rc, rc);
+    rc = SSMR3PutU32(pSSM, pContext->bufferobject.elementsBuffer->id);
     AssertRCReturn(rc, rc);
 #ifdef CR_ARB_pixel_buffer_object
-    rc = SSMR3PutU32(pSSM, pContext->bufferobject.packBuffer->name);
-    AssertRCReturn(rc, rc);
-    rc = SSMR3PutU32(pSSM, pContext->bufferobject.unpackBuffer->name);
+    rc = SSMR3PutU32(pSSM, pContext->bufferobject.packBuffer->id);
+    AssertRCReturn(rc, rc);
+    rc = SSMR3PutU32(pSSM, pContext->bufferobject.unpackBuffer->id);
     AssertRCReturn(rc, rc);
 #endif
@@ -1226 +1249 @@
 #ifdef CR_EXT_framebuffer_object
     /* Save FBOs */
-    ui32 = crHashtableNumElements(pContext->framebufferobject.framebuffers);
-    rc = SSMR3PutU32(pSSM, ui32);
-    AssertRCReturn(rc, rc);
-    crHashtableWalk(pContext->framebufferobject.framebuffers, crStateSaveFramebuffersCB, pSSM);
-    ui32 = crHashtableNumElements(pContext->framebufferobject.renderbuffers);
-    rc = SSMR3PutU32(pSSM, ui32);
-    AssertRCReturn(rc, rc);
-    crHashtableWalk(pContext->framebufferobject.renderbuffers, crStateSaveRenderbuffersCB, pSSM);
+    if (bSaveShared)
+    {
+        ui32 = crHashtableNumElements(pContext->shared->fbTable);
+        rc = SSMR3PutU32(pSSM, ui32);
+        AssertRCReturn(rc, rc);
+        crHashtableWalk(pContext->shared->fbTable, crStateSaveFramebuffersCB, pSSM);
+        ui32 = crHashtableNumElements(pContext->shared->rbTable);
+        rc = SSMR3PutU32(pSSM, ui32);
+        AssertRCReturn(rc, rc);
+        crHashtableWalk(pContext->shared->rbTable, crStateSaveRenderbuffersCB, pSSM);
+    }
     rc = SSMR3PutU32(pSSM, pContext->framebufferobject.drawFB?pContext->framebufferobject.drawFB->id:0);
     AssertRCReturn(rc, rc);
@@ -1299 +1325 @@
 }
 
+typedef struct _crFindSharedCtxParms {
+    CRContext *pSrcCtx, *pDstCtx;
+} crFindSharedCtxParms_t;
+
+static void crStateFindSharedCB(unsigned long key, void *data1, void *data2)
+{
+    CRContext *pContext = (CRContext *) data1;
+    crFindSharedCtxParms_t *pParms = (crFindSharedCtxParms_t *) data2;
+    (void) key;
+
+    if (pContext!=pParms->pSrcCtx && pContext->shared->id==pParms->pSrcCtx->shared->id)
+    {
+        pParms->pDstCtx->shared = pContext->shared;
+    }
+}
+
 #define SLC_COPYPTR(ptr) pTmpContext->ptr = pContext->ptr
 #define SLC_ASSSERT_NULL_PTR(ptr) CRASSERT(!pContext->ptr)
 
-int32_t crStateLoadContext(CRContext *pContext, PSSMHANDLE pSSM)
+int32_t crStateLoadContext(CRContext *pContext, CRHashTable * pCtxTable, PSSMHANDLE pSSM)
 {
     CRContext* pTmpContext;
@@ -1308 +1350 @@
     uint32_t uiNumElems, ui, k;
     unsigned long key;
+    GLboolean bLoadShared = GL_TRUE;
 
     CRASSERT(pContext && pSSM);
@@ -1319 +1362 @@
     AssertRCReturn(rc, rc);
 
-    SLC_COPYPTR(shared);
+    /* Deal with shared state */
+    {
+        crFindSharedCtxParms_t parms;
+
+        rc = SSMR3GetS32(pSSM, &pContext->shared->id);
+        AssertRCReturn(rc, rc);
+
+        pTmpContext->shared = NULL;
+        parms.pSrcCtx = pContext;
+        parms.pDstCtx = pTmpContext;
+        crHashtableWalk(pCtxTable, crStateFindSharedCB, &parms);
+
+        if (pTmpContext->shared)
+        {
+            CRASSERT(pContext->shared->refCount==1 && pTmpContext->shared->refCount>1);
+            bLoadShared = GL_FALSE;
+            crStateFreeShared(pContext->shared);
+            pContext->shared = NULL;
+        }
+        else
+        {
+            SLC_COPYPTR(shared);
+        }
+    }
+
     SLC_COPYPTR(flush_func);
     SLC_COPYPTR(flush_arg);
@@ -1341 +1408 @@
 
 #ifdef CR_ARB_vertex_buffer_object
-    SLC_COPYPTR(bufferobject.buffers);
     SLC_COPYPTR(bufferobject.nullBuffer);
 #endif
@@ -1449 +1515 @@
     }
 
-#ifdef CR_EXT_framebuffer_object
-    SLC_COPYPTR(framebufferobject.framebuffers);
-    SLC_COPYPTR(framebufferobject.renderbuffers);
-#endif
-
 #ifdef CR_OPENGL_VERSION_2_0
     SLC_COPYPTR(glsl.shaders);
@@ -1516 +1577 @@
 #endif
 
-    /* Load shared textures */
-    CRASSERT(pContext->shared && pContext->shared->textureTable);
-    rc = SSMR3GetU32(pSSM, &uiNumElems);
-    AssertRCReturn(rc, rc);
-    for (ui=0; ui<uiNumElems; ++ui)
-    {
-        CRTextureObj *pTexture;
-
-        rc = SSMR3GetMem(pSSM, &key, sizeof(key));
-        AssertRCReturn(rc, rc);
-
-        pTexture = (CRTextureObj *) crCalloc(sizeof(CRTextureObj));
-        if (!pTexture) return VERR_NO_MEMORY;
-
-        rc = SSMR3GetMem(pSSM, pTexture, sizeof(*pTexture));
-        AssertRCReturn(rc, rc);
-
-        /*allocate actual memory*/
-        for (i=0; i<6; ++i) {
-            pTexture->level[i] = (CRTextureLevel *) crCalloc(sizeof(CRTextureLevel) * CR_MAX_MIPMAP_LEVELS);
-            if (!pTexture->level[i]) return VERR_NO_MEMORY;
-        }
-
-        rc = crStateLoadTextureObjData(pTexture, pSSM);
-        AssertRCReturn(rc, rc);
-
-        crHashtableAdd(pContext->shared->textureTable, key, pTexture);
+    if (bLoadShared)
+    {
+        /* Load shared textures */
+        CRASSERT(pContext->shared && pContext->shared->textureTable);
+        rc = SSMR3GetU32(pSSM, &uiNumElems);
+        AssertRCReturn(rc, rc);
+        for (ui=0; ui<uiNumElems; ++ui)
+        {
+            CRTextureObj *pTexture;
+
+            rc = SSMR3GetMem(pSSM, &key, sizeof(key));
+            AssertRCReturn(rc, rc);
+
+            pTexture = (CRTextureObj *) crCalloc(sizeof(CRTextureObj));
+            if (!pTexture) return VERR_NO_MEMORY;
+
+            rc = SSMR3GetMem(pSSM, pTexture, sizeof(*pTexture));
+            AssertRCReturn(rc, rc);
+
+            pTexture->hwid = 0;
+
+            /*allocate actual memory*/
+            for (i=0; i<6; ++i) {
+                pTexture->level[i] = (CRTextureLevel *) crCalloc(sizeof(CRTextureLevel) * CR_MAX_MIPMAP_LEVELS);
+                if (!pTexture->level[i]) return VERR_NO_MEMORY;
+            }
+
+            rc = crStateLoadTextureObjData(pTexture, pSSM);
+            AssertRCReturn(rc, rc);
+
+            crHashtableAdd(pContext->shared->textureTable, key, pTexture);
+        }
     }
 
@@ -1641 +1707 @@
         AssertRCReturn(rc, rc);
 
+        pBufferObj->hwid = 0;
+
         if (pBufferObj->data)
         {
@@ -1648 +1716 @@
             AssertRCReturn(rc, rc);
         } 
-        else if (pBufferObj->name!=0 && pBufferObj->size>0)
+        else if (pBufferObj->id!=0 && pBufferObj->size>0)
         {
             rc = SSMR3GetMem(pSSM, &pBufferObj->data, sizeof(pBufferObj->data));
@@ -1663 +1731 @@
 
         if (key!=0)
-            crHashtableAdd(pContext->bufferobject.buffers, key, pBufferObj);        
+            crHashtableAdd(pContext->shared->buffersTable, key, pBufferObj);        
     }
     /* Load pointers */
-#define CRS_GET_BO(name) (((name)==0) ? (pContext->bufferobject.nullBuffer) : crHashtableSearch(pContext->bufferobject.buffers, name))
+#define CRS_GET_BO(name) (((name)==0) ? (pContext->bufferobject.nullBuffer) : crHashtableSearch(pContext->shared->buffersTable, name))
     rc = SSMR3GetU32(pSSM, &ui);
     AssertRCReturn(rc, rc);
@@ -1735 +1803 @@
 #ifdef CR_EXT_framebuffer_object
     /* Load FBOs */
-    rc = SSMR3GetU32(pSSM, &uiNumElems);
-    AssertRCReturn(rc, rc);
-    for (ui=0; ui<uiNumElems; ++ui)
-    {
-        CRFramebufferObject *pFBO;
-        pFBO = crAlloc(sizeof(*pFBO));
-        if (!pFBO) return VERR_NO_MEMORY;
-
-        rc = SSMR3GetMem(pSSM, &key, sizeof(key));
-        AssertRCReturn(rc, rc);
-
-        rc = SSMR3GetMem(pSSM, pFBO, sizeof(*pFBO));
-        AssertRCReturn(rc, rc);
-
-        crHashtableAdd(pContext->framebufferobject.framebuffers, key, pFBO);
-    }
-
-    rc = SSMR3GetU32(pSSM, &uiNumElems);
-    AssertRCReturn(rc, rc);
-    for (ui=0; ui<uiNumElems; ++ui)
-    {
-        CRRenderbufferObject *pRBO;
-        pRBO = crAlloc(sizeof(*pRBO));
-        if (!pRBO) return VERR_NO_MEMORY;
-
-        rc = SSMR3GetMem(pSSM, &key, sizeof(key));
-        AssertRCReturn(rc, rc);
-
-        rc = SSMR3GetMem(pSSM, pRBO, sizeof(*pRBO));
-        AssertRCReturn(rc, rc);
-
-        crHashtableAdd(pContext->framebufferobject.renderbuffers, key, pRBO);
+    if (bLoadShared)
+    {
+        rc = SSMR3GetU32(pSSM, &uiNumElems);
+        AssertRCReturn(rc, rc);
+        for (ui=0; ui<uiNumElems; ++ui)
+        {
+            CRFramebufferObject *pFBO;
+            pFBO = crAlloc(sizeof(*pFBO));
+            if (!pFBO) return VERR_NO_MEMORY;
+
+            rc = SSMR3GetMem(pSSM, &key, sizeof(key));
+            AssertRCReturn(rc, rc);
+
+            rc = SSMR3GetMem(pSSM, pFBO, sizeof(*pFBO));
+            AssertRCReturn(rc, rc);
+
+            crHashtableAdd(pContext->shared->fbTable, key, pFBO);
+        }
+
+        rc = SSMR3GetU32(pSSM, &uiNumElems);
+        AssertRCReturn(rc, rc);
+        for (ui=0; ui<uiNumElems; ++ui)
+        {
+            CRRenderbufferObject *pRBO;
+            pRBO = crAlloc(sizeof(*pRBO));
+            if (!pRBO) return VERR_NO_MEMORY;
+
+            rc = SSMR3GetMem(pSSM, &key, sizeof(key));
+            AssertRCReturn(rc, rc);
+
+            rc = SSMR3GetMem(pSSM, pRBO, sizeof(*pRBO));
+            AssertRCReturn(rc, rc);
+
+            crHashtableAdd(pContext->shared->rbTable, key, pRBO);
+        }
     }
 
@@ -1772 +1843 @@
     AssertRCReturn(rc, rc);
     pContext->framebufferobject.drawFB = ui==0 ? NULL 
-                                               : crHashtableSearch(pContext->framebufferobject.framebuffers, ui);
+                                               : crHashtableSearch(pContext->shared->fbTable, ui);
 
     rc = SSMR3GetU32(pSSM, &ui);
     AssertRCReturn(rc, rc);
     pContext->framebufferobject.readFB = ui==0 ? NULL 
-                                               : crHashtableSearch(pContext->framebufferobject.framebuffers, ui);
+                                               : crHashtableSearch(pContext->shared->fbTable, ui);
 
     rc = SSMR3GetU32(pSSM, &ui);
     AssertRCReturn(rc, rc);
     pContext->framebufferobject.renderbuffer = ui==0 ? NULL 
-                                                     : crHashtableSearch(pContext->framebufferobject.renderbuffers, ui);
+                                                     : crHashtableSearch(pContext->shared->rbTable, ui);
 
     /* Mark FBOs/RBOs for resending to GPU */

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_texdiff.c

@@ -185 +185 @@
                 activeUnit = i;
             }
-            if (from->unit[i].currentTexture1D->name != to->unit[i].currentTexture1D->name) 
-            {
-                diff_api.BindTexture(GL_TEXTURE_1D, to->unit[i].currentTexture1D->name);
+            if (from->unit[i].currentTexture1D->id != to->unit[i].currentTexture1D->id) 
+            {
+                diff_api.BindTexture(GL_TEXTURE_1D, crStateGetTextureObjHWID(to->unit[i].currentTexture1D));
                 FILLDIRTY(tb->current[i]);
                 FILLDIRTY(tb->dirty);
             }
-            if (from->unit[i].currentTexture2D->name != to->unit[i].currentTexture2D->name) 
-            {
-                diff_api.BindTexture(GL_TEXTURE_2D, to->unit[i].currentTexture2D->name);
+            if (from->unit[i].currentTexture2D->id != to->unit[i].currentTexture2D->id) 
+            {
+                diff_api.BindTexture(GL_TEXTURE_2D, crStateGetTextureObjHWID(to->unit[i].currentTexture2D));
                 FILLDIRTY(tb->current[i]);
                 FILLDIRTY(tb->dirty);
             }
 #ifdef CR_OPENGL_VERSION_1_2
-            if (from->unit[i].currentTexture3D->name != to->unit[i].currentTexture3D->name) {
-                diff_api.BindTexture(GL_TEXTURE_3D, to->unit[i].currentTexture3D->name);
+            if (from->unit[i].currentTexture3D->id != to->unit[i].currentTexture3D->id) {
+                diff_api.BindTexture(GL_TEXTURE_3D, crStateGetTextureObjHWID(to->unit[i].currentTexture3D));
                 FILLDIRTY(tb->current[i]);
                 FILLDIRTY(tb->dirty);
@@ -206 +206 @@
 #ifdef CR_ARB_texture_cube_map
             if (fromCtx->extensions.ARB_texture_cube_map &&
-                from->unit[i].currentTextureCubeMap->name != to->unit[i].currentTextureCubeMap->name) {
-                diff_api.BindTexture(GL_TEXTURE_CUBE_MAP_ARB, to->unit[i].currentTextureCubeMap->name);
+                from->unit[i].currentTextureCubeMap->id != to->unit[i].currentTextureCubeMap->id) {
+                diff_api.BindTexture(GL_TEXTURE_CUBE_MAP_ARB, crStateGetTextureObjHWID(to->unit[i].currentTextureCubeMap));
                 FILLDIRTY(tb->current[i]);
                 FILLDIRTY(tb->dirty);
@@ -214 +214 @@
 #ifdef CR_NV_texture_rectangle
             if (fromCtx->extensions.NV_texture_rectangle &&
-                from->unit[i].currentTextureRect->name != to->unit[i].currentTextureRect->name) {
-                diff_api.BindTexture(GL_TEXTURE_RECTANGLE_NV, to->unit[i].currentTextureRect->name);
+                from->unit[i].currentTextureRect->id != to->unit[i].currentTextureRect->id) {
+                diff_api.BindTexture(GL_TEXTURE_RECTANGLE_NV, crStateGetTextureObjHWID(to->unit[i].currentTextureRect));
                 FILLDIRTY(tb->current[i]);
                 FILLDIRTY(tb->dirty);
@@ -616 +616 @@
 #endif
 
-    diff_api.BindTexture( tobj->target, tobj->name );
+    diff_api.BindTexture(tobj->target, crStateGetTextureObjHWID(tobj));
 
     if (alwaysDirty || CHECKDIRTY(tobj->paramsBit[u], bitID)) 
@@ -1304 +1304 @@
                 if (*fromBinding != tobj)
                 {
-                    diff_api.BindTexture(tobj->target, tobj->name);
+                    diff_api.BindTexture(tobj->target, crStateGetTextureObjHWID(tobj));
                     *fromBinding = tobj;
                 }
@@ -1389 +1389 @@
     /* save current texture bindings */
     origUnit = g->texture.curTextureUnit;
-    orig1D = g->texture.unit[0].currentTexture1D->name;
-    orig2D = g->texture.unit[0].currentTexture2D->name;
-    orig3D = g->texture.unit[0].currentTexture3D->name;
+    orig1D = crStateGetTextureObjHWID(g->texture.unit[0].currentTexture1D);
+    orig2D = crStateGetTextureObjHWID(g->texture.unit[0].currentTexture2D);
+    orig3D = crStateGetTextureObjHWID(g->texture.unit[0].currentTexture3D);
 #ifdef CR_ARB_texture_cube_map
-    origCube = g->texture.unit[0].currentTextureCubeMap->name;
+    origCube = crStateGetTextureObjHWID(g->texture.unit[0].currentTextureCubeMap);
 #endif
 #ifdef CR_NV_texture_rectangle
-    origRect = g->texture.unit[0].currentTextureRect->name;
+    origRect = crStateGetTextureObjHWID(g->texture.unit[0].currentTextureRect);
 #endif
 

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_texture.c

@@ -172 +172 @@
 void
 crStateTextureInitTextureObj(CRContext *ctx, CRTextureObj *tobj,
-                                                         GLuint name, GLenum target)
+                             GLuint name, GLenum target)
 {
     const CRTextureState *t = &(ctx->texture);
@@ -194 +194 @@
 #endif
     tobj->target        = target;
-    tobj->name          = name;
+    tobj->id            = name;
+    tobj->hwid          = 0;
+
+#ifndef IN_GUEST
+    crStateGetTextureObjHWID(tobj);
+#endif
 
     CRASSERT(t->maxLevel);
@@ -3147 +3152 @@
     return tobj != NULL;
 }
+
+static void crStateCheckTextureHWIDCB(unsigned long key, void *data1, void *data2)
+{
+    CRTextureObj *pTex = (CRTextureObj *) data1;
+    crCheckIDHWID_t *pParms = (crCheckIDHWID_t*) data2;
+    (void) key;
+
+    if (crStateGetTextureObjHWID(pTex)==pParms->hwid)
+        pParms->id = pTex->id;
+}
+
+DECLEXPORT(GLuint) STATE_APIENTRY crStateTextureHWIDtoID(GLuint hwid)
+{
+    CRContext *g = GetCurrentContext();
+    crCheckIDHWID_t parms;
+
+    parms.id = hwid;
+    parms.hwid = hwid;
+
+    crHashtableWalk(g->shared->textureTable, crStateCheckTextureHWIDCB, &parms);
+    return parms.id;
+}
+
+DECLEXPORT(GLuint) STATE_APIENTRY crStateGetTextureHWID(GLuint id)
+{
+    CRContext *g = GetCurrentContext();
+    CRTextureObj *tobj = GET_TOBJ(tobj, g, id);
+
+    return tobj ? crStateGetTextureObjHWID(tobj) : 0;
+}
+
+DECLEXPORT(GLuint) STATE_APIENTRY crStateGetTextureObjHWID(CRTextureObj *tobj)
+{
+    CRASSERT(tobj);
+
+#ifndef IN_GUEST
+    if (tobj->id && !tobj->hwid)
+    {
+        CRASSERT(diff_api.GenTextures);
+        diff_api.GenTextures(1, &tobj->hwid);
+        CRASSERT(tobj->hwid);
+    }
+#endif
+
+    return tobj->hwid;
+}

trunk/src/VBox/GuestHost/OpenGL/util/hash.c

@@ -417 +417 @@
     crUnlockMutex(&h->mutex);
 #endif
-    for ( i = 0; i < range; i++)
-        crHashtableAdd( h, i + res , NULL );
     return res;
 }

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

@@ -65 +65 @@
 
 static const char* gszVBoxOGLSSMMagic = "***OpenGL state data***";
-#define SHCROGL_SSM_VERSION 19
+#define SHCROGL_SSM_VERSION 20
 
 static DECLCALLBACK(int) svcUnload (void *)

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/get_components.py

@@ -104 +104 @@
         'GL_BUFFER_ACCESS_ARB': (1, 'CR_ARB_vertex_buffer_object'),
         'GL_BUFFER_MAPPED_ARB': (1, 'CR_ARB_vertex_buffer_object'),
-        'GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING': (4, 'CR_ARB_vertex_buffer_object'),
+        'GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB': (1, 'CR_ARB_vertex_buffer_object'),
         'GL_QUERY_COUNTER_BITS_ARB': (1, 'CR_ARB_occlusion_query'),
         'GL_QUERY_RESULT_AVAILABLE_ARB': (1, 'CR_ARB_occlusion_query'),

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

@@ -87 +87 @@
 GLint crServerSPUWindowID(GLint serverWindow);
 
-GLuint crServerTranslateTextureID(GLuint id);
 GLuint crServerTranslateProgramID(GLuint id);
 

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_bufferobject.c

@@ -59 +59 @@
         }
 }
+
+void SERVER_DISPATCH_APIENTRY
+crServerDispatchBindBufferARB(GLenum target, GLuint buffer)
+{
+    crStateBindBufferARB(target, buffer);
+    cr_server.head_spu->dispatch_table.BindBufferARB(target, crStateGetBufferHWID(buffer));
+}
+
+GLboolean SERVER_DISPATCH_APIENTRY
+crServerDispatchIsBufferARB(GLuint buffer)
+{
+    GLboolean retval;
+    retval = cr_server.head_spu->dispatch_table.IsBufferARB(crStateGetBufferHWID(buffer));
+    crServerReturnValue( &retval, sizeof(retval) );
+    return retval; /* WILL PROBABLY BE IGNORED */
+}

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

@@ -46 +46 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    if (texture)
-    {
-        texture = crServerTranslateTextureID(texture);
-    }
-
     crStateFramebufferTexture1DEXT(target, attachment, textarget, texture, level);
-    cr_server.head_spu->dispatch_table.FramebufferTexture1DEXT(target, attachment, textarget, texture, level);
+    cr_server.head_spu->dispatch_table.FramebufferTexture1DEXT(target, attachment, textarget, crStateGetTextureHWID(texture), level);
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    if (texture)
-    {
-        texture = crServerTranslateTextureID(texture);
-    }
-
     crStateFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
-    cr_server.head_spu->dispatch_table.FramebufferTexture2DEXT(target, attachment, textarget, texture, level);
+    cr_server.head_spu->dispatch_table.FramebufferTexture2DEXT(target, attachment, textarget, crStateGetTextureHWID(texture), level);
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    if (texture)
-    {
-        texture = crServerTranslateTextureID(texture);
-    }
-
     crStateFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
-    cr_server.head_spu->dispatch_table.FramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
+    cr_server.head_spu->dispatch_table.FramebufferTexture3DEXT(target, attachment, textarget, crStateGetTextureHWID(texture), level, zoffset);
 }
 
@@ -121 +106 @@
         crStateGetFramebufferAttachmentParameterivEXT(target, attachment, pname, local_params);
 
-    if (GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT==pname)
-    {
-        GLint type;
-        crStateGetFramebufferAttachmentParameterivEXT(target, attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT, &type);
-        if (GL_TEXTURE==type)
-        {
-            /*todo, add reverse of crServerTranslateTextureID*/
-            if (!cr_server.sharedTextureObjects && local_params[0])
-            {
-                int client = cr_server.curClient->number;
-                local_params[0] = local_params[0] - client * 100000;
-            }
-        }
-    }
-
         crServerReturnValue(&(local_params[0]), 1*sizeof(GLint));
 }
+
+GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsFramebufferEXT( GLuint framebuffer )
+{
+    GLboolean retval;
+    retval = cr_server.head_spu->dispatch_table.IsFramebufferEXT(crStateGetFramebufferHWID(framebuffer));
+    crServerReturnValue( &retval, sizeof(retval) );
+    return retval; /* WILL PROBABLY BE IGNORED */
+}
+
+GLboolean SERVER_DISPATCH_APIENTRY crServerDispatchIsRenderbufferEXT( GLuint renderbuffer )
+{
+    GLboolean retval;
+    retval = cr_server.head_spu->dispatch_table.IsRenderbufferEXT(crStateGetRenderbufferHWID(renderbuffer));
+    crServerReturnValue( &retval, sizeof(retval) );
+    return retval; /* WILL PROBABLY BE IGNORED */
+}

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_gentextures.c

@@ -14 +14 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchGenTextures( GLsizei n, GLuint *textures )
 {
-    GLsizei i;
-    GLuint *local_textures = (GLuint *) crAlloc( n*sizeof( *local_textures) );
+    GLuint *local_textures = (GLuint *) crAlloc(n*sizeof(*local_textures));
     (void) textures;
-    cr_server.head_spu->dispatch_table.GenTextures( n, local_textures );
 
-    /* This is somewhat hacky.
-     * We have to make sure we're going to generate unique texture IDs.
-     * That wasn't the case before snapshot loading, because we could just rely on host video drivers.
-     * Now we could have a set of loaded texture IDs which aren't already reserved in the host driver.
-     * Note: It seems, that it's easy to reserve ATI/NVidia IDs, by simply calling glGenTextures
-     * with n==number of loaded textures. But it's really implementation dependant. So can't rely that it'll not change.
-     */
-    for (i=0; i<n; ++i)
-    {
-        /* translate the ID as it'd be done in glBindTexture call */
-        GLuint tID = crServerTranslateTextureID(local_textures[i]);
-        /* check if we have a texture with same ID loaded from snapshot */
-        while (crStateIsTexture(tID))
-        {
-            /* request new ID */
-            cr_server.head_spu->dispatch_table.GenTextures(1, &tID);
-            local_textures[i] = tID;
-            tID = crServerTranslateTextureID(tID);
-        }
-    }
+    crStateGenTextures(n, local_textures);
 
-    crServerReturnValue( local_textures, n*sizeof( *local_textures ) );
+    crServerReturnValue(local_textures, n*sizeof(*local_textures));
     crFree( local_textures );
 }
-
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchGenProgramsNV( GLsizei n, GLuint * ids )

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_get.py

@@ -100 +100 @@
 ];
 
+convert_bufferid = [
+    'GetVertexAttribdvARB',
+    'GetVertexAttribdvNV',
+    'GetVertexAttribfvARB',
+    'GetVertexAttribfvNV',
+    'GetVertexAttribivARB',
+    'GetVertexAttribivNV'
+];
+
 from get_components import *;
 
@@ -125 +134 @@
 
         print '\tcr_server.head_spu->dispatch_table.%s( %s );' % ( func_name, apiutil.MakeCallString(params) )
+
+        if func_name in convert_bufferid:
+            print '\tif (pname==GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB){'
+            print '\t\tlocal_params[0]=(%s)crStateBufferHWIDtoID((GLint)local_params[0]);' % (local_argtype);
+            print '\t}'
+
         if func_name in no_pnames:
             print '\tcrServerReturnValue( &(%s[0]), %d*sizeof(%s) );' % (local_argname, max_components[func_name], local_argtype );

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_glsl.c

@@ -104 +104 @@
 }
 
+GLint SERVER_DISPATCH_APIENTRY crServerDispatchGetAttribLocation( GLuint program, const char * name )
+{
+    GLint retval;
+    retval = cr_server.head_spu->dispatch_table.GetAttribLocation(crStateGetProgramHWID(program), name );
+    crServerReturnValue( &retval, sizeof(retval) );
+    return retval; /* WILL PROBABLY BE IGNORED */
+}
+
+GLhandleARB SERVER_DISPATCH_APIENTRY crServerDispatchGetHandleARB( GLenum pname )
+{
+    GLhandleARB retval;
+    retval = cr_server.head_spu->dispatch_table.GetHandleARB(pname);
+    if (pname==GL_PROGRAM_OBJECT_ARB)
+    {
+        retval = crStateGLSLProgramHWIDtoID(retval);
+    }
+    crServerReturnValue( &retval, sizeof(retval) );
+    return retval; /* WILL PROBABLY BE IGNORED */
+}
+
+GLint SERVER_DISPATCH_APIENTRY crServerDispatchGetUniformLocation(GLuint program, const char * name)
+{
+    GLint retval;
+    retval = cr_server.head_spu->dispatch_table.GetUniformLocation(crStateGetProgramHWID(program), name);
+    crServerReturnValue( &retval, sizeof(retval) );
+    return retval; /* WILL PROBABLY BE IGNORED */
+}
+
 #endif /* #ifdef CR_OPENGL_VERSION_2_0 */

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

@@ -41 +41 @@
 {
     if (!cr_server.sharedDisplayLists) {
-        int client = cr_server.curClient->number;
-        return id + client * 100000;
-    }
-    return id;
-}
-
-
-GLuint crServerTranslateTextureID( GLuint id )
-{
-    if (!cr_server.sharedTextureObjects && id) {
         int client = cr_server.curClient->number;
         return id + client * 100000;
@@ -248 +238 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchBindTexture( GLenum target, GLuint texture )
 {
-    texture = crServerTranslateTextureID( texture );
     crStateBindTexture( target, texture );
-    cr_server.head_spu->dispatch_table.BindTexture( target, texture );
-}
-
+    cr_server.head_spu->dispatch_table.BindTexture(target, crStateGetTextureHWID(texture));
+}
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteTextures( GLsizei n, const GLuint *textures)
 {
-    if (!cr_server.sharedTextureObjects) {
-        GLuint *newTextures = (GLuint *) crAlloc(n * sizeof(GLuint));
-        GLint i;
-        if (!newTextures) {
-            crError("crServerDispatchDeleteTextures: out of memory");
-            return;
-        }
-        for (i = 0; i < n; i++) {
-            newTextures[i] = crServerTranslateTextureID( textures[i] );
-        }
-        crStateDeleteTextures( n, newTextures );
-        cr_server.head_spu->dispatch_table.DeleteTextures( n, newTextures );
-        crFree(newTextures);
-    }
-    else {
-        crStateDeleteTextures( n, textures );
-        cr_server.head_spu->dispatch_table.DeleteTextures( n, textures );
-    }
+    GLuint *newTextures = (GLuint *) crAlloc(n * sizeof(GLuint));
+    GLint i;
+
+    if (!newTextures)
+    {
+        crError("crServerDispatchDeleteTextures: out of memory");
+        return;
+    }
+
+    for (i = 0; i < n; i++)
+    {
+        newTextures[i] = crStateGetTextureHWID(textures[i]);
+    }
+
+    crStateDeleteTextures(n, textures);
+    cr_server.head_spu->dispatch_table.DeleteTextures(n, newTextures);
+    crFree(newTextures);
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchPrioritizeTextures( GLsizei n, const GLuint * textures, const GLclampf * priorities )
 {
-    if (!cr_server.sharedTextureObjects) 
+    GLuint *newTextures = (GLuint *) crAlloc(n * sizeof(GLuint));
+    GLint i;
+
+    if (!newTextures)
     {
-        GLuint *newTextures = (GLuint *) crAlloc(n * sizeof(GLuint));
-        GLint i;
-        if (!newTextures) {
-            crError("crServerDispatchDeleteTextures: out of memory");
-            return;
-        }
-        for (i = 0; i < n; i++) {
-            newTextures[i] = crServerTranslateTextureID( textures[i] );
-        }
-        crStatePrioritizeTextures(n, newTextures, priorities);
-        cr_server.head_spu->dispatch_table.PrioritizeTextures(n, newTextures, priorities);
-        crFree(newTextures);
-    }
-    else
+        crError("crServerDispatchDeleteTextures: out of memory");
+        return;
+    }
+
+    for (i = 0; i < n; i++)
     {
-        crStatePrioritizeTextures(n, textures, priorities);
-        cr_server.head_spu->dispatch_table.PrioritizeTextures(n, textures, priorities);
-    }
+        newTextures[i] = crStateGetTextureHWID(textures[i]);
+    }
+
+    crStatePrioritizeTextures(n, textures, priorities);
+    cr_server.head_spu->dispatch_table.PrioritizeTextures(n, newTextures, priorities);
+    crFree(newTextures);
 }
 
@@ -320 +304 @@
 {
     GLboolean retval;
-    texture = crServerTranslateTextureID( texture );
-    retval = cr_server.head_spu->dispatch_table.IsTexture( texture );
+    retval = cr_server.head_spu->dispatch_table.IsTexture(crStateGetTextureHWID(texture));
     crServerReturnValue( &retval, sizeof(retval) );
     return retval; /* WILL PROBABLY BE IGNORED */
@@ -330 +313 @@
 {
     GLboolean retval;
-    program = crServerTranslateTextureID(program);
+    program = crServerTranslateProgramID(program);
     retval = cr_server.head_spu->dispatch_table.IsProgramARB( program );
     crServerReturnValue( &retval, sizeof(retval) );
@@ -349 +332 @@
         GLuint *textures2 = (GLuint *) crAlloc(n * sizeof(GLuint));
         for (i = 0; i < n; i++)
-            textures2[i] = crServerTranslateTextureID(textures[i]);
+            textures2[i] = crStateGetTextureHWID(textures[i]);
         retval = cr_server.head_spu->dispatch_table.AreTexturesResident(n, textures2, res);
         crFree(textures2);
-    }
-    else {
-        retval = cr_server.head_spu->dispatch_table.AreTexturesResident(n, textures, res);
     }
     crServerReturnValue(res, n * sizeof(GLboolean));

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

@@ -793 +793 @@
         char psz[200];
         GLint ctxID;
+        CRContext* pContext;
 
         rc = SSMR3GetMem(pSSM, &key, sizeof(key));
@@ -808 +809 @@
         ctxID = crServerDispatchCreateContextEx(createInfo.pszDpyName, createInfo.visualBits, 0, key, createInfo.internalID);
         CRASSERT((int64_t)ctxID == (int64_t)key);
+
+        pContext = (CRContext*) crHashtableSearch(cr_server.contextTable, key);
+        CRASSERT(pContext);
+        pContext->shared->id=-1;
     }
 
@@ -821 +826 @@
         CRASSERT(pContext);
 
-        rc = crStateLoadContext(pContext, pSSM);
+        rc = crStateLoadContext(pContext, cr_server.contextTable, pSSM);
         AssertRCReturn(rc, rc);
     }

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

@@ -216 +216 @@
 {
   switch (target) {
+    case GL_SHARE_CONTEXT_RESOURCES_CR:
+        crStateShareContext(value);
+        break;
     case GL_SHARED_DISPLAY_LISTS_CR:
         cr_server.sharedDisplayLists = value;

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_muralfbo.c

@@ -229 +229 @@
 
     /*Restore gl state*/
-    uid = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->name;
+    uid = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid;
     cr_server.head_spu->dispatch_table.BindTexture(GL_TEXTURE_2D, uid);
 
@@ -330 +330 @@
     cr_server.head_spu->dispatch_table.BindTexture(GL_TEXTURE_2D, mural->idColorTex);
     cr_server.head_spu->dispatch_table.GetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_BYTE, pixels);
-    uid = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->name;
+    uid = ctx->texture.unit[ctx->texture.curTextureUnit].currentTexture2D->hwid;
     cr_server.head_spu->dispatch_table.BindTexture(GL_TEXTURE_2D, uid);
 

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

@@ -61 +61 @@
         CRASSERT(tablesize/sizeof(%s)==1);
         texid = (GLuint) *get_values;
-        if (texid)
-        {
-            *get_values = (%s) (texid - cr_server.curClient->number * 100000);
-        }
+        *get_values = (%s) crStateTextureHWIDtoID(texid);
     }
     else if (GL_CURRENT_PROGRAM==pname)
@@ -93 +90 @@
         *get_values = (%s) crStateRBOHWIDtoID(rbid);
     }
-    """ % (types[index], types[index], types[index], types[index], types[index], types[index], types[index], types[index])
+    else if (GL_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_VERTEX_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_NORMAL_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_COLOR_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_INDEX_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB==pname
+             || GL_WEIGHT_ARRAY_BUFFER_BINDING_ARB==pname)
+    {
+        GLuint bufid;
+        CRASSERT(tablesize/sizeof(%s)==1);
+        bufid = (GLuint) *get_values;
+        *get_values = (%s) crStateBufferHWIDtoID(bufid);
+    }
+    """ % (types[index], types[index], types[index], types[index], types[index], types[index], types[index], types[index], types[index], types[index])
     print '\tcrServerReturnValue( get_values, tablesize );'
     print '\tcrFree(get_values);'

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

@@ -235 +235 @@
 TexImage2D
 TexImage3D
+BindBufferARB
+IsBufferARB
+IsFramebufferEXT
+IsRenderbufferEXT
+GetAttribLocation
+GetHandleARB
+GetUniformLocation

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

@@ -230 +230 @@
         offset += sizeof(int);
         cp = crStateGetClientPointerByIndex(index, &c->array);
-        CRASSERT(cp && cp->enabled && (!cp->buffer || !cp->buffer->name));
+        CRASSERT(cp && cp->enabled && (!cp->buffer || !cp->buffer->id));
         data = crAlloc((first+count)*cp->bytesPerIndex);
         crMemcpy(data+first*cp->bytesPerIndex, DATA_POINTER(offset, GLvoid), count*cp->bytesPerIndex);