Changeset 78375 in vbox for trunk/src/VBox/HostServices/SharedOpenGL/crserverlib

Timestamp:

May 3, 2019 9:51:02 PM (6 years ago)

Author:

vboxsync

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

130368

Message:

Additions/common/crOpengl,GuestHost/OpenGL,HostServices/SharedOpenGL: Eliminate all global variables from the state tracker library (state_tracker) in preparation of the SPU DLL merging, bugref:9435

Location:

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib

Files:

• presenter/server_presenter.cpp (modified) (5 diffs)
• server.h (modified) (1 diff)
• server_bufferobject.cpp (modified) (4 diffs)
• server_clear.cpp (modified) (3 diffs)
• server_context.cpp (modified) (8 diffs)
• server_dispatch.py (modified) (1 diff)
• server_framebuffer.cpp (modified) (13 diffs)
• server_gentextures.cpp (modified) (3 diffs)
• server_get.py (modified) (1 diff)
• server_getpixelmap.cpp (modified) (3 diffs)
• server_getshaders.cpp (modified) (21 diffs)
• server_getteximage.cpp (modified) (3 diffs)
• server_glsl.cpp (modified) (12 diffs)
• server_lists.cpp (modified) (4 diffs)
• server_main.cpp (modified) (16 diffs)
• server_misc.cpp (modified) (13 diffs)
• server_muralfbo.cpp (modified) (6 diffs)
• server_projmatrix.cpp (modified) (9 diffs)
• server_readpixels.cpp (modified) (1 diff)
• server_rpw.cpp (modified) (3 diffs)
• server_simpleget.py (modified) (7 diffs)
• server_stream.cpp (modified) (2 diffs)
• server_texture.cpp (modified) (17 diffs)
• server_viewport.cpp (modified) (2 diffs)
• server_window.cpp (modified) (1 diff)
• server_winpos.cpp (modified) (1 diff)

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/presenter/server_presenter.cpp

@@ -975 +975 @@
 
         crStateReleaseTexture(cr_server.MainContextInfo.pContext, pTobj);
-
-
-        crStateGlobalSharedRelease();
+        crStateGlobalSharedRelease(&cr_server.StateTracker);
     }
 
@@ -1026 +1024 @@
     }
 
-    CRSharedState *pShared = crStateGlobalSharedAcquire();
+    CRSharedState *pShared = crStateGlobalSharedAcquire(&cr_server.StateTracker);
     if (!pShared)
     {
@@ -1037 +1035 @@
     {
         LOG(("pTobj is null!"));
-        crStateGlobalSharedRelease();
+        crStateGlobalSharedRelease(&cr_server.StateTracker);
         return NULL;
     }
@@ -1043 +1041 @@
     Assert(pTobj->id == idTexture);
 
-    GLuint hwid = crStateGetTextureObjHWID(pTobj);
+    GLuint hwid = crStateGetTextureObjHWID(&cr_server.StateTracker, pTobj);
     if (!hwid)
     {
         WARN(("hwId is null!"));
-        crStateGlobalSharedRelease();
+        crStateGlobalSharedRelease(&cr_server.StateTracker);
         return NULL;
     }
@@ -1061 +1059 @@
     {
         WARN(("crFbTexCreate failed!"));
-        crStateGlobalSharedRelease();
+        crStateGlobalSharedRelease(&cr_server.StateTracker);
         return NULL;
     }

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

@@ -341 +341 @@
     CRContext *pCurCtx = pCurCtxInfo ? pCurCtxInfo->pContext : NULL;
 
-    CRASSERT(pCurCtx == crStateGetCurrent());
+    CRASSERT(pCurCtx == crStateGetCurrent(&cr_server.StateTracker));
 
     if (pCurrentMural)

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

@@ -46 +46 @@
     }
 
-    crStateGenBuffersARB(n, local_buffers);
+    crStateGenBuffersARB(&cr_server.StateTracker, n, local_buffers);
 
     crServerReturnValue( local_buffers, n * sizeof(*local_buffers) );
@@ -60 +60 @@
     }
 
-    crStateDeleteBuffersARB( n, buffer );
+    crStateDeleteBuffersARB(&cr_server.StateTracker, n, buffer );
 }
 
@@ -101 +101 @@
 crServerDispatchBindBufferARB(GLenum target, GLuint buffer)
 {
-    crStateBindBufferARB(target, buffer);
-    cr_server.head_spu->dispatch_table.BindBufferARB(target, crStateGetBufferHWID(buffer));
+    crStateBindBufferARB(&cr_server.StateTracker, target, buffer);
+    cr_server.head_spu->dispatch_table.BindBufferARB(target, crStateGetBufferHWID(&cr_server.StateTracker, buffer));
 }
 
@@ -110 +110 @@
     /* since GenBuffersARB issued to host ogl only on bind + some other ops, the host drivers may not know about them
      * so use state data*/
-    GLboolean retval = crStateIsBufferARB(buffer);
+    GLboolean retval = crStateIsBufferARB(&cr_server.StateTracker, buffer);
     crServerReturnValue( &retval, sizeof(retval) );
     return retval; /* WILL PROBABLY BE IGNORED */

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_clear.cpp

@@ -423 +423 @@
                 window = 0;
 
-        ctx = crStateGetCurrent();
+        ctx = crStateGetCurrent(&cr_server.StateTracker);
 
         CRASSERT(cr_server.curClient && cr_server.curClient->currentMural == mural);
@@ -449 +449 @@
 crServerDispatchFlush(void)
 {
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
     cr_server.head_spu->dispatch_table.Flush();
 
@@ -470 +470 @@
 crServerDispatchFinish(void)
 {
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
 
     cr_server.head_spu->dispatch_table.Finish();

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_context.cpp

@@ -63 +63 @@
             return -1;
         }
-        cr_server.MainContextInfo.pContext = crStateCreateContext(&cr_server.limits, visualBits, NULL);
+        cr_server.MainContextInfo.pContext = crStateCreateContext(&cr_server.StateTracker, &cr_server.limits, visualBits, NULL);
         CRASSERT(cr_server.MainContextInfo.pContext);
         cr_server.firstCallCreateContext = GL_FALSE;
@@ -114 +114 @@
         if (pContextInfo->SpuContext < 0) {
             crWarning("crServerDispatchCreateContext() failed.");
-            crStateEnableDiffOnMakeCurrent(GL_TRUE);
+            crStateEnableDiffOnMakeCurrent(&cr_server.StateTracker, GL_TRUE);
             cr_server.bUseMultipleContexts = GL_FALSE;
             if (!fFirst)
@@ -121 +121 @@
         else if (fFirst)
         {
-            crStateEnableDiffOnMakeCurrent(GL_FALSE);
+            crStateEnableDiffOnMakeCurrent(&cr_server.StateTracker, GL_FALSE);
         }
     }
@@ -132 +132 @@
      * dispatch function pointers.
      */
-    newCtx = crStateCreateContextEx(&cr_server.limits, visualBits, NULL, internalID);
+    newCtx = crStateCreateContextEx(&cr_server.StateTracker, &cr_server.limits, visualBits, NULL, internalID);
     if (newCtx) {
-        crStateSetCurrentPointers( newCtx, &(cr_server.current) );
+        crStateSetCurrentPointers(newCtx, &(cr_server.current) );
         crStateResetCurrentPointers(&(cr_server.current));
         retVal = preloadCtxID<0 ? (GLint)crHashtableAllocKeys( cr_server.contextTable, 1 ) : preloadCtxID;
@@ -214 +214 @@
     crCtxInfo->currentMural = NULL;
     crHashtableDelete(cr_server.contextTable, ctx, NULL);
-    crStateDestroyContext( crCtx );
+    crStateDestroyContext(&cr_server.StateTracker, crCtx);
 
     if (crCtxInfo->CreateInfo.pszDpyName)
@@ -306 +306 @@
      * crStateSwitchPrepare restores the FBO state to its default values before the context window switch,
      * while crStateSwitchPostprocess restores it back to the original values */
-    oldCtx = crStateGetCurrent();
+    oldCtx = crStateGetCurrent(&cr_server.StateTracker);
     if (oldMural && oldMural->fRedirected && crServerSupportRedirMuralFBO())
     {
@@ -335 +335 @@
 
     /* This is a hack to force updating the 'current' attribs */
-    crStateUpdateColorBits();
+    crStateUpdateColorBits(&cr_server.StateTracker);
 
     if (ctx)
-        crStateSetCurrentPointers( ctx, &(cr_server.current) );
+        crStateSetCurrentPointers(ctx, &(cr_server.current) );
 
     /* check if being made current for first time, update viewport */
@@ -387 +387 @@
 
     /* This used to be earlier, after crStateUpdateColorBits() call */
-    crStateMakeCurrent( ctx );
+    crStateMakeCurrent(&cr_server.StateTracker, ctx );
 
     if (mural && mural->fRedirected  && crServerSupportRedirMuralFBO())

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

@@ -37 +37 @@
     print('void SERVER_DISPATCH_APIENTRY crServerDispatch%s(%s)' % ( func_name, apiutil.MakeDeclarationStringForDispatcher( params ) ))
     print('{')
-    print('\tcrState%s(%s);' % (func_name, apiutil.MakeCallStringForDispatcher( params ) ))
+    if len(params) == 0:
+        print('\tcrState%s(&cr_server.StateTracker);' % (func_name))
+    else:
+        print('\tcrState%s(&cr_server.StateTracker, %s);' % (func_name, apiutil.MakeCallStringForDispatcher( params ) ))
     print('\tcr_server.head_spu->dispatch_table.%s(%s);' % (func_name, apiutil.MakeCallStringForDispatcher( params ) ))
     print('}')

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

@@ -38 +38 @@
     local_buffers = (GLuint *)crCalloc(n * sizeof(*local_buffers));
 
-    crStateGenFramebuffersEXT(n, local_buffers);
+    crStateGenFramebuffersEXT(&cr_server.StateTracker, n, local_buffers);
 
     crServerReturnValue(local_buffers, n * sizeof(*local_buffers));
@@ -58 +58 @@
     local_buffers = (GLuint *)crCalloc(n * sizeof(*local_buffers));
 
-    crStateGenRenderbuffersEXT(n, local_buffers);
+    crStateGenRenderbuffersEXT(&cr_server.StateTracker, n, local_buffers);
 
     crServerReturnValue(local_buffers, n * sizeof(*local_buffers));
@@ -66 +66 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    crStateFramebufferTexture1DEXT(target, attachment, textarget, texture, level);
-    cr_server.head_spu->dispatch_table.FramebufferTexture1DEXT(target, attachment, textarget, crStateGetTextureHWID(texture), level);
+    crStateFramebufferTexture1DEXT(&cr_server.StateTracker, target, attachment, textarget, texture, level);
+    cr_server.head_spu->dispatch_table.FramebufferTexture1DEXT(target, attachment, textarget, crStateGetTextureHWID(&cr_server.StateTracker, texture), level);
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    crStateFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
-    cr_server.head_spu->dispatch_table.FramebufferTexture2DEXT(target, attachment, textarget, crStateGetTextureHWID(texture), level);
+    crStateFramebufferTexture2DEXT(&cr_server.StateTracker, target, attachment, textarget, texture, level);
+    cr_server.head_spu->dispatch_table.FramebufferTexture2DEXT(target, attachment, textarget, crStateGetTextureHWID(&cr_server.StateTracker, texture), level);
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    crStateFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
-    cr_server.head_spu->dispatch_table.FramebufferTexture3DEXT(target, attachment, textarget, crStateGetTextureHWID(texture), level, zoffset);
+    crStateFramebufferTexture3DEXT(&cr_server.StateTracker, target, attachment, textarget, texture, level, zoffset);
+    cr_server.head_spu->dispatch_table.FramebufferTexture3DEXT(target, attachment, textarget, crStateGetTextureHWID(&cr_server.StateTracker, texture), level, zoffset);
 }
 
@@ -87 +87 @@
     GLint rfb = 0, dfb = 0;
 #endif
-        crStateBindFramebufferEXT(target, framebuffer);
+    crStateBindFramebufferEXT(&cr_server.StateTracker, target, framebuffer);
 
     if (0==framebuffer)
     {
-        CRContext *ctx = crStateGetCurrent();
+        CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
         if (ctx->buffer.drawBuffer == GL_FRONT || ctx->buffer.drawBuffer == GL_FRONT_LEFT || ctx->buffer.drawBuffer == GL_FRONT_RIGHT)
             cr_server.curClient->currentMural->bFbDraw = GL_TRUE;
@@ -149 +149 @@
     else
     {
-        cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, crStateGetFramebufferHWID(framebuffer));
+        cr_server.head_spu->dispatch_table.BindFramebufferEXT(target, crStateGetFramebufferHWID(&cr_server.StateTracker, framebuffer));
 #ifdef DEBUG_misha
         cr_server.head_spu->dispatch_table.GetIntegerv(GL_READ_FRAMEBUFFER_BINDING_EXT, &rfb);
@@ -155 +155 @@
         if (GL_FRAMEBUFFER_EXT == target)
         {
-            Assert(rfb == crStateGetFramebufferHWID(framebuffer));
-            Assert(dfb == crStateGetFramebufferHWID(framebuffer));
+            Assert(rfb == crStateGetFramebufferHWID(&cr_server.StateTracker, framebuffer));
+            Assert(dfb == crStateGetFramebufferHWID(&cr_server.StateTracker, framebuffer));
         }
         else if (GL_READ_FRAMEBUFFER_EXT == target)
         {
-            Assert(rfb == crStateGetFramebufferHWID(framebuffer));
+            Assert(rfb == crStateGetFramebufferHWID(&cr_server.StateTracker, framebuffer));
         }
         else if (GL_DRAW_FRAMEBUFFER_EXT == target)
         {
-            Assert(dfb == crStateGetFramebufferHWID(framebuffer));
+            Assert(dfb == crStateGetFramebufferHWID(&cr_server.StateTracker, framebuffer));
         }
         else
@@ -176 +176 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
 {
-        crStateBindRenderbufferEXT(target, renderbuffer);
-        cr_server.head_spu->dispatch_table.BindRenderbufferEXT(target, crStateGetRenderbufferHWID(renderbuffer));
+        crStateBindRenderbufferEXT(&cr_server.StateTracker, target, renderbuffer);
+        cr_server.head_spu->dispatch_table.BindRenderbufferEXT(target, crStateGetRenderbufferHWID(&cr_server.StateTracker, renderbuffer));
 }
 
@@ -188 +188 @@
     }
 
-    crStateDeleteFramebuffersEXT(n, framebuffers);
+    crStateDeleteFramebuffersEXT(&cr_server.StateTracker, n, framebuffers);
 }
 
@@ -199 +199 @@
     }
 
-    crStateDeleteRenderbuffersEXT(n, renderbuffers);
+    crStateDeleteRenderbuffersEXT(&cr_server.StateTracker, n, renderbuffers);
 }
 
@@ -205 +205 @@
 crServerDispatchFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-        crStateFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
-        cr_server.head_spu->dispatch_table.FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, crStateGetRenderbufferHWID(renderbuffer));
+        crStateFramebufferRenderbufferEXT(&cr_server.StateTracker, target, attachment, renderbuffertarget, renderbuffer);
+        cr_server.head_spu->dispatch_table.FramebufferRenderbufferEXT(target, attachment, renderbuffertarget, crStateGetRenderbufferHWID(&cr_server.StateTracker, renderbuffer));
 }
 
@@ -214 +214 @@
         GLint local_params[1];
         (void) params;
-        crStateGetFramebufferAttachmentParameterivEXT(target, attachment, pname, local_params);
+        crStateGetFramebufferAttachmentParameterivEXT(&cr_server.StateTracker, target, attachment, pname, local_params);
 
         crServerReturnValue(&(local_params[0]), 1*sizeof(GLint));
@@ -223 +223 @@
     /* since GenFramebuffers/Renderbuffers issued to host ogl only on bind + some other ops, the host drivers may not know about them
      * so use state data*/
-    GLboolean retval = crStateIsFramebufferEXT(framebuffer);
+    GLboolean retval = crStateIsFramebufferEXT(&cr_server.StateTracker, framebuffer);
     crServerReturnValue( &retval, sizeof(retval) );
     return retval; /* WILL PROBABLY BE IGNORED */
@@ -232 +232 @@
     /* since GenFramebuffers/Renderbuffers issued to host ogl only on bind + some other ops, the host drivers may not know about them
      * so use state data*/
-    GLboolean retval = crStateIsRenderbufferEXT(renderbuffer);
+    GLboolean retval = crStateIsRenderbufferEXT(&cr_server.StateTracker, renderbuffer);
     crServerReturnValue( &retval, sizeof(retval) );
     return retval; /* WILL PROBABLY BE IGNORED */

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

@@ -31 +31 @@
     }
 
-    crStateGenTextures(n, local_textures);
+    crStateGenTextures(&cr_server.StateTracker, n, local_textures);
 
     crServerReturnValue(local_textures, n*sizeof(*local_textures));
@@ -112 +112 @@
     {
         GLuint tID = crServerTranslateProgramID(local_progs[i]);
-        while (crStateIsProgramARB(tID))
+        while (crStateIsProgramARB(&cr_server.StateTracker, tID))
         {
             cr_server.head_spu->dispatch_table.GenProgramsARB(1, &tID);
@@ -138 +138 @@
     }
 
-    crStateCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
+    crStateCopyTexImage2D(&cr_server.StateTracker, target, level, internalFormat, x, y, width, height, border);
     cr_server.head_spu->dispatch_table.CopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
 }

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

@@ -138 +138 @@
         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\tlocal_params[0]=(%s)crStateBufferHWIDtoID(&cr_server.StateTracker, (GLint)local_params[0]);' % (local_argtype))
             print('\t}')
 

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_getpixelmap.cpp

@@ -64 +64 @@
 {
 #ifdef CR_ARB_pixel_buffer_object
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         GLvoid *pbo_offset;
@@ -91 +91 @@
 {
 #ifdef CR_ARB_pixel_buffer_object
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         GLvoid *pbo_offset;
@@ -118 +118 @@
 {
 #ifdef CR_ARB_pixel_buffer_object
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         GLvoid *pbo_offset;

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_getshaders.cpp

@@ -52 +52 @@
     }
 
-    cr_server.head_spu->dispatch_table.GetActiveAttrib(crStateGetProgramHWID(program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
+    cr_server.head_spu->dispatch_table.GetActiveAttrib(crStateGetProgramHWID(&cr_server.StateTracker, program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
     crServerReturnValue(pLocal, pLocal->length+1+sizeof(crGetActive_t));
     crFree(pLocal);
@@ -74 +74 @@
     }
 
-    cr_server.head_spu->dispatch_table.GetActiveUniform(crStateGetProgramHWID(program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
+    cr_server.head_spu->dispatch_table.GetActiveUniform(crStateGetProgramHWID(&cr_server.StateTracker, program), index, bufSize, &pLocal->length, &pLocal->size, &pLocal->type, (char*)&pLocal[1]);
     crServerReturnValue(pLocal, pLocal->length+1+sizeof(crGetActive_t));
     crFree(pLocal);
@@ -96 +96 @@
     /* initial (fallback )value */
     *pLocal = 0;
-    cr_server.head_spu->dispatch_table.GetAttachedShaders(crStateGetProgramHWID(program), maxCount, pLocal, (GLuint*)&pLocal[1]);
+    cr_server.head_spu->dispatch_table.GetAttachedShaders(crStateGetProgramHWID(&cr_server.StateTracker, program), maxCount, pLocal, (GLuint*)&pLocal[1]);
 
     {
@@ -103 +103 @@
 
         for (i=0; i<*pLocal; ++i)
-          ids[i] = crStateGLSLShaderHWIDtoID(ids[i]);
+          ids[i] = crStateGLSLShaderHWIDtoID(&cr_server.StateTracker, ids[i]);
     }
 
@@ -127 +127 @@
     /* initial (fallback )value */
     *pLocal = 0;
-    cr_server.head_spu->dispatch_table.GetAttachedObjectsARB(crStateGetProgramHWID(containerObj), maxCount, pLocal, (VBoxGLhandleARB*)&pLocal[1]);
+    cr_server.head_spu->dispatch_table.GetAttachedObjectsARB(crStateGetProgramHWID(&cr_server.StateTracker, containerObj), maxCount, pLocal, (VBoxGLhandleARB*)&pLocal[1]);
 
     {
@@ -134 +134 @@
 
         for (i=0; i<*pLocal; ++i)
-          ids[i] = crStateGLSLShaderHWIDtoID(ids[i]);
+          ids[i] = crStateGLSLShaderHWIDtoID(&cr_server.StateTracker, ids[i]);
     }
 
@@ -162 +162 @@
     *pLocal = 0;
     /** @todo recheck*/
-    hwid = crStateGetProgramHWID(obj);
-    if (!hwid) hwid = crStateGetShaderHWID(obj);
+    hwid = crStateGetProgramHWID(&cr_server.StateTracker, obj);
+    if (!hwid) hwid = crStateGetShaderHWID(&cr_server.StateTracker, obj);
     cr_server.head_spu->dispatch_table.GetInfoLogARB(hwid, maxLength, pLocal, (char*)&pLocal[1]);
     CRASSERT((*pLocal) <= maxLength);
@@ -187 +187 @@
     /* initial (fallback )value */
     *pLocal = 0;
-    cr_server.head_spu->dispatch_table.GetShaderInfoLog(crStateGetShaderHWID(shader), bufSize, pLocal, (char*)&pLocal[1]);
+    cr_server.head_spu->dispatch_table.GetShaderInfoLog(crStateGetShaderHWID(&cr_server.StateTracker, shader), bufSize, pLocal, (char*)&pLocal[1]);
     crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
     crFree(pLocal);
@@ -209 +209 @@
     /* initial (fallback )value */
     *pLocal = 0;
-    cr_server.head_spu->dispatch_table.GetProgramInfoLog(crStateGetProgramHWID(program), bufSize, pLocal, (char*)&pLocal[1]);
+    cr_server.head_spu->dispatch_table.GetProgramInfoLog(crStateGetProgramHWID(&cr_server.StateTracker, program), bufSize, pLocal, (char*)&pLocal[1]);
     CRASSERT(pLocal[0] <= bufSize);
     crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
@@ -232 +232 @@
     /* initial (fallback )value */
     *pLocal = 0;
-    cr_server.head_spu->dispatch_table.GetShaderSource(crStateGetShaderHWID(shader), bufSize, pLocal, (char*)&pLocal[1]);
+    cr_server.head_spu->dispatch_table.GetShaderSource(crStateGetShaderHWID(&cr_server.StateTracker, shader), bufSize, pLocal, (char*)&pLocal[1]);
     CRASSERT(pLocal[0] <= bufSize);
     crServerReturnValue(pLocal, pLocal[0]+sizeof(GLsizei));
@@ -258 +258 @@
     /* initial (fallback )value */
     *pLocal = 0;
-    crStateGLSLProgramCacheUniforms(program, maxcbData, pLocal, (char*)&pLocal[1]);
+    crStateGLSLProgramCacheUniforms(&cr_server.StateTracker, program, maxcbData, pLocal, (char*)&pLocal[1]);
 
     crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
@@ -284 +284 @@
     /* initial (fallback )value */
     *pLocal = 0;
-    crStateGLSLProgramCacheAttribs(program, maxcbData, pLocal, (char*)&pLocal[1]);
+    crStateGLSLProgramCacheAttribs(&cr_server.StateTracker, program, maxcbData, pLocal, (char*)&pLocal[1]);
 
     crServerReturnValue(pLocal, (*pLocal)+sizeof(GLsizei));
@@ -296 +296 @@
 
     /** @todo check if index and location is the same*/
-    cr_server.head_spu->dispatch_table.GetActiveUniform(crStateGetProgramHWID(program), location, 0, NULL, &size, &type, NULL);
-
-    return crStateGetUniformSize(type);
+    cr_server.head_spu->dispatch_table.GetActiveUniform(crStateGetProgramHWID(&cr_server.StateTracker, program), location, 0, NULL, &size, &type, NULL);
+
+    return crStateGetUniformSize(&cr_server.StateTracker, type);
 }
 
@@ -316 +316 @@
     }
 
-    cr_server.head_spu->dispatch_table.GetUniformfv(crStateGetProgramHWID(program), location, pLocal);
+    cr_server.head_spu->dispatch_table.GetUniformfv(crStateGetProgramHWID(&cr_server.StateTracker, program), location, pLocal);
 
     crServerReturnValue(pLocal, size);
@@ -337 +337 @@
     }
 
-    cr_server.head_spu->dispatch_table.GetUniformiv(crStateGetProgramHWID(program), location, pLocal);
+    cr_server.head_spu->dispatch_table.GetUniformiv(crStateGetProgramHWID(&cr_server.StateTracker, program), location, pLocal);
 
     crServerReturnValue(pLocal, size);
@@ -347 +347 @@
     GLuint retval, hwVal;
     hwVal = cr_server.head_spu->dispatch_table.CreateShader(type);
-    retval = crStateCreateShader(hwVal, type);
+    retval = crStateCreateShader(&cr_server.StateTracker, hwVal, type);
     crServerReturnValue(&retval, sizeof(retval));
     return retval; /* ignored */
@@ -356 +356 @@
     GLuint retval, hwVal;
     hwVal = cr_server.head_spu->dispatch_table.CreateProgram();
-    retval = crStateCreateProgram(hwVal);
+    retval = crStateCreateProgram(&cr_server.StateTracker, hwVal);
     crServerReturnValue(&retval, sizeof(retval));
     return retval; /* ignored */
@@ -364 +364 @@
 {
     GLboolean retval;
-    retval = cr_server.head_spu->dispatch_table.IsShader(crStateGetShaderHWID(shader));
+    retval = cr_server.head_spu->dispatch_table.IsShader(crStateGetShaderHWID(&cr_server.StateTracker, shader));
     crServerReturnValue(&retval, sizeof(retval));
     return retval; /* ignored */
@@ -372 +372 @@
 {
     GLboolean retval;
-    retval = cr_server.head_spu->dispatch_table.IsProgram(crStateGetProgramHWID(program));
+    retval = cr_server.head_spu->dispatch_table.IsProgram(crStateGetProgramHWID(&cr_server.StateTracker, program));
     crServerReturnValue(&retval, sizeof(retval));
     return retval; /* ignored */
@@ -380 +380 @@
 {
     GLfloat local_params[1] = {0};
-    GLuint hwid = crStateGetProgramHWID(obj);
+    GLuint hwid = crStateGetProgramHWID(&cr_server.StateTracker, obj);
     (void) params;
 
     if (!hwid)
     {
-        hwid = crStateGetShaderHWID(obj);
+        hwid = crStateGetShaderHWID(&cr_server.StateTracker, obj);
         if (!hwid)
         {
@@ -399 +399 @@
 {
     GLint local_params[1] = {0};
-    GLuint hwid = crStateGetProgramHWID(obj);
+    GLuint hwid = crStateGetProgramHWID(&cr_server.StateTracker, obj);
     if (!hwid)
     {
-        hwid = crStateGetShaderHWID(obj);
+        hwid = crStateGetShaderHWID(&cr_server.StateTracker, obj);
         if (!hwid)
         {

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_getteximage.cpp

@@ -21 +21 @@
 
 #ifdef CR_ARB_pixel_buffer_object
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         GLvoid *pbo_offset;
@@ -104 +104 @@
 
 #ifdef CR_ARB_pixel_buffer_object
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         GLvoid *pbo_offset;
@@ -136 +136 @@
 {
 #ifdef CR_ARB_pixel_buffer_object
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         GLvoid *pbo_offset;

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

@@ -32 +32 @@
     GLenum err = cr_server.head_spu->dispatch_table.GetError();
 #endif
-    cr_server.head_spu->dispatch_table.ShaderSource(crStateGetShaderHWID(shader), count, string, length);
+    cr_server.head_spu->dispatch_table.ShaderSource(crStateGetShaderHWID(&cr_server.StateTracker, shader), count, string, length);
 #ifdef DEBUG_misha
     err = cr_server.head_spu->dispatch_table.GetError();
@@ -45 +45 @@
     GLint iCompileStatus = GL_FALSE;
 #endif
-    crStateCompileShader(shader);
-    cr_server.head_spu->dispatch_table.CompileShader(crStateGetShaderHWID(shader));
-#ifdef DEBUG_misha
-    cr_server.head_spu->dispatch_table.GetShaderiv(crStateGetShaderHWID(shader), GL_COMPILE_STATUS, &iCompileStatus);
+    crStateCompileShader(&cr_server.StateTracker, shader);
+    cr_server.head_spu->dispatch_table.CompileShader(crStateGetShaderHWID(&cr_server.StateTracker, shader));
+#ifdef DEBUG_misha
+    cr_server.head_spu->dispatch_table.GetShaderiv(crStateGetShaderHWID(&cr_server.StateTracker, shader), GL_COMPILE_STATUS, &iCompileStatus);
     Assert(iCompileStatus == GL_TRUE);
 #endif
@@ -56 +56 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteShader(GLuint shader)
 {
-    GLuint shaderHW = crStateGetShaderHWID(shader);
-    crStateDeleteShader(shader);
+    GLuint shaderHW = crStateGetShaderHWID(&cr_server.StateTracker, shader);
+    crStateDeleteShader(&cr_server.StateTracker, shader);
     if (shaderHW)
         cr_server.head_spu->dispatch_table.DeleteShader(shaderHW);
@@ -66 +66 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchAttachShader(GLuint program, GLuint shader)
 {
-    crStateAttachShader(program, shader);
-    cr_server.head_spu->dispatch_table.AttachShader(crStateGetProgramHWID(program), crStateGetShaderHWID(shader));
+    crStateAttachShader(&cr_server.StateTracker, program, shader);
+    cr_server.head_spu->dispatch_table.AttachShader(crStateGetProgramHWID(&cr_server.StateTracker, program),
+                                                    crStateGetShaderHWID(&cr_server.StateTracker, shader));
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchDetachShader(GLuint program, GLuint shader)
 {
-    crStateDetachShader(program, shader);
-    cr_server.head_spu->dispatch_table.DetachShader(crStateGetProgramHWID(program), crStateGetShaderHWID(shader));
+    crStateDetachShader(&cr_server.StateTracker, program, shader);
+    cr_server.head_spu->dispatch_table.DetachShader(crStateGetProgramHWID(&cr_server.StateTracker, program),
+                                                    crStateGetShaderHWID(&cr_server.StateTracker, shader));
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchLinkProgram(GLuint program)
 {
-    crStateLinkProgram(program);
-    cr_server.head_spu->dispatch_table.LinkProgram(crStateGetProgramHWID(program));
+    crStateLinkProgram(&cr_server.StateTracker, program);
+    cr_server.head_spu->dispatch_table.LinkProgram(crStateGetProgramHWID(&cr_server.StateTracker, program));
     CR_SERVER_DUMP_LINK_PROGRAM(program);
 }
@@ -85 +87 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchUseProgram(GLuint program)
 {
-    crStateUseProgram(program);
-    cr_server.head_spu->dispatch_table.UseProgram(crStateGetProgramHWID(program));
+    crStateUseProgram(&cr_server.StateTracker, program);
+    cr_server.head_spu->dispatch_table.UseProgram(crStateGetProgramHWID(&cr_server.StateTracker, program));
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteProgram(GLuint program)
 {
-    GLuint hwId = crStateGetProgramHWID(program);
-    crStateDeleteProgram(program);
+    GLuint hwId = crStateGetProgramHWID(&cr_server.StateTracker, program);
+    crStateDeleteProgram(&cr_server.StateTracker, program);
     if (hwId)
         cr_server.head_spu->dispatch_table.DeleteProgram(hwId);
@@ -101 +103 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchValidateProgram(GLuint program)
 {
-    crStateValidateProgram(program);
-    cr_server.head_spu->dispatch_table.ValidateProgram(crStateGetProgramHWID(program));
+    crStateValidateProgram(&cr_server.StateTracker, program);
+    cr_server.head_spu->dispatch_table.ValidateProgram(crStateGetProgramHWID(&cr_server.StateTracker, program));
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchBindAttribLocation(GLuint program, GLuint index, const char * name)
 {
-    crStateBindAttribLocation(program, index, name);
-    cr_server.head_spu->dispatch_table.BindAttribLocation(crStateGetProgramHWID(program), index, name);
+    crStateBindAttribLocation(&cr_server.StateTracker, program, index, name);
+    cr_server.head_spu->dispatch_table.BindAttribLocation(crStateGetProgramHWID(&cr_server.StateTracker, program), index, name);
 }
 
 void SERVER_DISPATCH_APIENTRY crServerDispatchDeleteObjectARB(VBoxGLhandleARB obj)
 {
-    GLuint hwid =  crStateDeleteObjectARB(obj);
+    GLuint hwid =  crStateDeleteObjectARB(&cr_server.StateTracker, obj);
 
     if (hwid)
@@ -124 +126 @@
 {
     GLint retval;
-    retval = cr_server.head_spu->dispatch_table.GetAttribLocation(crStateGetProgramHWID(program), name );
+    retval = cr_server.head_spu->dispatch_table.GetAttribLocation(crStateGetProgramHWID(&cr_server.StateTracker, program), name );
     crServerReturnValue( &retval, sizeof(retval) );
     return retval; /* WILL PROBABLY BE IGNORED */
@@ -135 +137 @@
     if (pname==GL_PROGRAM_OBJECT_ARB)
     {
-        retval = crStateGLSLProgramHWIDtoID(retval);
+        retval = crStateGLSLProgramHWIDtoID(&cr_server.StateTracker, retval);
     }
     crServerReturnValue( &retval, sizeof(retval) );
@@ -144 +146 @@
 {
     GLint retval;
-    retval = cr_server.head_spu->dispatch_table.GetUniformLocation(crStateGetProgramHWID(program), name);
+    retval = cr_server.head_spu->dispatch_table.GetUniformLocation(crStateGetProgramHWID(&cr_server.StateTracker, program), name);
     crServerReturnValue( &retval, sizeof(retval) );
     return retval; /* WILL PROBABLY BE IGNORED */
@@ -153 +155 @@
     GLint local_params[1] = {0};
     (void) params;
-    cr_server.head_spu->dispatch_table.GetProgramiv(crStateGetProgramHWID(program), pname, local_params);
+    cr_server.head_spu->dispatch_table.GetProgramiv(crStateGetProgramHWID(&cr_server.StateTracker, program), pname, local_params);
     crServerReturnValue( &(local_params[0]), 1*sizeof(GLint) );
 }
@@ -161 +163 @@
     GLint local_params[1] = {0};
     (void) params;
-    cr_server.head_spu->dispatch_table.GetShaderiv( crStateGetShaderHWID(shader), pname, local_params );
+    cr_server.head_spu->dispatch_table.GetShaderiv( crStateGetShaderHWID(&cr_server.StateTracker, shader), pname, local_params );
     crServerReturnValue( &(local_params[0]), 1*sizeof(GLint) );
 }
@@ -197 +199 @@
         pLocalProgs[i] = crServerTranslateProgramID(programs[i]);
     }
-    crStateDeleteProgramsARB(n, pLocalProgs);
+    crStateDeleteProgramsARB(&cr_server.StateTracker, n, pLocalProgs);
     cr_server.head_spu->dispatch_table.DeleteProgramsARB(n, pLocalProgs);
     crFree(pLocalProgs);

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

@@ -64 +64 @@
 
     list = TranslateListID( list );
-    crStateNewList( list, mode );
+    crStateNewList(&cr_server.StateTracker, list, mode );
     cr_server.head_spu->dispatch_table.NewList( list, mode );
 }
@@ -84 +84 @@
             fbFbo = bbFbo = 0;
         }
-        crStateQueryHWState(fbFbo, bbFbo);
+        crStateQueryHWState(&cr_server.StateTracker, fbFbo, bbFbo);
     }
 }
@@ -90 +90 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchEndList(void)
 {
-    CRContext *g = crStateGetCurrent();
+    CRContext *g = crStateGetCurrent(&cr_server.StateTracker);
     CRListsState *l = &(g->lists);
 
     cr_server.head_spu->dispatch_table.EndList();
-    crStateEndList();
+    crStateEndList(&cr_server.StateTracker);
 
 #ifndef IN_GUEST
@@ -272 +272 @@
 {
     list = TranslateListID( list );
-    crStateDeleteLists( list, range );
+    crStateDeleteLists(&cr_server.StateTracker, list, range );
     cr_server.head_spu->dispatch_table.DeleteLists( list, range );
 }

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

@@ -51 +51 @@
  */
 CRServer cr_server;
+DECLHIDDEN(PCRStateTracker) g_pStateTracker;
 
 int tearingdown = 0; /* can't be static */
@@ -124 +125 @@
 {
     CRContextInfo *c = (CRContextInfo *) data;
-    crStateDestroyContext(c->pContext);
+    crStateDestroyContext(&cr_server.StateTracker, c->pContext);
     if (c->CreateInfo.pszDpyName)
         crFree(c->CreateInfo.pszDpyName);
@@ -180 +181 @@
     }
 
-    crStateSetCurrent( NULL );
+    crStateSetCurrent(&cr_server.StateTracker, NULL);
 
     cr_server.curClient = NULL;
@@ -218 +219 @@
     if (!fContextsDeleted)
     {
-        fOldEnableDiff = crStateEnableDiffOnMakeCurrent(GL_FALSE);
+        fOldEnableDiff = crStateEnableDiffOnMakeCurrent(&cr_server.StateTracker, GL_FALSE);
         if(cr_server.MainContextInfo.pContext)
-            crStateMakeCurrent(cr_server.MainContextInfo.pContext);
-        crStateEnableDiffOnMakeCurrent(fOldEnableDiff);
+            crStateMakeCurrent(&cr_server.StateTracker, cr_server.MainContextInfo.pContext);
+        crStateEnableDiffOnMakeCurrent(&cr_server.StateTracker, fOldEnableDiff);
     }
 
@@ -270 +271 @@
 #endif
 
-    crStateDestroy();
+    crStateDestroy(&cr_server.StateTracker);
 
     crNetTearDown();
@@ -356 +357 @@
     cr_server.programTable = crAllocHashtable();
 
-    crStateInit();
+    crStateInit(&cr_server.StateTracker);
+    g_pStateTracker = &cr_server.StateTracker;
 
     crStateLimitsInit( &(cr_server.limits) );
@@ -393 +395 @@
     if (!cr_server.head_spu)
     {
-        crStateDestroy();
+        crStateDestroy(&cr_server.StateTracker);
         return GL_FALSE;
     }
@@ -399 +401 @@
     crServerInitDispatch();
     crServerInitTmpCtxDispatch();
-    crStateDiffAPI( &(cr_server.head_spu->dispatch_table) );
+    crStateDiffAPI(&cr_server.StateTracker, &(cr_server.head_spu->dispatch_table) );
 
 #ifdef VBOX_WITH_CRSERVER_DUMPER
@@ -410 +412 @@
 
     /*Check for PBO support*/
-    if (crStateGetCurrent()->extensions.ARB_pixel_buffer_object)
+    if (crStateGetCurrent(&cr_server.StateTracker)->extensions.ARB_pixel_buffer_object)
     {
         cr_server.bUsePBOForReadback=GL_TRUE;
@@ -1422 +1424 @@
     crVBoxServerBuildSaveStateGlobal(&Data);
 
-    rc = crStateSaveGlobals(pSSM);
+    rc = crStateSaveGlobals(&cr_server.StateTracker, pSSM);
     AssertRCReturn(rc, rc);
 
@@ -2084 +2086 @@
     }
 
-    rc = crStateLoadGlobals(pSSM, version);
+    rc = crStateLoadGlobals(&cr_server.StateTracker, pSSM, version);
     AssertLogRelRCReturn(rc, rc);
 
@@ -2604 +2606 @@
 
     cr_server.head_spu->dispatch_table.MakeCurrent(0, 0, 0);
-    crStateCleanupCurrent();
+    crStateCleanupCurrent(&cr_server.StateTracker);
 
     /* note: we need to clean all contexts, since otherwise renderspu leanup won't work,
@@ -2612 +2614 @@
     {
         cr_server.head_spu->dispatch_table.DestroyContext(cr_server.MainContextInfo.SpuContext);
-        crStateDestroyContext(cr_server.MainContextInfo.pContext);
+        crStateDestroyContext(&cr_server.StateTracker, cr_server.MainContextInfo.pContext);
         if (cr_server.MainContextInfo.CreateInfo.pszDpyName)
             crFree(cr_server.MainContextInfo.CreateInfo.pszDpyName);
@@ -2630 +2632 @@
     cr_server.currentMural = NULL;
 
-    crStateDestroy();
+    crStateDestroy(&cr_server.StateTracker);
 //    crStateCleanupCurrent();
 
@@ -2651 +2653 @@
 
 //    crStateSetCurrent(NULL);
-    crStateInit();
-    crStateDiffAPI( &(cr_server.head_spu->dispatch_table) );
+    crStateInit(&cr_server.StateTracker);
+    crStateDiffAPI(&cr_server.StateTracker, &(cr_server.head_spu->dispatch_table) );
 
     CrPMgrEnable();
@@ -3835 +3837 @@
 }
 
+void crVBoxServerDetachThread(void)
+{
+    crStateVBoxDetachThread(&cr_server.StateTracker);
+}
+
+void crVBoxServerAttachThread(void)
+{
+    crStateVBoxAttachThread(&cr_server.StateTracker);
+}
+
+
 #endif

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

@@ -328 +328 @@
   switch (target) {
     case GL_SHARE_CONTEXT_RESOURCES_CR:
-        crStateShareContext(value);
+        crStateShareContext(&cr_server.StateTracker, value);
         break;
     case GL_RCUSAGE_TEXTURE_SET_CR:
-        crStateSetTextureUsed(value, GL_TRUE);
+        crStateSetTextureUsed(&cr_server.StateTracker, value, GL_TRUE);
         break;
     case GL_RCUSAGE_TEXTURE_CLEAR_CR:
-        crStateSetTextureUsed(value, GL_FALSE);
+        crStateSetTextureUsed(&cr_server.StateTracker, value, GL_FALSE);
         break;
     case GL_PIN_TEXTURE_SET_CR:
-        crStatePinTexture(value, GL_TRUE);
+        crStatePinTexture(&cr_server.StateTracker, value, GL_TRUE);
         break;
     case GL_PIN_TEXTURE_CLEAR_CR:
-        crStatePinTexture(value, GL_FALSE);
+        crStatePinTexture(&cr_server.StateTracker, value, GL_FALSE);
         break;
     case GL_SHARED_DISPLAY_LISTS_CR:
@@ -502 +502 @@
             GLuint tID, fboID;
             GLenum status;
-            CRContext *ctx = crStateGetCurrent();
+            CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
 
             gl->GenTextures(1, &tID);
@@ -601 +601 @@
             GLint dRow;
             GLuint pboId, sRow;
-            CRContext *ctx = crStateGetCurrent();
+            CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
 
             gl->GenBuffersARB(1, &pboId);
@@ -897 +897 @@
     CR_BLITTER_CONTEXT Ctx;
     CRMuralInfo *mural;
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
     PVBOXVR_TEXTURE pDrawTex, pReadTex;
     VBOXVR_TEXTURE DrawTex, ReadTex;
@@ -992 +992 @@
                                    GLbitfield mask, GLenum filter)
 {
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
     bool fTryBlitter = false;
 #ifdef CR_CHECK_BLITS
@@ -1274 +1274 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchDrawBuffer( GLenum mode )
 {
-    crStateDrawBuffer( mode );
-
-    if (!crStateGetCurrent()->framebufferobject.drawFB)
+    crStateDrawBuffer(&cr_server.StateTracker, mode );
+
+    if (!crStateGetCurrent(&cr_server.StateTracker)->framebufferobject.drawFB)
     {
         if (mode == GL_FRONT || mode == GL_FRONT_LEFT || mode == GL_FRONT_RIGHT)
@@ -1362 +1362 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchReadBuffer( GLenum mode )
 {
-    crStateReadBuffer( mode );
+    crStateReadBuffer(&cr_server.StateTracker, mode );
 
     if (crServerIsRedirectedToFBO()
             && cr_server.curClient->currentMural->aidFBOs[0]
-            && !crStateGetCurrent()->framebufferobject.readFB)
+            && !crStateGetCurrent(&cr_server.StateTracker)->framebufferobject.readFB)
     {
         CRMuralInfo *mural = cr_server.curClient->currentMural;
@@ -1433 +1433 @@
 {
     GLenum retval, err;
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
     retval = ctx->error;
 
@@ -1453 +1453 @@
 crServerMakeTmpCtxCurrent( GLint window, GLint nativeWindow, GLint context )
 {
-    CRContext *pCtx = crStateGetCurrent();
+    CRContext *pCtx = crStateGetCurrent(&cr_server.StateTracker);
     CRContext *pCurCtx = NULL;
     GLuint idDrawFBO = 0, idReadFBO = 0;
@@ -1890 +1890 @@
 GLvoid crServerSpriteCoordReplEnable(GLboolean fEnable)
 {
-    CRContext *g = crStateGetCurrent();
+    CRContext *g = crStateGetCurrent(&cr_server.StateTracker);
     CRTextureState *t = &(g->texture);
     GLuint curTextureUnit = t->curTextureUnit;
@@ -1948 +1948 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchEnd( void )
 {
-    CRContext *g = crStateGetCurrent();
+    CRContext *g = crStateGetCurrent(&cr_server.StateTracker);
     GLenum mode = g->current.mode;
 
-    crStateEnd();
+    crStateEnd(&cr_server.StateTracker);
     cr_server.head_spu->dispatch_table.End();
 
@@ -1963 +1963 @@
 {
 #ifdef DEBUG
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
     SPUDispatchTable *gl = &cr_server.head_spu->dispatch_table;
 
@@ -2012 +2012 @@
     CR_SERVER_DUMP_DRAW_ENTER();
 
-    crStateBegin(mode);
+    crStateBegin(&cr_server.StateTracker, mode);
     cr_server.head_spu->dispatch_table.Begin(mode);
 }

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

@@ -477 +477 @@
         if (cr_server.curClient && cr_server.curClient->currentMural == mural)
         {
-            if (!crStateGetCurrent()->framebufferobject.drawFB)
+            CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
+
+            if (!ctx->framebufferobject.drawFB)
             {
                 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurDrawBuffer));
             }
-            if (!crStateGetCurrent()->framebufferobject.readFB)
+            if (!ctx->framebufferobject.readFB)
             {
                 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, CR_SERVER_FBO_FOR_IDX(mural, mural->iCurReadBuffer));
             }
 
-            crStateGetCurrent()->buffer.width = 0;
-            crStateGetCurrent()->buffer.height = 0;
+            ctx->buffer.width = 0;
+            ctx->buffer.height = 0;
         }
     }
@@ -494 +496 @@
         if (cr_server.curClient && cr_server.curClient->currentMural == mural)
         {
-            if (!crStateGetCurrent()->framebufferobject.drawFB)
+            CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
+
+            if (!ctx->framebufferobject.drawFB)
             {
                 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_DRAW_FRAMEBUFFER, 0);
             }
-            if (!crStateGetCurrent()->framebufferobject.readFB)
+            if (!ctx->framebufferobject.readFB)
             {
                 cr_server.head_spu->dispatch_table.BindFramebufferEXT(GL_READ_FRAMEBUFFER, 0);
             }
 
-            crStateGetCurrent()->buffer.width = mural->width;
-            crStateGetCurrent()->buffer.height = mural->height;
+            ctx->buffer.width = mural->width;
+            ctx->buffer.height = mural->height;
         }
     }
@@ -513 +517 @@
 static void crServerCreateMuralFBO(CRMuralInfo *mural)
 {
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
     GLuint uid, i;
     GLenum status;
@@ -540 +544 @@
     /*Color texture*/
 
-    if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
     {
         gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
@@ -605 +609 @@
     gl->BindFramebufferEXT(GL_READ_FRAMEBUFFER, uid);
 
-    if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
     {
         gl->BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, ctx->bufferobject.unpackBuffer->hwid);
     }
 
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         gl->BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, ctx->bufferobject.packBuffer->hwid);
@@ -825 +829 @@
 void crServerMuralFBOSwapBuffers(CRMuralInfo *mural)
 {
-    CRContext *ctx = crStateGetCurrent();
+    CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
     GLint iOldCurDrawBuffer = mural->iCurDrawBuffer;
     GLint iOldCurReadBuffer = mural->iCurReadBuffer;

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_projmatrix.cpp

@@ -44 +44 @@
     const GLenum matMode = cr_server.curClient->currentCtxInfo->pContext->transform.matrixMode;
 
-    crStateLoadMatrixf( m );
+    crStateLoadMatrixf(&cr_server.StateTracker, m );
 
     if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
@@ -60 +60 @@
     const GLenum matMode = cr_server.curClient->currentCtxInfo->pContext->transform.matrixMode;
 
-    crStateLoadMatrixd( m );
+    crStateLoadMatrixd(&cr_server.StateTracker, m );
 
     if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
@@ -79 +79 @@
         /* load the overriding projection matrix */
         int eye = crServerGetCurrentEye();
-        crStateLoadMatrix( &cr_server.projectionMatrix[eye] );
+        crStateLoadMatrix(&cr_server.StateTracker, &cr_server.projectionMatrix[eye] );
     }
     else {
         /* the usual case */
-        crStateMultMatrixf( m );
+        crStateMultMatrixf(&cr_server.StateTracker, m );
         cr_server.head_spu->dispatch_table.MultMatrixf( m );
     }
@@ -96 +96 @@
         /* load the overriding projection matrix */
         int eye = crServerGetCurrentEye();
-        crStateLoadMatrix( &cr_server.projectionMatrix[eye] );
+        crStateLoadMatrix(&cr_server.StateTracker, &cr_server.projectionMatrix[eye] );
     }
     else {
         /* the usual case */
-        crStateMultMatrixd( m );
+        crStateMultMatrixd(&cr_server.StateTracker, m );
         cr_server.head_spu->dispatch_table.MultMatrixd( m );
     }
@@ -111 +111 @@
     const GLenum matMode = cr_server.curClient->currentCtxInfo->pContext->transform.matrixMode;
 
-    crStateLoadIdentity();
+    crStateLoadIdentity(&cr_server.StateTracker);
 
     if (matMode == GL_MODELVIEW && cr_server.viewOverride) {
@@ -322 +322 @@
 
     /* pass through */
-    crStateProgramStringARB(target, format, len, string);
+    crStateProgramStringARB(&cr_server.StateTracker, target, format, len, string);
     cr_server.head_spu->dispatch_table.ProgramStringARB(target, format, len, string);
 }
@@ -364 +364 @@
 
     /* pass through */
-    crStateLoadProgramNV(target, id, len, string);
+    crStateLoadProgramNV(&cr_server.StateTracker, target, id, len, string);
     cr_server.head_spu->dispatch_table.LoadProgramNV(target, id, len, string);
 }
@@ -381 +381 @@
 
     /* pass through */
-    crStateBindProgramARB(target, id);
+    crStateBindProgramARB(&cr_server.StateTracker, target, id);
     cr_server.head_spu->dispatch_table.BindProgramARB(target, id);
 }
@@ -395 +395 @@
     }
     /* pass through */
-    crStateBindProgramNV(target, id);
+    crStateBindProgramNV(&cr_server.StateTracker, target, id);
     cr_server.head_spu->dispatch_table.BindProgramNV(target, id);
 }

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_readpixels.cpp

@@ -33 +33 @@
 
 #ifdef CR_ARB_pixel_buffer_object
-    if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
     {
         GLvoid *pbo_offset;

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_rpw.cpp

@@ -470 +470 @@
     pContext = cr_server.currentCtxInfo->pContext;
 
-    if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
     {
         cr_server.head_spu->dispatch_table.BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
@@ -490 +490 @@
     pEntry->iTexDraw = -pEntry->iTexDraw;
 
-    if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))
     {
         cr_server.head_spu->dispatch_table.BindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pContext->bufferobject.unpackBuffer->hwid);
@@ -504 +504 @@
         }
 
-        if (crStateIsBufferBound(GL_PIXEL_PACK_BUFFER_ARB))
+        if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_PACK_BUFFER_ARB))
         {
             cr_server.head_spu->dispatch_table.BindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pContext->bufferobject.packBuffer->hwid);

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

@@ -62 +62 @@
         CRASSERT(tablesize/sizeof(%s)==1);
         texid = (GLuint) *get_values;
-        *get_values = (%s) crStateTextureHWIDtoID(texid);
+        *get_values = (%s) crStateTextureHWIDtoID(&cr_server.StateTracker, texid);
     }
     else if (GL_CURRENT_PROGRAM==pname)
@@ -69 +69 @@
         CRASSERT(tablesize/sizeof(%s)==1);
         programid = (GLuint) *get_values;
-        *get_values = (%s) crStateGLSLProgramHWIDtoID(programid);
+        *get_values = (%s) crStateGLSLProgramHWIDtoID(&cr_server.StateTracker, programid);
     }
     else if (GL_FRAMEBUFFER_BINDING_EXT==pname
@@ -85 +85 @@
         else
         {
-                fboid = crStateFBOHWIDtoID(fboid);
+                fboid = crStateFBOHWIDtoID(&cr_server.StateTracker, fboid);
         }
         *get_values = (%s) fboid;
@@ -93 +93 @@
         if (crServerIsRedirectedToFBO()
             && CR_SERVER_FBO_FOR_IDX(cr_server.curClient->currentMural, cr_server.curClient->currentMural->iCurReadBuffer)
-            && !crStateGetCurrent()->framebufferobject.readFB)
+            && !crStateGetCurrent(&cr_server.StateTracker)->framebufferobject.readFB)
         {
-            *get_values = (%s) crStateGetCurrent()->buffer.readBuffer;
-            Assert(crStateGetCurrent()->buffer.readBuffer == GL_BACK || crStateGetCurrent()->buffer.readBuffer == GL_FRONT);
+            *get_values = (%s) crStateGetCurrent(&cr_server.StateTracker)->buffer.readBuffer;
+            Assert(crStateGetCurrent(&cr_server.StateTracker)->buffer.readBuffer == GL_BACK || crStateGetCurrent(&cr_server.StateTracker)->buffer.readBuffer == GL_FRONT);
         }
     }
@@ -103 +103 @@
         if (crServerIsRedirectedToFBO()
             && CR_SERVER_FBO_FOR_IDX(cr_server.curClient->currentMural, cr_server.curClient->currentMural->iCurDrawBuffer)
-            && !crStateGetCurrent()->framebufferobject.drawFB)
+            && !crStateGetCurrent(&cr_server.StateTracker)->framebufferobject.drawFB)
         {
-            *get_values = (%s) crStateGetCurrent()->buffer.drawBuffer;
-            Assert(crStateGetCurrent()->buffer.drawBuffer == GL_BACK || crStateGetCurrent()->buffer.drawBuffer == GL_FRONT);
+            *get_values = (%s) crStateGetCurrent(&cr_server.StateTracker)->buffer.drawBuffer;
+            Assert(crStateGetCurrent(&cr_server.StateTracker)->buffer.drawBuffer == GL_BACK || crStateGetCurrent(&cr_server.StateTracker)->buffer.drawBuffer == GL_FRONT);
         }
     }
@@ -114 +114 @@
         CRASSERT(tablesize/sizeof(%s)==1);
         rbid = (GLuint) *get_values;
-        *get_values = (%s) crStateRBOHWIDtoID(rbid);
+        *get_values = (%s) crStateRBOHWIDtoID(&cr_server.StateTracker, rbid);
     }
     else if (GL_ARRAY_BUFFER_BINDING_ARB==pname
@@ -131 +131 @@
         CRASSERT(tablesize/sizeof(%s)==1);
         bufid = (GLuint) *get_values;
-        *get_values = (%s) crStateBufferHWIDtoID(bufid);
+        *get_values = (%s) crStateBufferHWIDtoID(&cr_server.StateTracker, bufid);
     }
     else if (GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS==pname)

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_stream.cpp

@@ -580 +580 @@
         UnpackerState.pDispatchTbl     = &(cr_server.dispatch);
         UnpackerState.rcUnpack         = VINF_SUCCESS;
+        UnpackerState.pStateTracker    = &cr_server.StateTracker;
 
         cr_server.pUnpackerState = &UnpackerState;
@@ -695 +696 @@
         UnpackerState.pDispatchTbl     = &(cr_server.dispatch);
         UnpackerState.rcUnpack         = VINF_SUCCESS;
+        UnpackerState.pStateTracker    = &cr_server.StateTracker;
 
         cr_server.pUnpackerState = &UnpackerState;

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_texture.cpp

@@ -39 +39 @@
 #if defined(CR_ARB_pixel_buffer_object)
 # define CR_CHECKBUFFER(name, checkptr)                     \
-    if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))   \
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))   \
     {                                                       \
         CR_FIXPTR();                                        \
@@ -53 +53 @@
 #if defined(CR_ARB_pixel_buffer_object) && !defined(CR_STATE_NO_TEXTURE_IMAGE_STORE)
 # define CR_FINISHBUFFER()                                                                  \
-    if (crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB))                                   \
+    if (crStateIsBufferBound(&cr_server.StateTracker, GL_PIXEL_UNPACK_BUFFER_ARB))          \
     {                                                                                       \
         if (!cr_server.head_spu->dispatch_table.UnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB)) \
@@ -64 +64 @@
 #endif
 
-#define CR_FUNC_SUBIMAGE(name, def, call, ptrname)          \
-void SERVER_DISPATCH_APIENTRY                               \
-crServerDispatch##name def                                  \
-{                                                           \
-    const GLvoid *realptr = ptrname;                        \
-    CR_CHECKBUFFER(name, CR_CHECKPTR(name))                 \
-    crState##name call;                                     \
-    CR_FINISHBUFFER()                                       \
-    realptr = ptrname;                                      \
-    cr_server.head_spu->dispatch_table.name call;           \
-}
-
-#define CR_FUNC_IMAGE(name, def, call, ptrname)             \
-void SERVER_DISPATCH_APIENTRY                               \
-crServerDispatch##name def                                  \
-{                                                           \
-    const GLvoid *realptr = ptrname;                        \
-    CR_CHECKBUFFER(name, CR_NOTHING())                      \
-    crState##name call;                                     \
-    CR_FINISHBUFFER()                                       \
-    realptr = ptrname;                                      \
-    cr_server.head_spu->dispatch_table.name call;           \
+#define CR_FUNC_SUBIMAGE(name, def, state_call, call, ptrname)          \
+void SERVER_DISPATCH_APIENTRY                                           \
+crServerDispatch##name def                                              \
+{                                                                       \
+    const GLvoid *realptr = ptrname;                                    \
+    CR_CHECKBUFFER(name, CR_CHECKPTR(name))                             \
+    crState##name state_call;                                           \
+    CR_FINISHBUFFER()                                                   \
+    realptr = ptrname;                                                  \
+    cr_server.head_spu->dispatch_table.name call;                       \
+}
+
+#define CR_FUNC_IMAGE(name, def, state_call, call, ptrname)             \
+void SERVER_DISPATCH_APIENTRY                                           \
+crServerDispatch##name def                                              \
+{                                                                       \
+    const GLvoid *realptr = ptrname;                                    \
+    CR_CHECKBUFFER(name, CR_NOTHING())                                  \
+    crState##name state_call;                                           \
+    CR_FINISHBUFFER()                                                   \
+    realptr = ptrname;                                                  \
+    cr_server.head_spu->dispatch_table.name call;                       \
 }
 
@@ -91 +91 @@
 CR_FUNC_SUBIMAGE(CompressedTexSubImage1DARB,
     (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imagesize, const GLvoid * data),
+    (&cr_server.StateTracker, target, level, xoffset, width, format, imagesize, realptr),
     (target, level, xoffset, width, format, imagesize, realptr), data)
 
 CR_FUNC_SUBIMAGE(CompressedTexSubImage2DARB,
     (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imagesize, const GLvoid * data),
+    (&cr_server.StateTracker, target, level, xoffset, yoffset, width, height, format, imagesize, realptr),
     (target, level, xoffset, yoffset, width, height, format, imagesize, realptr), data)
 
 CR_FUNC_SUBIMAGE(CompressedTexSubImage3DARB,
     (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imagesize, const GLvoid * data),
+    (&cr_server.StateTracker, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imagesize, realptr),
     (target, level, xoffset, yoffset, zoffset, width, height, depth, format, imagesize, realptr), data)
 
 CR_FUNC_IMAGE(CompressedTexImage1DARB,
     (GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imagesize, const GLvoid * data),
+    (&cr_server.StateTracker, target, level, internalFormat, width, border, imagesize, realptr),
     (target, level, internalFormat, width, border, imagesize, realptr), data)
 
 CR_FUNC_IMAGE(CompressedTexImage2DARB,
     (GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imagesize, const GLvoid * data),
+    (&cr_server.StateTracker, target, level, internalFormat, width, height, border, imagesize, realptr),
     (target, level, internalFormat, width, height, border, imagesize, realptr), data)
 
 CR_FUNC_IMAGE(CompressedTexImage3DARB,
     (GLenum target, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imagesize, const GLvoid * data),
+    (&cr_server.StateTracker, target, level, internalFormat, width, height, depth, border, imagesize, realptr),
     (target, level, internalFormat, width, height, depth, border, imagesize, realptr), data)
 #endif
@@ -116 +122 @@
 CR_FUNC_SUBIMAGE(TexSubImage1D,
     (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid * pixels),
+    (&cr_server.StateTracker, target, level, xoffset, width, format, type, realptr),
     (target, level, xoffset, width, format, type, realptr), pixels)
 
 CR_FUNC_SUBIMAGE(TexSubImage2D,
     (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid * pixels),
+    (&cr_server.StateTracker, target, level, xoffset, yoffset, width, height, format, type, realptr),
     (target, level, xoffset, yoffset, width, height, format, type, realptr), pixels)
 
 CR_FUNC_SUBIMAGE(TexSubImage3D,
     (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid * pixels),
+    (&cr_server.StateTracker, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, realptr),
     (target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, realptr), pixels)
 
 CR_FUNC_IMAGE(TexImage1D,
     (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid * pixels),
+    (&cr_server.StateTracker, target, level, internalFormat, width, border, format, type, realptr),
     (target, level, internalFormat, width, border, format, type, realptr), pixels)
 
 CR_FUNC_IMAGE(TexImage2D,
     (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * pixels),
+    (&cr_server.StateTracker, target, level, internalFormat, width, height, border, format, type, realptr),
     (target, level, internalFormat, width, height, border, format, type, realptr), pixels)
 
 CR_FUNC_IMAGE(TexImage3D,
     (GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid * pixels),
+    (&cr_server.StateTracker, target, level, internalFormat, width, height, depth, border, format, type, realptr),
     (target, level, internalFormat, width, height, depth, border, format, type, realptr), pixels)
 
@@ -141 +153 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnvf( GLenum target, GLenum pname, GLfloat param )
 {
-    crStateTexEnvf( target, pname, param );
+    crStateTexEnvf(&cr_server.StateTracker, target, pname, param );
     if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
         CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnvf( target, pname, param ););
@@ -148 +160 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnvfv( GLenum target, GLenum pname, const GLfloat * params )
 {
-    crStateTexEnvfv( target, pname, params );
+    crStateTexEnvfv(&cr_server.StateTracker, target, pname, params );
     if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
         CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnvfv( target, pname, params ););
@@ -155 +167 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnvi( GLenum target, GLenum pname, GLint param )
 {
-    crStateTexEnvi( target, pname, param );
+    crStateTexEnvi(&cr_server.StateTracker, target, pname, param );
     if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
         CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnvi( target, pname, param ););
@@ -162 +174 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchTexEnviv( GLenum target, GLenum pname, const GLint * params )
 {
-    crStateTexEnviv( target, pname, params );
+    crStateTexEnviv(&cr_server.StateTracker, target, pname, params );
     if (GL_POINT_SPRITE != target && pname != GL_COORD_REPLACE)
         CR_GLERR_CHECK(cr_server.head_spu->dispatch_table.TexEnviv( target, pname, params ););
@@ -175 +187 @@
         cr_server.head_spu->dispatch_table.GetTexEnvfv( target, pname, local_params );
     else
-        crStateGetTexEnvfv( target, pname, local_params );
+        crStateGetTexEnvfv(&cr_server.StateTracker, target, pname, local_params );
 
     cComponents = RT_MIN(crStateHlpComponentsCount(pname), RT_ELEMENTS(local_params));
@@ -189 +201 @@
         cr_server.head_spu->dispatch_table.GetTexEnviv( target, pname, local_params );
     else
-        crStateGetTexEnviv( target, pname, local_params );
+        crStateGetTexEnviv(&cr_server.StateTracker, target, pname, local_params );
 
     cComponents = RT_MIN(crStateHlpComponentsCount(pname), RT_ELEMENTS(local_params));
@@ -197 +209 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchBindTexture( GLenum target, GLuint texture )
 {
-    crStateBindTexture( target, texture );
-    cr_server.head_spu->dispatch_table.BindTexture(target, crStateGetTextureHWID(texture));
+    crStateBindTexture(&cr_server.StateTracker, target, texture );
+    cr_server.head_spu->dispatch_table.BindTexture(target, crStateGetTextureHWID(&cr_server.StateTracker, texture));
 }
 
@@ -223 +235 @@
     for (i = 0; i < n; i++)
     {
-        newTextures[i] = crStateGetTextureHWID(textures[i]);
+        newTextures[i] = crStateGetTextureHWID(&cr_server.StateTracker, textures[i]);
     }
 
@@ -232 +244 @@
 
 
-    crStateDeleteTextures(n, textures);
+    crStateDeleteTextures(&cr_server.StateTracker, n, textures);
     cr_server.head_spu->dispatch_table.DeleteTextures(n, newTextures);
     crFree(newTextures);
@@ -257 +269 @@
     }
 
-    crStatePrioritizeTextures(n, textures, priorities);
+    crStatePrioritizeTextures(&cr_server.StateTracker, n, textures, priorities);
 
     for (i = 0; i < n; i++)
     {
-        newTextures[i] = crStateGetTextureHWID(textures[i]);
+        newTextures[i] = crStateGetTextureHWID(&cr_server.StateTracker, textures[i]);
     }
 
@@ -273 +285 @@
 {
     GLboolean retval;
-    retval = cr_server.head_spu->dispatch_table.IsTexture(crStateGetTextureHWID(texture));
+    retval = cr_server.head_spu->dispatch_table.IsTexture(crStateGetTextureHWID(&cr_server.StateTracker, texture));
     crServerReturnValue( &retval, sizeof(retval) );
     return retval; /* WILL PROBABLY BE IGNORED */
@@ -313 +325 @@
     for (i = 0; i < n; i++)
     {
-        textures2[i] = crStateGetTextureHWID(textures[i]);
+        textures2[i] = crStateGetTextureHWID(&cr_server.StateTracker, textures[i]);
     }
     retval = cr_server.head_spu->dispatch_table.AreTexturesResident(n, textures2, res);

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_viewport.cpp

@@ -276 +276 @@
 void SERVER_DISPATCH_APIENTRY crServerDispatchViewport( GLint x, GLint y, GLsizei width, GLsizei height )
 {
-        CRContext *ctx = crStateGetCurrent();
+        CRContext *ctx = crStateGetCurrent(&cr_server.StateTracker);
 
         if (ctx->viewport.viewportX != x ||
@@ -284 +284 @@
                  /* Note -- If there are tiles, this will be overridden in the 
                         * process of decoding the BoundsInfo packet, so no worries. */
-                 crStateViewport( x, y, width, height );
+                 crStateViewport(&cr_server.StateTracker, x, y, width, height );
         }
 

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_window.cpp

@@ -351 +351 @@
             && !mural->fRedirected)
     {
-        crStateGetCurrent()->buffer.width = mural->width;
-        crStateGetCurrent()->buffer.height = mural->height;
+        crStateGetCurrent(&cr_server.StateTracker)->buffer.width = mural->width;
+        crStateGetCurrent(&cr_server.StateTracker)->buffer.height = mural->height;
     }
 

trunk/src/VBox/HostServices/SharedOpenGL/crserverlib/server_winpos.cpp

@@ -9 +9 @@
 static void crServerWindowPos( GLfloat x, GLfloat y, GLfloat z )
 {
-        crStateWindowPos3fARB(x, y, z);
+        crStateWindowPos3fARB(&cr_server.StateTracker, x, y, z);
         cr_server.head_spu->dispatch_table.WindowPos3fARB(x, y, z);
 }