Changeset 51313 in vbox

Timestamp:

May 20, 2014 7:12:20 PM (10 years ago)

Author:

vboxsync

Message:

crOpenGL: bugfixes and work-arounds for wine issues

Location:

trunk/src/VBox

Files:

• Additions/WINNT/Graphics/Wine_new/Makefile.kmk (modified) (1 diff)
• Additions/WINNT/Graphics/Wine_new/wined3d/context.c (modified) (1 diff)
• Additions/WINNT/Graphics/Wine_new/wined3d/device.c (modified) (1 diff)
• Additions/WINNT/Graphics/Wine_new/wined3d/state.c (modified) (2 diffs)
• Additions/WINNT/Graphics/Wine_new/wined3d/wined3d_gl.h (modified) (1 diff)
• Additions/common/crOpenGL/pack/packspu.h (modified) (3 diffs)
• Additions/common/crOpenGL/pack/packspu_client.c (modified) (22 diffs)
• Additions/common/crOpenGL/pack/packspu_context.c (modified) (2 diffs)
• Additions/common/crOpenGL/pack/packspu_get.py (modified) (3 diffs)
• Additions/common/crOpenGL/pack/packspu_init.c (modified) (1 diff)
• Additions/common/crOpenGL/pack/packspu_misc.c (modified) (2 diffs)
• Additions/common/crOpenGL/pack/packspu_net.c (modified) (1 diff)
• GuestHost/OpenGL/include/chromium.h (modified) (1 diff)
• GuestHost/OpenGL/include/state/cr_current.h (modified) (2 diffs)
• GuestHost/OpenGL/packer/pack_client.c (modified) (13 diffs)
• GuestHost/OpenGL/packer/pack_currentheader.py (modified) (1 diff)
• GuestHost/OpenGL/packer/pack_currenttypes.py (modified) (1 diff)
• GuestHost/OpenGL/packer/pack_program.c (modified) (11 diffs)
• GuestHost/OpenGL/packer/packer.py (modified) (1 diff)
• GuestHost/OpenGL/state_tracker/state_client.c (modified) (2 diffs)
• GuestHost/OpenGL/state_tracker/state_current.c (modified) (1 diff)
• GuestHost/OpenGL/state_tracker/state_current.py (modified) (1 diff)

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/Makefile.kmk

@@ -176 +176 @@
         VBOX_WITH_WINE_FIX_SURFUPDATA \
         VBOX_WITH_WINE_FIX_CURVBO \
-        VBOX_WITH_WINE_FIX_ZEROVERTATTR \
         VBOX_WITH_WINE_FIX_FTOA \
         VBOX_WITH_WINE_DBG

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/wined3d/context.c

@@ -1919 +1919 @@
      * this is a kinda hack, but it is needed since our ogl driver currently does not support ShareLists */
     pglChromiumParameteriCR(GL_SHARE_CONTEXT_RESOURCES_CR, GL_TRUE);
+    pglChromiumParameteriCR(GL_CHECK_ZERO_VERT_ARRT, GL_TRUE);
 # if defined(VBOX_WINE_WITH_SINGLE_CONTEXT) || defined(VBOX_WINE_WITH_SINGLE_SWAPCHAIN_CONTEXT)
     pglChromiumParameteriCR(GL_FLUSH_ON_THREAD_SWITCH_CR,  GL_TRUE);

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/wined3d/device.c

@@ -1341 +1341 @@
     gl_info = context->gl_info;
 
+#ifdef VBOX_WITH_WINE_FIX_ZEROVERTATTR
     zv_destroy(device);
+#endif
 
     if (device->logo_surface)

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/wined3d/state.c

@@ -4136 +4136 @@
 #endif
             {
+#ifdef DEBUG_misha
+                Assert(i);
+#endif
 
             if (context->numbered_array_mask & (1 << i))
@@ -4225 +4228 @@
 #endif
             {
+#ifdef DEBUG_misha
+                Assert(i);
+#endif
 
             if (context->numbered_array_mask & (1 << i)) unload_numbered_array(context, i);

trunk/src/VBox/Additions/WINNT/Graphics/Wine_new/wined3d/wined3d_gl.h

@@ -189 +189 @@
 /*configures host to create windows initially hidden*/
 #define GL_HOST_WND_CREATED_HIDDEN_CR 0x8B2B
+
+/* enable zero vertex attribute generation to work around wine bug */
+#define GL_CHECK_ZERO_VERT_ARRT       0x8B30
 
 typedef void (WINE_GLAPI *PGLFNCHROMIUMPARAMETERUCR)(GLenum param, GLint value);

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

@@ -28 +28 @@
 typedef struct thread_info_t ThreadInfo;
 typedef struct context_info_t ContextInfo;
+typedef struct zvabuffer_info_t ZvaBufferInfo;
+
+struct zvabuffer_info_t
+{
+    /* GL_ARRAY_BUFFER_ARB buffer */
+    GLuint idBuffer;
+    /* buffer length */
+    GLuint cbBuffer;
+    /* number of values stored in the buffer currently */
+    GLuint cValues;
+    /* current buffer value */
+    union
+    {
+        GLfloat f[4];
+        GLuint ui[4];
+        GLubyte ub[4];
+        GLshort s[4];
+        GLushort us[4];
+    } Value;
+};
 
 struct thread_info_t {
@@ -48 +68 @@
     GLint serverCtx;         /* context ID returned by server */
     GLboolean  fAutoFlush;
+    GLboolean  fCheckZerroVertAttr;
     ThreadInfo *currentThread;
+    ZvaBufferInfo zvaBufferInfo;
     GLubyte glVersion[100];     /* GL_VERSION string */
     GLubyte pszRealVendor[100];
@@ -76 +98 @@
 #endif
 
-#ifdef VBOX_WITH_CRPACKSPU_DUMPER
     SPUDispatchTable self;
 
+#ifdef VBOX_WITH_CRPACKSPU_DUMPER
     CR_RECORDER Recorder;
     CR_DBGPRINT_DUMPER Dumper;

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

@@ -9 +9 @@
 #include "cr_glstate.h"
 #include "packspu_proto.h"
+#include "cr_mem.h"
 
 void PACKSPU_APIENTRY packspu_FogCoordPointerEXT( GLenum type, GLsizei stride, const GLvoid *pointer )
@@ -173 +174 @@
 }
 
+#ifdef DEBUG_misha
+/* debugging */
+//# define CR_FORCE_ZVA_SERVER_ARRAY
+#endif
+# define CR_FORCE_ZVA_EXPAND
+
+
+GLboolean packspuZvaCreate(ContextInfo *pCtx, const GLfloat *pValue, GLuint cValues)
+{
+    ZvaBufferInfo *pInfo = &pCtx->zvaBufferInfo;
+    GLuint cbValue = 4 * sizeof (*pValue);
+    GLuint cbValues = cValues * cbValue;
+    GLfloat *pBuffer;
+    uint8_t *pu8Buf;
+    GLuint i;
+
+    /* quickly sort out if we can use the current value */
+    if (pInfo->idBuffer
+            && pInfo->cValues >= cValues
+            && !memcmp(pValue, &pInfo->Value, cbValue))
+        return GL_FALSE;
+
+    pBuffer = (GLfloat*)crAlloc(cbValues);
+    if (!pBuffer)
+    {
+        WARN(("crAlloc for pBuffer failed"));
+        return GL_FALSE;
+    }
+
+    pu8Buf = (uint8_t *)pBuffer;
+    for (i = 0; i < cValues; ++i)
+    {
+        memcpy(pu8Buf, pValue, cbValue);
+        pu8Buf += cbValue;
+    }
+
+    /* */
+    if (!pInfo->idBuffer)
+    {
+        pack_spu.self.GenBuffersARB(1, &pInfo->idBuffer);
+        Assert(pInfo->idBuffer);
+    }
+
+    pack_spu.self.BindBufferARB(GL_ARRAY_BUFFER_ARB, pInfo->idBuffer);
+
+    if (pInfo->cbBuffer < cbValues)
+    {
+        pack_spu.self.BufferDataARB(GL_ARRAY_BUFFER_ARB, cbValues, pBuffer, GL_DYNAMIC_DRAW_ARB);
+        pInfo->cbBuffer = cbValues;
+    }
+    else
+    {
+        pack_spu.self.BufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, cbValues, pBuffer);
+    }
+
+    pInfo->cValues = cValues;
+    memcpy(&pInfo->Value, pValue, cbValue);
+
+    crFree(pBuffer);
+
+    return GL_TRUE;
+}
+
+typedef struct
+{
+    ContextInfo *pCtx;
+    GLuint idBuffer;
+    CRClientPointer cp;
+} CR_ZVA_RESTORE_CTX;
+
+void packspuZvaEnable(ContextInfo *pCtx, const GLfloat *pValue, GLuint cValues, CR_ZVA_RESTORE_CTX *pRestoreCtx)
+{
+    CRContext *g = pCtx->clientState;
+
+    Assert(0);
+
+#ifdef DEBUG
+    {
+        CRContext *pCurState = crStateGetCurrent();
+
+        Assert(g == pCurState);
+    }
+#endif
+
+    pRestoreCtx->pCtx = pCtx;
+    pRestoreCtx->idBuffer = g->bufferobject.arrayBuffer ? g->bufferobject.arrayBuffer->id : 0;
+    pRestoreCtx->cp = g->client.array.a[0];
+
+    Assert(!pRestoreCtx->cp.enabled);
+
+    /* buffer ref count mechanism does not work actually atm,
+     * still ensure the buffer does not get destroyed if we fix it in the future */
+    if (pRestoreCtx->cp.buffer)
+        pRestoreCtx->cp.buffer->refCount++;
+
+    packspuZvaCreate(pCtx, pValue, cValues);
+
+    pack_spu.self.BindBufferARB(GL_ARRAY_BUFFER_ARB, pCtx->zvaBufferInfo.idBuffer);
+
+    pack_spu.self.VertexAttribPointerARB(0, 4, GL_FLOAT,
+            GL_FALSE, /*normalized*/
+            0, /*stride*/
+            NULL /*addr*/);
+
+    pack_spu.self.EnableVertexAttribArrayARB(0);
+}
+
+void packspuZvaDisable(CR_ZVA_RESTORE_CTX *pRestoreCtx)
+{
+    if (pRestoreCtx->cp.buffer)
+        pack_spu.self.BindBufferARB(GL_ARRAY_BUFFER_ARB, pRestoreCtx->cp.buffer->id);
+    else
+        pack_spu.self.BindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
+
+    pack_spu.self.VertexAttribPointerARB(0, pRestoreCtx->cp.size, pRestoreCtx->cp.type,
+            pRestoreCtx->cp.normalized, /*normalized*/
+            pRestoreCtx->cp.stride, /*stride*/
+            pRestoreCtx->cp.p);
+
+    if (pRestoreCtx->cp.enabled)
+        pack_spu.self.EnableVertexAttribArrayARB(0);
+    else
+        pack_spu.self.DisableVertexAttribArrayARB(0);
+
+    if (pRestoreCtx->cp.buffer)
+    {
+        if (pRestoreCtx->cp.buffer->id != pRestoreCtx->idBuffer)
+            pack_spu.self.BindBufferARB(GL_ARRAY_BUFFER_ARB, pRestoreCtx->idBuffer);
+
+        /* we have increased the refcount above, decrease it back */
+        pRestoreCtx->cp.buffer->refCount--;
+    }
+    else
+    {
+        if (pRestoreCtx->idBuffer)
+            pack_spu.self.BindBufferARB(GL_ARRAY_BUFFER_ARB, pRestoreCtx->idBuffer);
+    }
+
+#ifdef DEBUG
+    {
+        CRContext *g = pRestoreCtx->pCtx->clientState;
+        CRContext *pCurState = crStateGetCurrent();
+
+        Assert(g == pCurState);
+
+        Assert(pRestoreCtx->cp.p == g->client.array.a[0].p);
+        Assert(pRestoreCtx->cp.size == g->client.array.a[0].size);
+        Assert(pRestoreCtx->cp.type == g->client.array.a[0].type);
+        Assert(pRestoreCtx->cp.stride == g->client.array.a[0].stride);
+        Assert(pRestoreCtx->cp.enabled == g->client.array.a[0].enabled);
+        Assert(pRestoreCtx->cp.normalized == g->client.array.a[0].normalized);
+        Assert(pRestoreCtx->cp.bytesPerIndex == g->client.array.a[0].bytesPerIndex);
+# ifdef CR_ARB_vertex_buffer_object
+        Assert(pRestoreCtx->cp.buffer == g->client.array.a[0].buffer);
+# endif
+# ifdef CR_EXT_compiled_vertex_array
+        Assert(pRestoreCtx->cp.locked == g->client.array.a[0].locked);
+# endif
+        Assert(pRestoreCtx->idBuffer == (g->bufferobject.arrayBuffer ? g->bufferobject.arrayBuffer->id : 0));
+    }
+#endif
+}
 
 void PACKSPU_APIENTRY
@@ -180 +343 @@
 #if 1
     GLboolean serverArrays = GL_FALSE;
+    GLuint cZvaValues = 0;
+    GLfloat aAttrib[4];
 
 #if CR_ARB_vertex_buffer_object
@@ -185 +350 @@
     /*crDebug("packspu_ArrayElement index:%i", index);*/
     if (ctx->clientState->extensions.ARB_vertex_buffer_object)
+    {
         serverArrays = crStateUseServerArrays();
-#endif
-
-    if (serverArrays) {
+        if (ctx->fCheckZerroVertAttr)
+            cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
+    }
+#endif
+
+    if (serverArrays
+#ifdef CR_FORCE_ZVA_EXPAND
+            && !cZvaValues
+#endif
+            ) {
+        CR_ZVA_RESTORE_CTX RestoreCtx;
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
+
+        Assert(cZvaValues < UINT32_MAX/2);
 
         /* LockArraysEXT can not be executed between glBegin/glEnd pair, it also
@@ -198 +374 @@
         CRASSERT(!clientState->array.locked || clientState->array.synced);
 
+        if (cZvaValues)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+
         /* Send the DrawArrays command over the wire */
         if (pack_spu.swap)
@@ -203 +382 @@
         else
             crPackArrayElement( index );
+
+        if (cZvaValues)
+            packspuZvaDisable(&RestoreCtx);
     }
     else {
@@ -208 +390 @@
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
-        if (pack_spu.swap)
-            crPackExpandArrayElementSWAP( index, clientState );
-        else
-            crPackExpandArrayElement( index, clientState );
+
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        CR_ZVA_RESTORE_CTX RestoreCtx;
+
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+#endif
+
+        if (pack_spu.swap)
+            crPackExpandArrayElementSWAP( index, clientState, cZvaValues ? aAttrib : NULL );
+        else
+            crPackExpandArrayElement( index, clientState, cZvaValues ? aAttrib : NULL );
+
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaDisable(&RestoreCtx);
+#endif
     }
 #else
     GET_CONTEXT(ctx);
     CRClientState *clientState = &(ctx->clientState->client);
-    crPackExpandArrayElement(index, clientState);
+    crPackExpandArrayElement(index, clientState, NULL);
 #endif
 }
 
 /*#define CR_USE_LOCKARRAYS*/
+#ifdef CR_USE_LOCKARRAYS
+# error "check Zero Vertex Attrib hack is supported properly!"
+#endif
 
 void PACKSPU_APIENTRY
@@ -226 +424 @@
 {
     GLboolean serverArrays = GL_FALSE;
+    GLuint cZvaValues = 0;
+    GLfloat aAttrib[4];
 
 #if CR_ARB_vertex_buffer_object
@@ -233 +433 @@
     /*crDebug("DrawElements count=%d, indices=%p", count, indices);*/
     if (ctx->clientState->extensions.ARB_vertex_buffer_object)
+    {
         serverArrays = crStateUseServerArrays();
+        if (ctx->fCheckZerroVertAttr)
+            cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
+    }
 
 # ifdef CR_USE_LOCKARRAYS
@@ -298 +502 @@
 #endif
 
-    if (serverArrays) {
+    if (serverArrays
+#ifdef CR_FORCE_ZVA_EXPAND
+            && !cZvaValues
+#endif
+            ) {
+        CR_ZVA_RESTORE_CTX RestoreCtx;
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
 
+        Assert(cZvaValues < UINT32_MAX/2);
+
+        if (cZvaValues)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+
         /*Note the comment in packspu_LockArraysEXT*/
         if (clientState->array.locked && !clientState->array.synced)
@@ -308 +522 @@
             clientState->array.synced = GL_TRUE;
         }
+
         /* Send the DrawArrays command over the wire */
         if (pack_spu.swap)
@@ -313 +528 @@
         else
             crPackDrawElements( mode, count, type, indices );
+
+        if (cZvaValues)
+            packspuZvaDisable(&RestoreCtx);
     }
     else {
@@ -318 +536 @@
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
-        if (pack_spu.swap)
-            crPackExpandDrawElementsSWAP( mode, count, type, indices, clientState );
+
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        CR_ZVA_RESTORE_CTX RestoreCtx;
+
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+#endif
+
+        if (pack_spu.swap)
+            crPackExpandDrawElementsSWAP( mode, count, type, indices, clientState, cZvaValues ? aAttrib : NULL );
         else
         {
             //packspu_Begin(mode);
-            crPackExpandDrawElements( mode, count, type, indices, clientState );
+            crPackExpandDrawElements( mode, count, type, indices, clientState, cZvaValues ? aAttrib : NULL );
             //packspu_End();
         }
+
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaDisable(&RestoreCtx);
+#endif
     }
 
@@ -341 +572 @@
 {
     GLboolean serverArrays = GL_FALSE;
+    GLuint cZvaValues = 0;
+    GLfloat aAttrib[4];
 
 #if CR_ARB_vertex_buffer_object
@@ -346 +579 @@
     /*crDebug("DrawRangeElements count=%d", count);*/
     if (ctx->clientState->extensions.ARB_vertex_buffer_object)
+    {
          serverArrays = crStateUseServerArrays();
-#endif
-
-    if (serverArrays) {
+         if (ctx->fCheckZerroVertAttr)
+             cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
+    }
+#endif
+
+    if (serverArrays
+#ifdef CR_FORCE_ZVA_EXPAND
+            && !cZvaValues
+#endif
+            ) {
+        CR_ZVA_RESTORE_CTX RestoreCtx;
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
 
+        Assert(cZvaValues < UINT32_MAX/2);
+
+        if (cZvaValues)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+
         /*Note the comment in packspu_LockArraysEXT*/
         if (clientState->array.locked && !clientState->array.synced)
@@ -365 +612 @@
         else
             crPackDrawRangeElements( mode, start, end, count, type, indices );
+
+        if (cZvaValues)
+            packspuZvaDisable(&RestoreCtx);
     }
     else {
@@ -370 +620 @@
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
-        if (pack_spu.swap)
-            crPackExpandDrawRangeElementsSWAP( mode, start, end, count, type, indices, clientState );
-        else
-        {
-            crPackExpandDrawRangeElements( mode, start, end, count, type, indices, clientState );
-        }
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        CR_ZVA_RESTORE_CTX RestoreCtx;
+
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+#endif
+
+        if (pack_spu.swap)
+            crPackExpandDrawRangeElementsSWAP( mode, start, end, count, type, indices, clientState, cZvaValues ? aAttrib : NULL );
+        else
+        {
+            crPackExpandDrawRangeElements( mode, start, end, count, type, indices, clientState, cZvaValues ? aAttrib : NULL );
+        }
+
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaDisable(&RestoreCtx);
+#endif
     }
 }
@@ -384 +646 @@
 {
     GLboolean serverArrays = GL_FALSE;
+    GLuint cZvaValues = 0;
+    GLfloat aAttrib[4];
 
 #if CR_ARB_vertex_buffer_object
@@ -390 +654 @@
     /*crDebug("DrawArrays count=%d", count);*/
     if (ctx->clientState->extensions.ARB_vertex_buffer_object)
+    {
          serverArrays = crStateUseServerArrays();
+         if (ctx->fCheckZerroVertAttr)
+             cZvaValues = crStateNeedDummyZeroVertexArray(thread->currentContext->clientState, &thread->packer->current, aAttrib);
+    }
 
 # ifdef CR_USE_LOCKARRAYS
@@ -409 +677 @@
 #endif
 
-    if (serverArrays)
-    {
+    if (serverArrays
+#ifdef CR_FORCE_ZVA_EXPAND
+            && !cZvaValues
+#endif
+            )
+    {
+        CR_ZVA_RESTORE_CTX RestoreCtx;
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
 
+        Assert(cZvaValues < UINT32_MAX/2);
+
+        if (cZvaValues)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+
         /*Note the comment in packspu_LockArraysEXT*/
         if (clientState->array.locked && !clientState->array.synced)
@@ -426 +704 @@
         else
             crPackDrawArrays( mode, first, count );
+
+        if (cZvaValues)
+            packspuZvaDisable(&RestoreCtx);
     }
     else
@@ -432 +713 @@
         GET_CONTEXT(ctx);
         CRClientState *clientState = &(ctx->clientState->client);
-        if (pack_spu.swap)
-            crPackExpandDrawArraysSWAP( mode, first, count, clientState );
-        else
-            crPackExpandDrawArrays( mode, first, count, clientState );
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        CR_ZVA_RESTORE_CTX RestoreCtx;
+
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaEnable(ctx, aAttrib, cZvaValues, &RestoreCtx);
+#endif
+
+        if (pack_spu.swap)
+            crPackExpandDrawArraysSWAP( mode, first, count, clientState, cZvaValues ? aAttrib : NULL );
+        else
+            crPackExpandDrawArrays( mode, first, count, clientState, cZvaValues ? aAttrib : NULL );
+
+#ifdef CR_FORCE_ZVA_SERVER_ARRAY
+        if (cZvaValues && cZvaValues < UINT32_MAX/2)
+            packspuZvaDisable(&RestoreCtx);
+#endif
+
     }
 

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_context.c

@@ -419 +419 @@
     context->serverCtx = 0;
     context->currentThread = NULL;
+
+    memset (&context->zvaBufferInfo, 0, sizeof (context->zvaBufferInfo));
 
     if (curContext == context)
@@ -500 +502 @@
             }
 
+            if (thread->currentContext && newCtx != thread->currentContext && thread->currentContext->fCheckZerroVertAttr)
+            {
+                crStateCurrentRecoverNew(thread->currentContext->clientState, &thread->packer->current);
+                crStateResetCurrentPointers(&thread->packer->current);
+            }
             thread->currentContext = newCtx;
             crPackSetContext( thread->packer );

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_get.py

@@ -58 +58 @@
 simple_funcs = [ 'GetIntegerv', 'GetFloatv', 'GetDoublev', 'GetBooleanv' ]
 simple_swaps = [ 'SWAP32', 'SWAPFLOAT', 'SWAPDOUBLE', '(GLboolean) SWAP32' ]
+
+vertattr_get_funcs = [ 'GetVertexAttribdv' 'GetVertexAttribfv' 'GetVertexAttribiv' ]
 
 hard_funcs = {
@@ -122 +124 @@
         || pname == GL_DRAW_FRAMEBUFFER_BINDING_EXT 
 #endif
+        || pname == GL_ARRAY_BUFFER_BINDING
+        || pname == GL_ELEMENT_ARRAY_BUFFER_BINDING
+        || pname == GL_PIXEL_PACK_BUFFER_BINDING
+        || pname == GL_PIXEL_UNPACK_BUFFER_BINDING
         )
         {
@@ -157 +163 @@
         }
             """ % (params[-1][1], params[-1][1], func_name, func_name, apiutil.MakeCallString(params), func_name, func_name)
+            
+        if func_name in vertattr_get_funcs:
+            print """
+    if (pname != GL_CURRENT_VERTEX_ATTRIB_ARB)
+    {
+#ifdef DEBUG
+        %s localparams;
+        localparams = (%s) crAlloc(__numValues(pname) * sizeof(*localparams));
+        crState%s(index, pname, localparams);
+        crPack%s(index, %s, &writeback);
+        packspuFlush( (void *) thread );
+        CRPACKSPU_WRITEBACK_WAIT(thread, writeback);
+        for (i=0; i<crStateHlpComponentsCount(pname); ++i)
+        {
+            if (localparams[i] != params[i])
+            {
+                crWarning("Incorrect local state in %s for %%x param %%i", pname, i);
+                crWarning("Expected %%i but got %%i", (int)localparams[i], (int)params[i]);
+            }
+        }
+        crFree(localparams);
+#else
+        crState%s(pname, params);
+#endif
+        return;
+    } 
+            """ % (params[-1][1], params[-1][1], func_name, func_name, apiutil.MakeCallString(params), func_name, func_name)
+
         params.append( ("&writeback", "foo", 0) )
         print '\tif (pack_spu.swap)'

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_init.c

@@ -80 +80 @@
 packSPUSelfDispatch(SPUDispatchTable *self)
 {
-#ifdef VBOX_WITH_CRPACKSPU_DUMPER
     crSPUInitDispatchTable( &(pack_spu.self) );
     crSPUCopyDispatchTable( &(pack_spu.self), self );
-#else
-    (void)self;
-#endif
 }
 

trunk/src/VBox/Additions/common/crOpenGL/pack/packspu_misc.c

@@ -435 +435 @@
 }
 
+static void packspuCheckZerroVertAttr(GLboolean fEnable)
+{
+    GET_THREAD(thread);
+
+    thread->currentContext->fCheckZerroVertAttr = fEnable;
+}
+
 void PACKSPU_APIENTRY packspu_ChromiumParameteriCR(GLenum target, GLint value)
 {
@@ -442 +449 @@
             /* this is a pure packspu state, don't propagate it any further */
             packspuFluchOnThreadSwitch(value);
+            return;
+        case GL_CHECK_ZERO_VERT_ARRT:
+            packspuCheckZerroVertAttr(value);
             return;
         case GL_SHARE_CONTEXT_RESOURCES_CR:

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

@@ -131 +131 @@
     CRASSERT(buf);
 
+    if (ctx && ctx->fCheckZerroVertAttr)
+    {
+        crStateCurrentRecoverNew(ctx->clientState, &thread->packer->current);
+        crStateResetCurrentPointers(&thread->packer->current);
+    }
+
     /* We're done packing into the current buffer, unbind it */
     crPackReleaseBuffer( thread->packer );

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

@@ -731 +731 @@
 #define GL_HH_RENDERTHREAD_INFORM     0x8B2F
 
+/* enable zero vertex attribute generation to work around wine bug */
+#define GL_CHECK_ZERO_VERT_ARRT       0x8B30
+
 /**********************************************************************/
 /*****                Chromium-specific API                       *****/

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

@@ -90 +90 @@
 DECLEXPORT(void) crStateCurrentRecover( void );
 
+DECLEXPORT(void) crStateCurrentRecoverNew(CRContext *g, CRCurrentStatePointers  *current);
+
 DECLEXPORT(void) crStateCurrentDiff(CRCurrentBits *bb, CRbitvalue *bitID,
                                     CRContext *fromCtx, CRContext *toCtx);
@@ -97 +99 @@
 DECLEXPORT(void) crStateRasterPosUpdate(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
 
+DECLEXPORT(GLuint) crStateNeedDummyZeroVertexArray(CRContext *g, CRCurrentStatePointers  *current, GLfloat *pZva);
+
 #ifdef __cplusplus
 }

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

@@ -28 +28 @@
     unsigned char *p = array->a[attr].p + index * array->a[attr].stride;
 
+#ifdef DEBUG_misha
+    Assert(index >= 0);
+#endif
+
 #ifdef CR_ARB_vertex_buffer_object
     if (array->a[attr].buffer && array->a[attr].buffer->data)
     {
+        Assert(((GLuint)p) < array->a[attr].buffer->size);
+        Assert(((GLint)p) >= 0);
         p = (unsigned char *)(array->a[attr].buffer->data) + (unsigned long)p;
     }
@@ -298 +304 @@
  */
 void
-crPackExpandArrayElement(GLint index, CRClientState *c)
+crPackExpandArrayElement(GLint index, CRClientState *c, const GLfloat *pZva)
 {
     unsigned char *p;
@@ -561 +567 @@
         crPackVertexAttrib(array, VERT_ATTRIB_POS, index);
     }
+    else if (pZva)
+    {
+        crPackVertexAttrib4fvARB(VERT_ATTRIB_POS, pZva);
+    }
     else if (array->v.enabled)
     {
@@ -613 +623 @@
 
 void
-crPackExpandDrawArrays(GLenum mode, GLint first, GLsizei count, CRClientState *c)
+crPackExpandDrawArrays(GLenum mode, GLint first, GLsizei count, CRClientState *c, const GLfloat *pZva)
 {
     int i;
@@ -632 +642 @@
     for (i=0; i<count; i++)
     {
-        crPackExpandArrayElement(first + i, c);
+        crPackExpandArrayElement(first + i, c, pZva);
     }
     crPackEnd();
@@ -753 +763 @@
 void
 crPackExpandDrawElements(GLenum mode, GLsizei count, GLenum type,
-                                                 const GLvoid *indices, CRClientState *c)
+                                                 const GLvoid *indices, CRClientState *c, const GLfloat *pZva)
 {
     int i;
@@ -801 +811 @@
             for (i=0; i<count; i++)
             {
-                crPackExpandArrayElement((GLint) *p++, c);
+                crPackExpandArrayElement((GLint) *p++, c, pZva);
             }
             break;
@@ -807 +817 @@
             for (i=0; i<count; i++)
             {
-                crPackExpandArrayElement((GLint) * (GLushort *) p, c);
+                crPackExpandArrayElement((GLint) * (GLushort *) p, c, pZva);
                 p+=sizeof (GLushort);
             }
@@ -814 +824 @@
             for (i=0; i<count; i++)
             {
-                crPackExpandArrayElement((GLint) * (GLuint *) p, c);
+                crPackExpandArrayElement((GLint) * (GLuint *) p, c, pZva);
                 p+=sizeof (GLuint);
             }
@@ -872 +882 @@
  */
 void
-crPackExpandDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, CRClientState *c)
+crPackExpandDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, CRClientState *c, const GLfloat *pZva)
 {
     if (start>end)
@@ -880 +890 @@
     }
 
-    crPackExpandDrawElements(mode, count, type, indices, c);
+    crPackExpandDrawElements(mode, count, type, indices, c, pZva);
 }
 
@@ -906 +916 @@
 void
 crPackExpandMultiDrawArraysEXT( GLenum mode, GLint *first, GLsizei *count,
-                                                                GLsizei primcount, CRClientState *c )
+                                                                GLsizei primcount, CRClientState *c, const GLfloat *pZva )
 {
    GLint i;
    for (i = 0; i < primcount; i++) {
       if (count[i] > 0) {
-         crPackExpandDrawArrays(mode, first[i], count[i], c);
+         crPackExpandDrawArrays(mode, first[i], count[i], c, pZva);
       }
    }
@@ -939 +949 @@
 crPackExpandMultiDrawElementsEXT( GLenum mode, const GLsizei *count,
                                   GLenum type, const GLvoid **indices,
-                                  GLsizei primcount, CRClientState *c )
+                                  GLsizei primcount, CRClientState *c, const GLfloat *pZva )
 {
    GLint i;
    for (i = 0; i < primcount; i++) {
       if (count[i] > 0) {
-         crPackExpandDrawElements(mode, count[i], type, indices[i], c);
+         crPackExpandDrawElements(mode, count[i], type, indices[i], c, pZva);
       }
    }

trunk/src/VBox/GuestHost/OpenGL/packer/pack_currentheader.py

@@ -57 +57 @@
         unsigned int vtx_count_begin;
         unsigned int attribsUsedMask;
-
+    unsigned int changedVertexAttrib;
 } CRCurrentStatePointers;
 

trunk/src/VBox/GuestHost/OpenGL/packer/pack_currenttypes.py

@@ -57 +57 @@
                 'members': []
         },
+}
+
+current_fns_new = {
+    'VertexAttrib': {
+        'types': ['s','f','d','b','i','ub','ui','us','Nub','Nus','Nui','Nb','Ns','Ni'],
+        'sizes': [1,2,3,4],
+        'default': [0,0,0,1],
+        'members': ['x', 'y', 'z', 'w'],
+        'array': 'CR_MAX_VERTEX_ATTRIBS'
+    },
 }
 

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

@@ -366 +366 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 8 );
-    pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.b4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -382 +382 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 20 );
-    pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.i4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -398 +398 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 12 );
-    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.s4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -414 +414 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 8 );
-    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -430 +430 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 20 );
-    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -446 +446 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 12 );
-    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.s4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -462 +462 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 8 );
-    pc->current.c.vertexAttrib.b4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.b4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -478 +478 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 20 );
-    pc->current.c.vertexAttrib.i4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.i4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -494 +494 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 20 );
-    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.ui4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -510 +510 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 12 );
-    pc->current.c.vertexAttrib.s4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.s4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );
@@ -527 +527 @@
     unsigned char *data_ptr;
     CR_GET_BUFFERED_POINTER( pc, 8 );
-    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 12;
+    pc->current.c.vertexAttrib.ub4[index] = data_ptr + 4;
     pc->current.attribsUsedMask |= (1 << index);
     WRITE_DATA( 0, GLuint, index );

trunk/src/VBox/GuestHost/OpenGL/packer/packer.py

@@ -104 +104 @@
         type = m.group(3) + m.group(2)
         # Add 12 to skip the packet length, opcode and index fields
-        print "\tpc->current.c.%s.%s[index] = data_ptr + 12;" % (name,type)
+        print "\tpc->current.c.%s.%s[index] = data_ptr + 4;" % (name,type)
         if m.group(4) == "ARB" or m.group(4) == "NV":
             print "\tpc->current.attribsUsedMask |= (1 << index);"
+            print "\tpc->current.changedVertexAttrib |= (1 << index);"
         return
 

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

@@ -1565 +1565 @@
 #ifdef DEBUG_misha
 /* debugging */
-# define CR_NO_SERVER_ARRAYS
+//# define CR_NO_SERVER_ARRAYS
 #endif
 
@@ -1627 +1627 @@
 
     return res;
+#else
+    return GL_FALSE;
+#endif
+}
+
+GLuint crStateNeedDummyZeroVertexArray(CRContext *g, CRCurrentStatePointers *current, GLfloat *pZva)
+{
+#if defined(CR_ARB_vertex_buffer_object)
+    CRClientState *c = &(g->client);
+    int i;
+    GLuint zvMax = 0;
+
+    if (c->array.a[0].enabled)
+        return 0;
+
+    for (i = 1; (unsigned int)i < g->limits.maxVertexProgramAttribs; i++)
+    {
+        if (c->array.a[i].enabled)
+        {
+            if (c->array.a[i].buffer && c->array.a[i].buffer->id)
+            {
+                GLuint cElements = c->array.a[i].buffer->size / c->array.a[i].stride;
+                if (zvMax < cElements)
+                    zvMax = cElements;
+            }
+            else
+            {
+                zvMax = ~0;
+                break;
+            }
+        }
+    }
+
+    if (zvMax)
+    {
+        Assert(!c->array.v.enabled);
+
+        crStateCurrentRecoverNew(g, current);
+        crStateResetCurrentPointers(current);
+
+        memcpy(pZva, &g->current.vertexAttrib[0][0], sizeof (*pZva) * 4);
+    }
+
+    return zvMax;
 #else
     return GL_FALSE;

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

@@ -111 +111 @@
 void crStateResetCurrentPointers( CRCurrentStatePointers *current )
 {
-    crMemset(&(current->c.index), 0, sizeof(GLindex_p));
-    crMemset(&(current->c.vertexAttrib), 0, sizeof(GLvertexattrib_p));
-    crMemset(&(current->c.fogCoord), 0, sizeof(GLfogcoord_p));
-    crMemset(&(current->c.edgeFlag), 0, sizeof(GLedgeflag_p));
-    crMemset(&(current->c.normal), 0, sizeof(GLnormal_p));
-    crMemset(&(current->c.color), 0, sizeof(GLcolor_p));
-    crMemset(&(current->c.secondaryColor), 0, sizeof(GLsecondarycolor_p));
-    crMemset(&(current->c.texCoord), 0, sizeof(GLtexcoord_p));
-    /*
-    current->attribsUsedMask = 0;
-    */
+    uint32_t attribsUsedMask = current->attribsUsedMask;
+
+    crMemset(current, 0, sizeof (*current));
+
+    current->attribsUsedMask = attribsUsedMask;
 }
 

trunk/src/VBox/GuestHost/OpenGL/state_tracker/state_current.py

@@ -287 +287 @@
                 print '\t}'
 print '}'
+
+print '''
+
+void crStateCurrentRecoverNew(CRContext *g, CRCurrentStatePointers  *current)
+{
+    const unsigned char *v;
+    convert_func convert=NULL;
+    CRCurrentState *c = &(g->current);
+    CRStateBits *sb = GetCurrentBits();
+    CRCurrentBits *cb = &(sb->current);
+
+    static const GLfloat vertexAttrib_default[4] = {0.0f, 0.0f, 0.0f, 1.0f};
+
+    GLvertexattrib_p *vertexAttrib = &(current->c.vertexAttrib);
+
+    unsigned int i;
+    CRbitvalue nbitID[CR_MAX_BITARRAY];
+
+
+    /* silence warnings */
+    (void) __convert_b1;
+    (void) __convert_b2;
+    (void) __convert_b3;
+    (void) __convert_b4;
+    (void) __convert_ui1;
+    (void) __convert_ui2;
+    (void) __convert_ui3;
+    (void) __convert_ui4;
+    (void) __convert_l1;
+    (void) __convert_l2;
+    (void) __convert_l3;
+    (void) __convert_l4;
+    (void) __convert_us1;
+    (void) __convert_us2;
+    (void) __convert_us3;
+    (void) __convert_us4;
+    (void) __convert_ub1;
+    (void) __convert_ub2;
+    (void) __convert_ub3;
+    (void) __convert_ub4;
+    (void) __convert_rescale_s1;
+    (void) __convert_rescale_s2;
+    (void) __convert_rescale_b1;
+    (void) __convert_rescale_b2;
+    (void) __convert_rescale_ui1;
+    (void) __convert_rescale_ui2;
+    (void) __convert_rescale_i1;
+    (void) __convert_rescale_i2;
+    (void) __convert_rescale_us1;
+    (void) __convert_rescale_us2;
+    (void) __convert_rescale_ub1;
+    (void) __convert_rescale_ub2;
+    (void) __convert_Ni1;
+    (void) __convert_Ni2;
+    (void) __convert_Ni3;
+    (void) __convert_Ni4;
+    (void) __convert_Nb1;
+    (void) __convert_Nb2;
+    (void) __convert_Nb3;
+    (void) __convert_Nb4;
+    (void) __convert_Nus1;
+    (void) __convert_Nus2;
+    (void) __convert_Nus3;
+    (void) __convert_Nus4;
+    (void) __convert_Nui1;
+    (void) __convert_Nui2;
+    (void) __convert_Nui3;
+    (void) __convert_Nui4;
+    (void) __convert_Ns1;
+    (void) __convert_Ns2;
+    (void) __convert_Ns3;
+    (void) __convert_Ns4;
+    (void) __convert_Nub1;
+    (void) __convert_Nub2;
+    (void) __convert_Nub3;
+    (void) __convert_Nub4;
+
+
+'''
+
+for k in current_fns_new.keys():
+    print '\t/* %s */' % k
+    print '\tif (current->changed%s)' % k
+    print '\t{'
+    print '\t\tv=NULL;'
+    name = '%s%s' % (k[:1].lower(),k[1:])
+
+    indent = ""
+    if current_fns_new[k].has_key( 'array' ):
+        print '\t\tfor (i = 0 ; i < %s ; i++)' % current_fns_new[k]['array']
+        print '\t\t{'
+        indent += "\t\t"
+        print '\t\tif (!(current->changed%s & (1 << i))) continue;' % k
+    for type in current_fns_new[k]['types']:
+        if type[0:1] == "N":
+            normalized = 1
+            type2 = type[1:]
+        else:
+            normalized = 0
+            type2 = type
+        for size in current_fns_new[k]['sizes']:
+            ptr = '%s->%s%d' % (name, type, size )
+            if current_fns_new[k].has_key( 'array' ):
+                ptr += "[i]"
+            print '#ifdef DEBUG_misha'
+            print '%s\tif (%s)' % (indent, ptr)
+            print '%s\t{' % (indent)
+            print '%s\t\tuint32_t *pTst = (uint32_t*)(%s);' % (indent, ptr)
+            print '%s\t\t--pTst;' % (indent)
+            print '%s\t\tAssert((*pTst) == i);' % (indent)
+            print '%s\t}' % (indent)
+            print '#endif'
+            print '%s\tif (v < %s)' % (indent, ptr)
+            print '%s\t{' % indent
+            print '%s\t\tv = %s;' % (indent, ptr)
+            if (k == 'Color' or k == 'Normal' or k == 'SecondaryColor' or normalized) and type != 'f' and type != 'd' and type != 'l':
+                print '%s\t\tconvert = (convert_func) __convert_rescale_%s%d;' % (indent,type,size)
+            else:
+                print '%s\t\tconvert = (convert_func) __convert_%s%d;' % (indent,type,size)
+            print '%s\t}' % indent
+    print ''
+    print '%s\tif (v != NULL) {' % indent
+    if current_fns_new[k].has_key( 'array' ):
+        if k == 'TexCoord':
+            print '%s\t\tCOPY_4V(c->vertexAttrib[VERT_ATTRIB_TEX0 + i], %s_default);' % (indent,name)
+        else:
+            print '%s\t\tCOPY_4V(c->%s[i], %s_default);' % (indent,name,name)
+    else:
+        if k == 'Normal':
+            print '%s\t\tCOPY_4V(c->vertexAttrib[VERT_ATTRIB_NORMAL], %s_default);' % (indent,name)
+        elif k == 'FogCoord':
+            print '%s\t\tc->vertexAttrib[VERT_ATTRIB_FOG][0] =  %s_default;' % (indent,name)
+        elif k == 'Color':
+            print '%s\t\tCOPY_4V(c->vertexAttrib[VERT_ATTRIB_COLOR0], %s_default);' % (indent,name)
+        elif k == 'SecondaryColor':
+            print '%s\t\tCOPY_4V(c->vertexAttrib[VERT_ATTRIB_COLOR1],  %s_default);' % (indent,name)
+        elif k == 'TexCoord':
+            print '%s\t\tCOPY_4V(c->vertexAttrib[VERT_ATTRIB_TEX0], %s_default);' % (indent,name)
+        elif k == 'Index':
+            print '%s\t\tc->colorIndex =  %s_default;' % (indent,name)
+        elif k == 'EdgeFlag':
+            print '%s\t\tc->edgeFlag =  %s_default;' % (indent,name)
+        else:
+            print '%s\t\tc->%s = %s_default;' % (indent,name,name)
+    if k == 'EdgeFlag':
+        print '%s\t\t__convert_boolean (&c->edgeFlag, v);' % (indent)
+        dirtyVar = 'cb->edgeFlag'
+    elif k == 'Normal':
+        print '%s\t\tconvert(&(c->vertexAttrib[VERT_ATTRIB_NORMAL][0]), v);' % (indent)
+        dirtyVar = 'cb->vertexAttrib[VERT_ATTRIB_NORMAL]'
+    elif k == 'TexCoord':
+        print '%s\t\tconvert(&(c->vertexAttrib[VERT_ATTRIB_TEX0 + i][0]), v);' % (indent)
+        dirtyVar = 'cb->vertexAttrib[VERT_ATTRIB_TEX0 + i]'
+    elif k == 'Color':
+        print '%s\t\tconvert(&(c->vertexAttrib[VERT_ATTRIB_COLOR0][0]), v);' % (indent)
+        dirtyVar = 'cb->vertexAttrib[VERT_ATTRIB_COLOR0]'
+    elif k == 'Index':
+        print '%s\t\tconvert(&(c->colorIndex), v);' % (indent)
+        dirtyVar = 'cb->colorIndex'
+    elif k == 'SecondaryColor':
+        print '%s\t\tconvert(&(c->vertexAttrib[VERT_ATTRIB_COLOR1][0]), v);' % (indent)
+        dirtyVar = 'cb->vertexAttrib[VERT_ATTRIB_COLOR1]'
+    elif k == 'FogCoord':
+        print '%s\t\tconvert(&(c->vertexAttrib[VERT_ATTRIB_FOG][0]), v);' % (indent)
+        dirtyVar = 'cb->vertexAttrib[VERT_ATTRIB_FOG]'
+    elif k == 'VertexAttrib':
+        print '%s\t\tconvert(&(c->vertexAttrib[i][0]), v);' % (indent)
+        dirtyVar = 'cb->vertexAttrib[i]'
+    else:
+        assert 0  # should never get here
+
+    print '%s\t\tDIRTY(%s, nbitID);' % (indent, dirtyVar)
+
+#   if current_fns_new[k].has_key( 'array' ):
+#       print '%s\t\tDIRTY(cb->%s[i], nbitID);' % (indent,name)
+#   else:
+#       print '%s\t\tDIRTY(cb->%s, nbitID);' % (indent,name)
+
+
+
+    print '%s\t\tDIRTY(cb->dirty, nbitID);' % indent
+    print '%s\t}' % indent
+    if current_fns_new[k].has_key( 'array' ):
+        print '%s\t%s->ptr[i] = v;' % (indent, name )
+    else:
+        print '%s\t%s->ptr = v;' % (indent, name )
+    if current_fns_new[k].has_key( 'array' ):
+        print '\t\t}'
+        print '\t\tcurrent->changed%s = 0;' % k
+        print '\t}'
+print '}'