Changeset 82586 in vbox for trunk/src

Timestamp:

Dec 16, 2019 3:23:17 PM (5 years ago)

Author:

vboxsync

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

135467

Message:

Devices/Graphics: use glVertexAttrib to set a constant value of a generic vertex attribute

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA3d-internal.h (modified) (2 diffs)
• DevVGA-SVGA3d-ogl.cpp (modified) (19 diffs)
• DevVGA-SVGA3d-win.cpp (modified) (1 diff)
• DevVGA-SVGA3d.cpp (modified) (2 diffs)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-internal.h

@@ -693 +693 @@
 #endif
 
+/** @def VMSVGA3DSURFACE_NEEDS_DATA
+ * Checks whether SurfaceDMA transfers must always update pSurfaceData,
+ * even if the surface has a host hardware resource.
+ * @returns true/false
+ * @param   a_pSurface      The VMSVGA3d surface.
+ */
+#ifdef VMSVGA3D_DIRECT3D
+# define VMSVGA3DSURFACE_NEEDS_DATA(a_pSurface) \
+   (   (a_pSurface)->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER \
+    || (a_pSurface)->enmD3DResType == VMSVGA3D_D3DRESTYPE_INDEX_BUFFER)
+#else
+# define VMSVGA3DSURFACE_NEEDS_DATA(a_pSurface) \
+    ((a_pSurface)->enmOGLResType == VMSVGA3D_OGLRESTYPE_BUFFER)
+#endif
 
 
@@ -1084 +1098 @@
         PFNGLDELETESHADERPROC                           glDeleteShader;
         PFNGLDELETEPROGRAMPROC                          glDeleteProgram;
+        PFNGLVERTEXATTRIB4FVPROC                        glVertexAttrib4fv;
+        PFNGLVERTEXATTRIB4UBVPROC                       glVertexAttrib4ubv;
+        PFNGLVERTEXATTRIB4NUBVPROC                      glVertexAttrib4Nubv;
+        PFNGLVERTEXATTRIB4SVPROC                        glVertexAttrib4sv;
+        PFNGLVERTEXATTRIB4NSVPROC                       glVertexAttrib4Nsv;
+        PFNGLVERTEXATTRIB4NUSVPROC                      glVertexAttrib4Nusv;
     } ext;
 

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-ogl.cpp

@@ -737 +737 @@
     GLGETPROC_(PFNGLDELETESHADERPROC                     , glDeleteShader, "");
     GLGETPROC_(PFNGLDELETEPROGRAMPROC                    , glDeleteProgram, "");
+
+    GLGETPROC_(PFNGLVERTEXATTRIB4FVPROC                  , glVertexAttrib4fv, "");
+    GLGETPROC_(PFNGLVERTEXATTRIB4UBVPROC                 , glVertexAttrib4ubv, "");
+    GLGETPROC_(PFNGLVERTEXATTRIB4NUBVPROC                , glVertexAttrib4Nubv, "");
+    GLGETPROC_(PFNGLVERTEXATTRIB4SVPROC                  , glVertexAttrib4sv, "");
+    GLGETPROC_(PFNGLVERTEXATTRIB4NSVPROC                 , glVertexAttrib4Nsv, "");
+    GLGETPROC_(PFNGLVERTEXATTRIB4NUSVPROC                , glVertexAttrib4Nusv, "");
 
     /* OpenGL 3.0 core, GL_ARB_instanced_arrays. Same functions names in the ARB and core specs. */
@@ -3102 +3109 @@
                      pBox->x, pBox->y, pBox->x + pBox->w, pBox->y + pBox->h));
 
+                /* The caller already copied the data to the pMipLevel->pSurfaceData buffer, see VMSVGA3DSURFACE_NEEDS_DATA. */
                 uint32_t const offHst = pBox->x * pSurface->cbBlock;
                 uint32_t const cbWidth = pBox->w * pSurface->cbBlock;
 
-                rc = vmsvgaR3GmrTransfer(pThis,
-                                         pThisCC,
-                                         transfer,
-                                         pbData,
-                                         pMipLevel->cbSurface,
-                                         offHst,
-                                         pMipLevel->cbSurfacePitch,
-                                         GuestPtr,
-                                         pBox->srcx * pSurface->cbBlock,
-                                         cbGuestPitch,
-                                         cbWidth,
-                                         pBox->h);
-                AssertRC(rc);
+                memcpy(pbData + offHst, (uint8_t *)pMipLevel->pSurfaceData + offHst, cbWidth);
 
                 Log4(("Buffer updated at [0x%x;0x%x):\n%.*Rhxd\n", offHst, offHst + cbWidth, cbWidth, (uint8_t *)pbData + offHst));
@@ -5899 +5895 @@
 
 /* Convert VMWare vertex declaration to its OpenGL equivalent. */
-int vmsvga3dVertexDecl2OGL(SVGA3dVertexArrayIdentity &identity, GLint &size, GLenum &type, GLboolean &normalized)
+int vmsvga3dVertexDecl2OGL(SVGA3dVertexArrayIdentity &identity, GLint &size, GLenum &type, GLboolean &normalized, uint32_t &cbAttrib)
 {
     normalized = GL_FALSE;
@@ -5907 +5903 @@
         size = 1;
         type = GL_FLOAT;
+        cbAttrib = sizeof(float);
         break;
     case SVGA3D_DECLTYPE_FLOAT2:
         size = 2;
         type = GL_FLOAT;
+        cbAttrib = 2 * sizeof(float);
         break;
     case SVGA3D_DECLTYPE_FLOAT3:
         size = 3;
         type = GL_FLOAT;
+        cbAttrib = 3 * sizeof(float);
         break;
     case SVGA3D_DECLTYPE_FLOAT4:
         size = 4;
         type = GL_FLOAT;
+        cbAttrib = 4 * sizeof(float);
         break;
 
@@ -5925 +5925 @@
         type = GL_UNSIGNED_BYTE;
         normalized = GL_TRUE;   /* glVertexAttribPointer fails otherwise */
+        cbAttrib = sizeof(uint32_t);
         break;
 
@@ -5933 +5934 @@
         size = 4;
         type = GL_UNSIGNED_BYTE;
+        cbAttrib = sizeof(uint32_t);
         break;
 
@@ -5941 +5943 @@
         size = 2;
         type = GL_SHORT;
+        cbAttrib = 2 * sizeof(uint16_t);
         break;
 
@@ -5949 +5952 @@
         size = 4;
         type = GL_SHORT;
+        cbAttrib = 4 * sizeof(uint16_t);
         break;
 
@@ -5955 +5959 @@
         size = 4;
         type = GL_UNSIGNED_SHORT;
+        cbAttrib = 4 * sizeof(uint16_t);
         break;
 
@@ -5961 +5966 @@
         size = 2;
         type = GL_UNSIGNED_SHORT;
+        cbAttrib = 2 * sizeof(uint16_t);
         break;
 
@@ -5966 +5972 @@
         size = 3;
         type = GL_UNSIGNED_INT_2_10_10_10_REV;    /** @todo correct? */
+        cbAttrib = sizeof(uint32_t);
         break;
 
@@ -5972 +5979 @@
         size = 3;
         type = GL_INT_2_10_10_10_REV;    /** @todo correct? */
+        cbAttrib = sizeof(uint32_t);
         break;
 
@@ -5977 +5985 @@
         size = 2;
         type = GL_HALF_FLOAT;
+        cbAttrib = 2 * sizeof(uint16_t);
         break;
     case SVGA3D_DECLTYPE_FLOAT16_4:
         size = 4;
         type = GL_HALF_FLOAT;
+        cbAttrib = 4 * sizeof(uint16_t);
         break;
     default:
@@ -5988 +5998 @@
     //pVertexElement->Method      = identity.method;
     //pVertexElement->Usage       = identity.usage;
+
+    return VINF_SUCCESS;
+}
+
+static float vmsvga3dFloat16To32(uint16_t f16)
+{
+    /* From Wiki */
+#ifndef INFINITY
+    static uint32_t const sBitsINFINITY = UINT32_C(0x7f800000);
+    #define INFINITY (*(float const *)&sBitsINFINITY)
+#endif
+#ifndef NAN
+    static uint32_t const sBitsNAN = UINT32_C(0x7fc00000);
+    #define NAN (*(float const *)&sBitsNAN)
+#endif
+
+    uint16_t const s = (f16 >> UINT16_C(15)) & UINT16_C(0x1);
+    uint16_t const e = (f16 >> UINT16_C(10)) & UINT16_C(0x1f);
+    uint16_t const m = (f16                ) & UINT16_C(0x3ff);
+
+    float result = s ? 1.0f : -1.0f;
+    if (e == 0)
+    {
+        if (m == 0)
+            result *= 0.0f;                            /* zero, -0 */
+        else
+            result *= (float)m / 1024.0f / 16384.0f;   /* subnormal numbers: sign * 2^-14 * 0.m */
+    }
+    else if (e == 0x1f)
+    {
+        if (m == 0)
+            result *= INFINITY;                        /* +-infinity */
+        else
+            result = NAN;                              /* NAN */
+    }
+    else
+    {
+        result *= powf(2.0f, (float)e - 15.0f) * (1.0f + (float)m / 1024.0f); /* sign * 2^(e-15) * 1.m */
+    }
+
+    return result;
+}
+
+/* Set a vertex attribute according to VMSVGA vertex declaration. */
+static int vmsvga3dSetVertexAttrib(PVMSVGA3DSTATE pState, GLuint index, SVGA3dVertexArrayIdentity const *pIdentity, GLvoid const *pv)
+{
+    switch (pIdentity->type)
+    {
+        case SVGA3D_DECLTYPE_FLOAT1:
+        {
+            /* "One-component float expanded to (float, 0, 0, 1)." */
+            GLfloat const *p = (GLfloat *)pv;
+            GLfloat const v[4] = { p[0], 0.0f, 0.0f, 1.0f };
+            pState->ext.glVertexAttrib4fv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_FLOAT2:
+        {
+            /* "Two-component float expanded to (float, float, 0, 1)." */
+            GLfloat const *p = (GLfloat *)pv;
+            GLfloat const v[4] = { p[0], p[1], 0.0f, 1.0f };
+            pState->ext.glVertexAttrib4fv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_FLOAT3:
+        {
+            /* "Three-component float expanded to (float, float, float, 1)." */
+            GLfloat const *p = (GLfloat *)pv;
+            GLfloat const v[4] = { p[0], p[1], p[2], 1.0f };
+            pState->ext.glVertexAttrib4fv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_FLOAT4:
+            pState->ext.glVertexAttrib4fv(index, (GLfloat const *)pv);
+            break;
+        case SVGA3D_DECLTYPE_D3DCOLOR:
+            /** @todo Need to swap bytes? */
+            pState->ext.glVertexAttrib4Nubv(index, (GLubyte const *)pv);
+            break;
+        case SVGA3D_DECLTYPE_UBYTE4:
+            pState->ext.glVertexAttrib4ubv(index, (GLubyte const *)pv);
+            break;
+        case SVGA3D_DECLTYPE_SHORT2:
+        {
+            /* "Two-component, signed short expanded to (value, value, 0, 1)." */
+            GLshort const *p = (GLshort const *)pv;
+            GLshort const v[4] = { p[0], p[1], 0, 1 };
+            pState->ext.glVertexAttrib4sv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_SHORT4:
+            pState->ext.glVertexAttrib4sv(index, (GLshort const *)pv);
+            break;
+        case SVGA3D_DECLTYPE_UBYTE4N:
+            pState->ext.glVertexAttrib4Nubv(index, (GLubyte const *)pv);
+            break;
+        case SVGA3D_DECLTYPE_SHORT2N:
+        {
+            /* "Normalized, two-component, signed short, expanded to (first short/32767.0, second short/32767.0, 0, 1)." */
+            GLshort const *p = (GLshort const *)pv;
+            GLshort const v[4] = { p[0], p[1], 0, 1 };
+            pState->ext.glVertexAttrib4Nsv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_SHORT4N:
+            pState->ext.glVertexAttrib4Nsv(index, (GLshort const *)pv);
+            break;
+        case SVGA3D_DECLTYPE_USHORT2N:
+        {
+            GLushort const *p = (GLushort const *)pv;
+            GLushort const v[4] = { p[0], p[1], 0, 1 };
+            pState->ext.glVertexAttrib4Nusv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_USHORT4N:
+            pState->ext.glVertexAttrib4Nusv(index, (GLushort const *)pv);
+            break;
+        case SVGA3D_DECLTYPE_UDEC3:
+        {
+            /** @todo Test */
+            /* "Three-component, unsigned, 10 10 10 format expanded to (value, value, value, 1)." */
+            uint32_t const u32 = *(uint32_t *)pv;
+            GLfloat const v[4] = { (float)(u32 & 0x3ff), (float)((u32 >> 10) & 0x3ff), (float)((u32 >> 20) & 0x3ff), 1.0f };
+            pState->ext.glVertexAttrib4fv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_DEC3N:
+        {
+            /** @todo Test */
+            /* "Three-component, signed, 10 10 10 format normalized and expanded to (v[0]/511.0, v[1]/511.0, v[2]/511.0, 1)." */
+            uint32_t const u32 = *(uint32_t *)pv;
+            GLfloat const v[4] = { (u32 & 0x3ff) / 511.0f, ((u32 >> 10) & 0x3ff) / 511.0f, ((u32 >> 20) & 0x3ff) / 511.0f, 1.0f };
+            pState->ext.glVertexAttrib4fv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_FLOAT16_2:
+        {
+            /** @todo Test */
+            /* "Two-component, 16-bit, floating point expanded to (value, value, 0, 1)." */
+            uint16_t const *p = (uint16_t *)pv;
+            GLfloat const v[4] = { vmsvga3dFloat16To32(p[0]), vmsvga3dFloat16To32(p[1]), 0.0f, 1.0f };
+            pState->ext.glVertexAttrib4fv(index, v);
+            break;
+        }
+        case SVGA3D_DECLTYPE_FLOAT16_4:
+        {
+            /** @todo Test */
+            uint16_t const *p = (uint16_t *)pv;
+            GLfloat const v[4] = { vmsvga3dFloat16To32(p[0]), vmsvga3dFloat16To32(p[1]),
+                                   vmsvga3dFloat16To32(p[2]), vmsvga3dFloat16To32(p[3]) };
+            pState->ext.glVertexAttrib4fv(index, v);
+            break;
+        }
+        default:
+            AssertFailedReturn(VERR_INVALID_PARAMETER);
+    }
 
     return VINF_SUCCESS;
@@ -6073 +6239 @@
                                                     uint32_t iVertexDeclBase, uint32_t numVertexDecls,
                                                     SVGA3dVertexDecl *pVertexDecl,
-                                                    SVGA3dVertexDivisor const *paVertexDivisors, uint32_t cInstances)
+                                                    SVGA3dVertexDivisor const *paVertexDivisors)
 {
     PVMSVGA3DSTATE      pState = pThisCC->svga.p3dState;
@@ -6126 +6292 @@
         GLenum type;
         GLboolean normalized;
+        uint32_t cbAttrib;
         GLuint index = iVertexDeclBase + iVertex;
 
         Log(("vmsvga3dDrawPrimitives: array index %d type=%s (%d) method=%s (%d) usage=%s (%d) usageIndex=%d stride=%d offset=%d\n", index, vmsvgaDeclType2String(pVertexDecl[iVertex].identity.type), pVertexDecl[iVertex].identity.type, vmsvgaDeclMethod2String(pVertexDecl[iVertex].identity.method), pVertexDecl[iVertex].identity.method, vmsvgaDeclUsage2String(pVertexDecl[iVertex].identity.usage), pVertexDecl[iVertex].identity.usage, pVertexDecl[iVertex].identity.usageIndex, pVertexDecl[iVertex].array.stride, pVertexDecl[iVertex].array.offset));
 
-        rc = vmsvga3dVertexDecl2OGL(pVertexDecl[iVertex].identity, size, type, normalized);
+        rc = vmsvga3dVertexDecl2OGL(pVertexDecl[iVertex].identity, size, type, normalized, cbAttrib);
         AssertRCReturn(rc, rc);
 
+        ASSERT_GUEST_RETURN(   pVertexSurface->paMipmapLevels[0].cbSurface >= pVertexDecl[iVertex].array.offset
+                            && pVertexSurface->paMipmapLevels[0].cbSurface - pVertexDecl[iVertex].array.offset >= cbAttrib,
+                            VERR_INVALID_PARAMETER);
+        RT_UNTRUSTED_VALIDATED_FENCE();
+
         if (pContext->state.shidVertex != SVGA_ID_INVALID)
         {
-            /* Use numbered vertex arrays when shaders are active. */
-            pState->ext.glEnableVertexAttribArray(index);
-            VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
-            pState->ext.glVertexAttribPointer(index, size, type, normalized, pVertexDecl[iVertex].array.stride,
-                                              (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
-            VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
-
-            GLuint divisor = paVertexDivisors && paVertexDivisors[index].s.instanceData ? 1 : 0;
-            if (pVertexDecl[iVertex].array.stride == 0)
+            /* Use numbered vertex arrays (or attributes) when shaders are active. */
+            if (pVertexDecl[iVertex].array.stride)
             {
-                /* Zero stride means that the attribute pointer must not be increased.
-                 * See comment about stride in vmsvga3dDrawPrimitives.
+                pState->ext.glEnableVertexAttribArray(index);
+                VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
+                pState->ext.glVertexAttribPointer(index, size, type, normalized, pVertexDecl[iVertex].array.stride,
+                                                  (const GLvoid *)(uintptr_t)pVertexDecl[iVertex].array.offset);
+                VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
+
+                GLuint divisor = paVertexDivisors && paVertexDivisors[index].s.instanceData ? 1 : 0;
+                pState->ext.glVertexAttribDivisor(index, divisor);
+                VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
+
+                /** @todo case SVGA3D_DECLUSAGE_COLOR: color component order not identical!! test GL_BGRA!!  */
+            }
+            else
+            {
+                /*
+                 * D3D and OpenGL have a different meaning of value zero for the vertex array stride:
+                 * - D3D (VMSVGA): "use a zero stride to tell the runtime not to increment the vertex buffer offset."
+                 * - OpenGL: "If stride is 0, the generic vertex attributes are understood to be tightly packed in the array."
+                 * VMSVGA uses the D3D semantics.
+                 *
+                 * Use glVertexAttrib in order to tell OpenGL to reuse the zero stride attributes for each vertex.
                  */
-                if (!divisor)
-                {
-                    LogRelMax(8, ("VMSVGA: zero stride array (instancing %s %d)\n", paVertexDivisors ? "on" : "off", cInstances));
-                    AssertFailed();
-                }
-
-                divisor = cInstances; /* This attrib must never advance. */
+                pState->ext.glDisableVertexAttribArray(index);
+                VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
+
+                const GLvoid *v = (uint8_t *)pVertexSurface->paMipmapLevels[0].pSurfaceData + pVertexDecl[iVertex].array.offset;
+                vmsvga3dSetVertexAttrib(pState, index, &pVertexDecl[iVertex].identity, v);
+                VMSVGA3D_CHECK_LAST_ERROR_WARN(pState, pContext);
             }
-            pState->ext.glVertexAttribDivisor(index, divisor);
-            VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
-
-            /** @todo case SVGA3D_DECLUSAGE_COLOR: color component order not identical!! test GL_BGRA!!  */
         }
         else
@@ -6395 +6574 @@
     }
 
-    /*
-     * D3D and OpenGL have a different meaning of value zero for the vertex array stride:
-     * - D3D and VMSVGA: "use a zero stride to tell the runtime not to increment the vertex buffer offset."
-     * - OpenGL: "If stride is 0, the generic vertex attributes are understood to be tightly packed in the array."
-     * VMSVGA uses the D3D semantics.
-     *
-     * In order to tell OpenGL to reuse the zero stride attributes for each vertex
-     * such attributes could be declared as instance data, then OpenGL applies them once
-     * for all vertices of the one drawn instance.
-     *
-     * If instancing is already used (cVertexDivisor > 0), then the code does nothing and assumes that
-     * all instance data is already correctly marked as such.
-     *
-     * If instancing is not requisted (cVertexDivisor == 0), then the code creates a description for
-     * one instance where all arrays with zero stride are marked as instance data, and all arrays
-     * with non-zero stride as indexed data.
-     */
-    bool fZeroStrideArray = false;
-    if (cVertexDivisor == 0)
-    {
-        unsigned i;
-        for (i = 0; i < numVertexDecls; ++i)
-        {
-            if (pVertexDecl[i].array.stride == 0)
-            {
-                fZeroStrideArray = true;
-                break;
-            }
-        }
-
-        if (fZeroStrideArray)
-        {
-            cVertexDivisor = numVertexDecls;
-            pVertexDivisor = (SVGA3dVertexDivisor *)RTMemTmpAlloc(sizeof(SVGA3dVertexDivisor) * cVertexDivisor);
-            AssertPtrReturn(pVertexDivisor, VERR_NO_MEMORY);
-
-            for (i = 0; i < numVertexDecls; ++i)
-            {
-                pVertexDivisor[i].s.count = 1;
-                if (pVertexDecl[i].array.stride == 0)
-                {
-                    pVertexDivisor[i].s.instanceData = 1;
-                }
-                else
-                {
-                    pVertexDivisor[i].s.indexedData = 1;
-                }
-            }
-        }
-    }
-
     /* Try to figure out if instancing is used.
      * Support simple instancing case with one set of indexed data and one set per-instance data.
@@ -6482 +6610 @@
 
         rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pThisCC, pContext, iCurrentVertex, iVertex - iCurrentVertex,
-                                                      &pVertexDecl[iCurrentVertex], pVertexDivisor, cInstances);
+                                                      &pVertexDecl[iCurrentVertex], pVertexDivisor);
         AssertRCReturn(rc, rc);
 
@@ -6647 +6775 @@
     }
 
-    if (fZeroStrideArray)
-    {
-        RTMemTmpFree(pVertexDivisor);
-        pVertexDivisor = NULL;
-    }
-
 #ifdef DEBUG
     /* Check whether 'activeTexture' on texture unit 'i' matches what we expect. */

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp

@@ -2474 +2474 @@
         Assert(pBox->y == 0 && pBox->h == 1 && pBox->z == 0 && pBox->d == 1);
 
-        /* vmsvgaR3GmrTransfer verifies input parameters except for the host buffer addres and size.
-         * srcx has been verified in vmsvga3dSurfaceDMA to not cause 32 bit overflow when multiplied by cbBlock.
-         */
+        /* The caller has already updated pMipLevel->pSurfaceData, see VMSVGA3DSURFACE_NEEDS_DATA. */
+
+#ifdef LOG_ENABLED
         uint32_t const offHst = pBox->x * pSurface->cbBlock;
         uint32_t const cbWidth = pBox->w * pSurface->cbBlock;
-
-        uint32_t const offGst = pBox->srcx * pSurface->cbBlock;
-
-        /* Copy data between the guest and the host buffer. */
-        rc = vmsvgaR3GmrTransfer(pThis,
-                                 pThisCC,
-                                 transfer,
-                                 (uint8_t *)pMipLevel->pSurfaceData,
-                                 pMipLevel->cbSurface,
-                                 offHst,
-                                 pMipLevel->cbSurfacePitch,
-                                 GuestPtr,
-                                 offGst,
-                                 cbGuestPitch,
-                                 cbWidth,
-                                 1); /* Buffers are 1-dimensional */
-        AssertRC(rc);
-
         Log4(("Buffer updated at [0x%x;0x%x):\n%.*Rhxd\n", offHst, offHst + cbWidth, cbWidth, (uint8_t *)pMipLevel->pSurfaceData + offHst));
+#endif
 
         /* Do not bother to copy the data to the D3D resource now. vmsvga3dDrawPrimitives will do that.

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d.cpp

@@ -616 +616 @@
         RT_UNTRUSTED_VALIDATED_FENCE();
 
-        if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
+        if (   !VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface)
+            || VMSVGA3DSURFACE_NEEDS_DATA(pSurface))
         {
             uint64_t uGuestOffset = u32GuestBlockX * pSurface->cbBlock +
@@ -653 +654 @@
             }
         }
-        else
+
+        if (VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
         {
             SVGA3dCopyBox clipBox;