Changeset 69153 in vbox for trunk

Timestamp:

Oct 22, 2017 9:38:04 AM (7 years ago)

Author:

vboxsync

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

118464

Message:

Devices/Graphics: VMSVGA: Initial support for volume textures. Remember the type of created D3D resource.

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA3d-info.cpp (modified) (6 diffs)
• DevVGA-SVGA3d-internal.h (modified) (7 diffs)
• DevVGA-SVGA3d-ogl.cpp (modified) (12 diffs)
• DevVGA-SVGA3d-savedstate.cpp (modified) (4 diffs)
• DevVGA-SVGA3d-win.cpp (modified) (87 diffs)
• DevVGA-SVGA3d.cpp (modified) (5 diffs)

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

@@ -267 +267 @@
      * wast memory on them).
      */
-    uint32_t const fSwitchFlags = pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
+    uint32_t const fSwitchFlags = pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
     if (   fSwitchFlags != SVGA3D_SURFACE_HINT_DEPTHSTENCIL
         && fSwitchFlags != (SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE))
@@ -312 +312 @@
                      * D3D specifics.
                      */
-                    HRESULT  hr;
-                    switch (fSwitchFlags)
+                    Assert(pSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_NONE);
+
+                    HRESULT hr;
+                    switch (pSurface->enmD3DResType)
                     {
-                        case SVGA3D_SURFACE_HINT_TEXTURE:
-                        case SVGA3D_SURFACE_HINT_RENDERTARGET:
-                        case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
+                        case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
+                            AssertFailed(); ///@todo
+                            break;
+
+                        case VMSVGA3D_D3DRESTYPE_SURFACE:
+                        case VMSVGA3D_D3DRESTYPE_TEXTURE:
+                        case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
                         {
                             /*
@@ -323 +329 @@
                              */
                             D3DLOCKED_RECT LockedRect;
-                            if (fSwitchFlags & SVGA3D_SURFACE_HINT_TEXTURE)
+                            if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
+                            {
+                                hr = pSurface->u.pCubeTexture->LockRect(vmsvga3dCubemapFaceFromIndex(iFace),
+                                                                        i, /* texture level */
+                                                                        &LockedRect,
+                                                                        NULL,
+                                                                        D3DLOCK_READONLY);
+                            }
+                            else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE)
                             {
                                 if (pSurface->bounce.pTexture)
                                 {
                                     if (    !pSurface->fDirty
-                                        &&  fSwitchFlags == (SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET)
+                                        &&  RT_BOOL(fSwitchFlags & SVGA3D_SURFACE_HINT_RENDERTARGET)
                                         &&  i == 0 /* only the first time */)
                                     {
@@ -403 +417 @@
                         }
 
-                        case SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_INDEXBUFFER:
-                        case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
-                        case SVGA3D_SURFACE_HINT_INDEXBUFFER:
+                        case VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER:
+                        case VMSVGA3D_D3DRESTYPE_INDEX_BUFFER:
                         {
                             /* Current type of the buffer. */
-                            const bool fVertex = RT_BOOL(pSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER);
+                            const bool fVertex = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER);
 
                             void *pvD3DData = NULL;
@@ -428 +441 @@
 
                         default:
-                            AssertMsgFailed(("%#x\n", fSwitchFlags));
+                            AssertMsgFailed(("flags %#x, type %d\n", fSwitchFlags, pSurface->enmD3DResType));
                     }
 
@@ -1811 +1824 @@
     pHlp->pfnPrintf(pHlp, "Format:                  %s\n",
                     vmsvgaFormatEnumValueEx(szTmp, sizeof(szTmp), NULL, (int)pSurface->format, false, &g_SVGA3dSurfaceFormat2String));
-    pHlp->pfnPrintf(pHlp, "Flags:                   %#x", pSurface->flags);
-    vmsvga3dInfoU32Flags(pHlp, pSurface->flags, "SVGA3D_SURFACE_", g_aSvga3DSurfaceFlags, RT_ELEMENTS(g_aSvga3DSurfaceFlags));
+    pHlp->pfnPrintf(pHlp, "Flags:                   %#x", pSurface->surfaceFlags);
+    vmsvga3dInfoU32Flags(pHlp, pSurface->surfaceFlags, "SVGA3D_SURFACE_", g_aSvga3DSurfaceFlags, RT_ELEMENTS(g_aSvga3DSurfaceFlags));
     pHlp->pfnPrintf(pHlp, "\n");
     if (pSurface->cFaces == 0)

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

@@ -486 +486 @@
 
 #ifdef VMSVGA3D_DIRECT3D
+
+/* What kind of Direct3D resource has been created for the VMSVGA3D surface. */
+typedef enum VMSVGA3DD3DRESTYPE
+{
+    VMSVGA3D_D3DRESTYPE_NONE           = 0,
+    VMSVGA3D_D3DRESTYPE_SURFACE        = 1,
+    VMSVGA3D_D3DRESTYPE_TEXTURE        = 2,
+    VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE   = 3,
+    VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE = 4,
+    VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER  = 5,
+    VMSVGA3D_D3DRESTYPE_INDEX_BUFFER   = 6
+} VMSVGA3DD3DRESTYPE;
+
 /**
  *
@@ -498 +511 @@
         IDirect3DTexture9          *pTexture;
         IDirect3DCubeTexture9      *pCubeTexture;
+        IDirect3DVolumeTexture9    *pVolumeTexture;
     } u;
 } VMSVGA3DSHAREDSURFACE;
@@ -514 +528 @@
     uint32_t                idAssociatedContext;
 #endif
-    uint32_t                flags;
+    uint32_t                surfaceFlags;
     SVGA3dSurfaceFormat     format;
 #ifdef VMSVGA3D_OPENGL
@@ -552 +566 @@
     /** Event query inserted after each GPU operation that updates or uses this surface. */
     IDirect3DQuery9        *pQuery;
-    /** @todo Just remember the type of actually created D3D object. Do not always guess from flags.
-     * Replace fu32ActualUsageFlags and possibly fStencilAsTexture. */
+    /* The type of actually created D3D resource. */
+    VMSVGA3DD3DRESTYPE      enmD3DResType;
     union
     {
         IDirect3DSurface9          *pSurface;
+        IDirect3DTexture9          *pTexture;
         IDirect3DCubeTexture9      *pCubeTexture;
+        IDirect3DVolumeTexture9    *pVolumeTexture;
+        IDirect3DVertexBuffer9     *pVertexBuffer;
         IDirect3DIndexBuffer9      *pIndexBuffer;
-        IDirect3DTexture9          *pTexture;
-        IDirect3DVertexBuffer9     *pVertexBuffer;
     } u;
     union
@@ -566 +581 @@
         IDirect3DTexture9          *pTexture;
         IDirect3DCubeTexture9      *pCubeTexture;
+        IDirect3DVolumeTexture9    *pVolumeTexture;
     } bounce;
     /** AVL tree containing VMSVGA3DSHAREDSURFACE structures. */
     AVLU32TREE              pSharedObjectTree;
     bool                    fStencilAsTexture;
-    uint32_t                fu32ActualUsageFlags;
 #endif
 } VMSVGA3DSURFACE;
@@ -588 +603 @@
     SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, idAssociatedContext),
 # endif
-    SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, flags),
+    SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, surfaceFlags),
     SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, format),
 # ifdef VMSVGA3D_OPENGL
@@ -1122 +1137 @@
 }
 
-
-#endif
-
+#ifdef VMSVGA3D_DIRECT3D
+DECLINLINE(D3DCUBEMAP_FACES) vmsvga3dCubemapFaceFromIndex(uint32_t iFace)
+{
+    D3DCUBEMAP_FACES Face;
+    switch (iFace)
+    {
+        case 0: Face = D3DCUBEMAP_FACE_POSITIVE_X; break;
+        case 1: Face = D3DCUBEMAP_FACE_NEGATIVE_X; break;
+        case 2: Face = D3DCUBEMAP_FACE_POSITIVE_Y; break;
+        case 3: Face = D3DCUBEMAP_FACE_NEGATIVE_Y; break;
+        case 4: Face = D3DCUBEMAP_FACE_POSITIVE_Z; break;
+        default:
+        case 5: Face = D3DCUBEMAP_FACE_NEGATIVE_Z; break;
+    }
+    return Face;
+}
+#endif /* VMSVGA3D_DIRECT3D */
+
+#endif
+

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

@@ -1855 +1855 @@
     VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
 
-    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
+    switch (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
     {
     case SVGA3D_SURFACE_CUBEMAP:
@@ -1891 +1891 @@
 
     default:
-        AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface), ("type=%x\n", (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)));
+        AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface), ("type=%x\n", (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)));
         break;
     }
@@ -2122 +2122 @@
     VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
 
-    pSurface->flags              |= SVGA3D_SURFACE_HINT_TEXTURE;
+    pSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_TEXTURE;
 
     if (idPrevCtx < pState->cContexts && pState->papContexts[idPrevCtx]->id == idPrevCtx)
@@ -2344 +2344 @@
     RT_NOREF(uHostFace); ///@todo
 
-    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
+    switch (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
     {
     case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
@@ -2503 +2503 @@
                 {
                     Log(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n",
-                         (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_VERTEXBUFFER ? "vertex" :
-                           (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_INDEXBUFFER ? "index" : "buffer",
+                         (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_VERTEXBUFFER ? "vertex" :
+                           (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_INDEXBUFFER ? "index" : "buffer",
                          pBox->x, pBox->y, pBox->x + pBox->w, pBox->y + pBox->h));
 
@@ -2653 +2653 @@
     {
         /* Unknown surface type; turn it into a texture. */
-        Log(("vmsvga3dGenerateMipmaps: unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->flags, pSurface->format));
+        Log(("vmsvga3dGenerateMipmaps: unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
         rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
         AssertRCReturn(rc, rc);
@@ -4802 +4802 @@
         if (pRenderTarget->oglId.texture == OPENGL_INVALID_ID)
         {
-            Log(("vmsvga3dSetRenderTarget: create renderbuffer to be used as render target; surface id=%x type=%d format=%d\n", target.sid, pRenderTarget->flags, pRenderTarget->internalFormatGL));
+            Log(("vmsvga3dSetRenderTarget: create renderbuffer to be used as render target; surface id=%x type=%d format=%d\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->internalFormatGL));
             pContext = &pState->SharedCtx;
             VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
@@ -4831 +4831 @@
         AssertReturn(pRenderTarget->oglId.texture != OPENGL_INVALID_ID, VERR_INVALID_PARAMETER);
 
-        pRenderTarget->flags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
+        pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
 
         pState->ext.glFramebufferRenderbuffer(GL_FRAMEBUFFER,
@@ -4851 +4851 @@
         if (pRenderTarget->oglId.texture == OPENGL_INVALID_ID)
         {
-            Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->flags, pRenderTarget->format));
+            Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
             int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
             AssertRCReturn(rc, rc);
@@ -4859 +4859 @@
         Assert(!pRenderTarget->fDirty);
 
-        pRenderTarget->flags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
+        pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
 
         pState->ext.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + type - SVGA3D_RT_COLOR0, GL_TEXTURE_2D, pRenderTarget->oglId.texture, target.mipmap);
@@ -5978 +5978 @@
         pVertexSurface->fDirty = false;
 
-        pVertexSurface->flags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
+        pVertexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
 
         pState->ext.glBindBuffer(GL_ARRAY_BUFFER, OPENGL_INVALID_ID);
@@ -6312 +6312 @@
                 pIndexSurface->fDirty = false;
 
-                pIndexSurface->flags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
+                pIndexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
 
                 pState->ext.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, OPENGL_INVALID_ID);

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

@@ -357 +357 @@
                 }
 
-                rc = vmsvga3dSurfaceDefine(pThis, sid, surface.flags, surface.format, surface.faces, surface.multiSampleCount, surface.autogenFilter, cMipLevels, pMipmapLevelSize);
+                rc = vmsvga3dSurfaceDefine(pThis, sid, surface.surfaceFlags, surface.format, surface.faces, surface.multiSampleCount, surface.autogenFilter, cMipLevels, pMipmapLevelSize);
                 AssertRCReturn(rc, rc);
 
@@ -607 +607 @@
                         AssertReturn(pData, VERR_NO_MEMORY);
 
-                        switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
+                        switch (pSurface->enmD3DResType)
                         {
-                        case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
-                        case SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE:
-                            /** @todo unable to easily fetch depth surface data in d3d 9 */
+                        case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
+                        case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
+                            AssertFailed(); ///@todo
                             fSkipSave = true;
                             break;
-                        case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
-                            fRenderTargetTexture = true;
-                            /* no break */
-                        case SVGA3D_SURFACE_HINT_TEXTURE:
-                            fTexture = true;
-                            /* no break */
-                        case SVGA3D_SURFACE_HINT_RENDERTARGET:
+                        case VMSVGA3D_D3DRESTYPE_SURFACE:
+                        case VMSVGA3D_D3DRESTYPE_TEXTURE:
                         {
+                            if (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
+                            {
+                               /** @todo unable to easily fetch depth surface data in d3d 9 */
+                               fSkipSave = true;
+                               break;
+                            }
+
+                            fTexture = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE);
+                            fRenderTargetTexture = fTexture && (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET);
+
                             D3DLOCKED_RECT LockedRect;
 
@@ -698 +703 @@
                         }
 
-                        case SVGA3D_SURFACE_HINT_VERTEXBUFFER | SVGA3D_SURFACE_HINT_INDEXBUFFER:
-                        case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
-                        case SVGA3D_SURFACE_HINT_INDEXBUFFER:
+                        case VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER:
+                        case VMSVGA3D_D3DRESTYPE_INDEX_BUFFER:
                         {
                             /* Current type of the buffer. */
-                            const bool fVertex = RT_BOOL(pSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER);
+                            const bool fVertex = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER);
 
                             uint8_t *pD3DData;
@@ -754 +758 @@
                         Assert(pMipmapLevel->cbSurface);
 
-                        switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
+                        switch (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
                         {
                         default:

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

@@ -1105 +1105 @@
     Assert(pSurface->pSharedObjectTree == NULL);
 
-    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
-    {
-    case SVGA3D_SURFACE_CUBEMAP:
-    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE:
-    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
+    switch (pSurface->enmD3DResType)
+    {
+    case VMSVGA3D_D3DRESTYPE_SURFACE:
+        D3D_RELEASE(pSurface->u.pSurface);
+        break;
+
+    case VMSVGA3D_D3DRESTYPE_TEXTURE:
+        D3D_RELEASE(pSurface->u.pTexture);
+        D3D_RELEASE(pSurface->bounce.pTexture);
+        break;
+
+    case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
         D3D_RELEASE(pSurface->u.pCubeTexture);
         D3D_RELEASE(pSurface->bounce.pCubeTexture);
         break;
 
-    case SVGA3D_SURFACE_HINT_INDEXBUFFER | SVGA3D_SURFACE_HINT_VERTEXBUFFER:
-    case SVGA3D_SURFACE_HINT_INDEXBUFFER:
-    case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
-        if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_VERTEXBUFFER)
-            D3D_RELEASE(pSurface->u.pVertexBuffer);
-        else if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_INDEXBUFFER)
-            D3D_RELEASE(pSurface->u.pIndexBuffer);
-        else
-            AssertMsg(pSurface->u.pVertexBuffer == NULL, ("fu32ActualUsageFlags %x\n", pSurface->fu32ActualUsageFlags));
-        break;
-
-    case SVGA3D_SURFACE_HINT_TEXTURE:
-    case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
-        D3D_RELEASE(pSurface->u.pTexture);
-        D3D_RELEASE(pSurface->bounce.pTexture);
-        break;
-
-    case SVGA3D_SURFACE_HINT_RENDERTARGET:
-    case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
-    case SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE:    /** @todo actual texture surface not supported */
-        if (pSurface->fStencilAsTexture)
-            D3D_RELEASE(pSurface->u.pTexture);
-        else
-            D3D_RELEASE(pSurface->u.pSurface);
+    case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
+        D3D_RELEASE(pSurface->u.pVolumeTexture);
+        D3D_RELEASE(pSurface->bounce.pVolumeTexture);
+        break;
+
+    case VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER:
+        D3D_RELEASE(pSurface->u.pVertexBuffer);
+        break;
+
+    case VMSVGA3D_D3DRESTYPE_INDEX_BUFFER:
+        D3D_RELEASE(pSurface->u.pIndexBuffer);
         break;
 
     default:
-        AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface), ("type=%x\n", (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)));
+        AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface),
+                  ("surfaceFlags=0x%x\n", (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)));
         break;
     }
@@ -1157 +1152 @@
     PVMSVGA3DSURFACE       pSurface = (PVMSVGA3DSURFACE)pvParam;
 
-    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
-    {
-    case SVGA3D_SURFACE_CUBEMAP:
-    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE:
-    case SVGA3D_SURFACE_CUBEMAP | SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
+    switch (pSurface->enmD3DResType)
+    {
+    case VMSVGA3D_D3DRESTYPE_TEXTURE:
+        LogFunc(("release shared texture object for context %d\n", pNode->Key));
+        Assert(pSharedSurface->u.pTexture);
+        D3D_RELEASE(pSharedSurface->u.pTexture);
+        break;
+
+    case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
         LogFunc(("release shared cube texture object for context %d\n", pNode->Key));
         Assert(pSharedSurface->u.pCubeTexture);
@@ -1167 +1166 @@
         break;
 
-    case SVGA3D_SURFACE_HINT_TEXTURE:
-    case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
-        LogFunc(("release shared texture object for context %d\n", pNode->Key));
-        Assert(pSharedSurface->u.pTexture);
-        D3D_RELEASE(pSharedSurface->u.pTexture);
+    case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
+        LogFunc(("release shared volume texture object for context %d\n", pNode->Key));
+        Assert(pSharedSurface->u.pVolumeTexture);
+        D3D_RELEASE(pSharedSurface->u.pVolumeTexture);
         break;
 
@@ -1190 +1188 @@
     if (!pSharedSurface)
     {
-        const bool fCubeTexture = RT_BOOL(pSurface->flags & SVGA3D_SURFACE_CUBEMAP);
         const uint32_t cWidth = pSurface->pMipmapLevels[0].mipmapSize.width;
         const uint32_t cHeight = pSurface->pMipmapLevels[0].mipmapSize.height;
+        const uint32_t cDepth = pSurface->pMipmapLevels[0].mipmapSize.depth;
         const uint32_t numMipLevels = pSurface->faces[0].numMipLevels;
 
-        LogFunc(("Create shared %stexture copy d3d (%d,%d) cMip=%d usage %x format %x.\n",
-                  fCubeTexture ? "cube " : "",
+        LogFunc(("Create shared %stexture copy d3d (%d,%d,%d) cMip=%d usage %x format %x.\n",
+                  pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE ? "volume " :
+                  pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE ? "cube " :
+                  pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE ? "" : "UNKNOWN!!!",
                   cWidth,
                   cHeight,
+                  cDepth,
                   numMipLevels,
                   pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET,
@@ -1210 +1211 @@
         AssertReturn(ret, NULL);
 
-        /* Create shadow copy of the original shared texture. Shared d3d resources require Vista+ and have some restrictions. */
+        /* Create shadow copy of the original shared texture.
+         * Shared d3d resources require Vista+ and have some restrictions.
+         * D3DUSAGE_RENDERTARGET is required for use as a StretchRect destination.
+         */
         HRESULT hr;
-        if (fCubeTexture)
+        if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
+            hr = pContext->pDevice->CreateVolumeTexture(cWidth,
+                                                        cHeight,
+                                                        cDepth,
+                                                        numMipLevels,
+                                                        pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET,
+                                                        pSurface->formatD3D,
+                                                        D3DPOOL_DEFAULT,
+                                                        &pSharedSurface->u.pVolumeTexture,
+                                                        &pSurface->hSharedObject);
+        else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
             hr = pContext->pDevice->CreateCubeTexture(cWidth,
                                                       numMipLevels,
-                                                      pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
+                                                      pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET,
                                                       pSurface->formatD3D,
                                                       D3DPOOL_DEFAULT,
                                                       &pSharedSurface->u.pCubeTexture,
                                                       &pSurface->hSharedObject);
-        else
+        else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE)
             hr = pContext->pDevice->CreateTexture(cWidth,
                                                   cHeight,
                                                   numMipLevels,
-                                                  pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
+                                                  pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET,
                                                   pSurface->formatD3D,
                                                   D3DPOOL_DEFAULT,
                                                   &pSharedSurface->u.pTexture,
                                                   &pSurface->hSharedObject);
-        AssertMsgReturn(hr == D3D_OK, ("CreateTexture failed with %x\n", hr), NULL);
+        else
+            hr = E_FAIL;
+
+        if (RT_LIKELY(hr == D3D_OK))
+            /* likely */;
+        else
+        {
+            AssertMsgFailed(("CreateTexture type %d failed with %x\n", pSurface->enmD3DResType, hr));
+            RTAvlU32Remove(&pSurface->pSharedObjectTree, pContext->id);
+            RTMemFree(pSharedSurface);
+            return NULL;
+        }
     }
     return pSharedSurface;
@@ -1312 +1337 @@
 }
 
-DECLINLINE(D3DCUBEMAP_FACES) vmsvga3dCubemapFaceFromIndex(uint32_t iFace)
-{
-    D3DCUBEMAP_FACES Face;
-    switch (iFace)
-    {
-        case 0: Face = D3DCUBEMAP_FACE_POSITIVE_X; break;
-        case 1: Face = D3DCUBEMAP_FACE_NEGATIVE_X; break;
-        case 2: Face = D3DCUBEMAP_FACE_POSITIVE_Y; break;
-        case 3: Face = D3DCUBEMAP_FACE_NEGATIVE_Y; break;
-        case 4: Face = D3DCUBEMAP_FACE_POSITIVE_Z; break;
-        default:
-        case 5: Face = D3DCUBEMAP_FACE_NEGATIVE_Z; break;
-    }
-    return Face;
-}
-
 /** Get IDirect3DSurface9 for the given face and mipmap.
  */
@@ -1339 +1348 @@
     AssertPtrReturn(pSurface->u.pSurface, VERR_INVALID_PARAMETER);
 
-    const bool fTexture     = RT_BOOL(pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE);
-    const bool fCubeTexture = RT_BOOL(pSurface->flags & SVGA3D_SURFACE_CUBEMAP);
-
     IDirect3DBaseTexture9 *pTexture;
     if (fLockable && pSurface->bounce.pTexture)
@@ -1356 +1362 @@
                         VERR_INVALID_PARAMETER);
 
-        if (fTexture)
+        if (   pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE
+            || pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
         {
             LogFunc(("using texture sid=%x created for another context (%d vs %d)\n",
@@ -1376 +1383 @@
 #endif
 
-    if (fCubeTexture)
+    if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
     {
         Assert(pSurface->cFaces == 6);
@@ -1385 +1392 @@
         AssertMsgReturn(hr == D3D_OK, ("GetCubeMapSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
     }
-    else if (fTexture)
+    else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE)
     {
         Assert(pSurface->cFaces == 1);
@@ -1394 +1401 @@
         AssertMsgReturn(hr == D3D_OK, ("GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
     }
-    else
+    else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_SURFACE)
     {
         pSurface->u.pSurface->AddRef();
         *ppD3DSurf = pSurface->u.pSurface;
+    }
+    else
+    {
+        AssertMsgFailedReturn(("No surface for type %d\n", pSurface->enmD3DResType), VERR_INTERNAL_ERROR);
     }
 
@@ -1429 +1440 @@
     AssertRCReturn(rc, rc);
 
-    const bool fDestTexture = RT_BOOL(pSurfaceDest->flags & SVGA3D_SURFACE_HINT_TEXTURE);
-
-    if (    fDestTexture
-        &&  !pSurfaceDest->u.pSurface
-        &&  pSurfaceSrc->u.pSurface)
+    /* If src is HW and dst is not, then create the dst texture. */
+    if (   pSurfaceSrc->u.pSurface
+        && !pSurfaceDest->u.pSurface
+        && RT_BOOL(pSurfaceDest->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE))
     {
         const uint32_t cid = pSurfaceSrc->idAssociatedContext;
@@ -1441 +1451 @@
         AssertRCReturn(rc, rc);
 
-        LogFunc(("sid=%x type=%x format=%d -> create texture\n", sidDest, pSurfaceDest->flags, pSurfaceDest->format));
+        LogFunc(("sid=%x type=%x format=%d -> create texture\n", sidDest, pSurfaceDest->surfaceFlags, pSurfaceDest->format));
         rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurfaceDest);
         AssertRCReturn(rc, rc);
     }
+
+    Assert(pSurfaceSrc->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE); ///@todo
+    Assert(pSurfaceDest->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE); ///@todo
 
     if (   pSurfaceSrc->u.pSurface
@@ -1647 +1660 @@
 
         /* If the destination bounce texture has been used, then update the actual texture. */
-        if (   pSurfaceDest->u.pSurface
-            && fDestTexture
-            && pSurfaceDest->bounce.pTexture)
+        if (   pSurfaceDest->u.pTexture
+            && pSurfaceDest->bounce.pTexture
+            && (   pSurfaceDest->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE
+                || pSurfaceDest->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE))
         {
             AssertMsgReturn(pContext, ("Context is NULL\n"), VERR_INTERNAL_ERROR);
@@ -1656 +1670 @@
             IDirect3DBaseTexture9 *pSourceTexture;
             IDirect3DBaseTexture9 *pDestinationTexture;
-            if (pSurfaceDest->flags & SVGA3D_SURFACE_CUBEMAP)
+            if (pSurfaceDest->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
             {
                 pSourceTexture = pSurfaceDest->bounce.pCubeTexture;
@@ -1697 +1711 @@
     Assert(pSurface->u.pTexture == NULL);
     Assert(pSurface->bounce.pTexture == NULL);
+    Assert(pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_NONE);
 
     const uint32_t cWidth = pSurface->pMipmapLevels[0].mipmapSize.width;
     const uint32_t cHeight = pSurface->pMipmapLevels[0].mipmapSize.height;
+    const uint32_t cDepth = pSurface->pMipmapLevels[0].mipmapSize.depth;
     const uint32_t numMipLevels = pSurface->faces[0].numMipLevels;
 
@@ -1705 +1721 @@
      * Create D3D texture object.
      */
-    if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
+    if (pSurface->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
     {
         Assert(pSurface->cFaces == 6);
         Assert(cWidth == cHeight);
+        Assert(cDepth == 1);
 
         hr = pContext->pDevice->CreateCubeTexture(cWidth,
@@ -1745 +1762 @@
             AssertMsgReturn(hr == D3D_OK, ("CreateCubeTexture (fallback) failed with %x\n", hr), VERR_INTERNAL_ERROR);
         }
+
+        pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE;
     }
     else if (   pSurface->formatD3D == D3DFMT_D24S8
@@ -1751 +1770 @@
         Assert(pSurface->cFaces == 1);
         Assert(pSurface->faces[0].numMipLevels == 1);
+        Assert(cDepth == 1);
 
         /* Use the INTZ format for a depth/stencil surface that will be used as a texture */
         hr = pContext->pDevice->CreateTexture(cWidth,
                                               cHeight,
-                                              1,
+                                              1, /* mip levels */
                                               D3DUSAGE_DEPTHSTENCIL,
                                               FOURCC_INTZ,
@@ -1764 +1784 @@
 
         pSurface->fStencilAsTexture = true;
+        pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_TEXTURE;
     }
     else
     {
-        /** @todo if (depth > 1) CreateVolumeTexture */
-        Assert(pSurface->cFaces == 1);
-
-        hr = pContext->pDevice->CreateTexture(cWidth,
-                                              cHeight,
-                                              numMipLevels,
-                                              pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
-                                              pSurface->formatD3D,
-                                              D3DPOOL_DEFAULT,
-                                              &pSurface->u.pTexture,
-                                              &pSurface->hSharedObject);
-        if (hr == D3D_OK)
-        {
-            /* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
+        if (cDepth > 1)
+        {
+            hr = pContext->pDevice->CreateVolumeTexture(cWidth,
+                                                        cHeight,
+                                                        cDepth,
+                                                        numMipLevels,
+                                                        pSurface->fUsageD3D,
+                                                        pSurface->formatD3D,
+                                                        D3DPOOL_DEFAULT,
+                                                        &pSurface->u.pVolumeTexture,
+                                                        &pSurface->hSharedObject);
+            if (hr == D3D_OK)
+            {
+                /* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
+                hr = pContext->pDevice->CreateVolumeTexture(cWidth,
+                                                            cHeight,
+                                                            cDepth,
+                                                            numMipLevels,
+                                                            (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) | D3DUSAGE_DYNAMIC /* Lockable */,
+                                                            pSurface->formatD3D,
+                                                            D3DPOOL_SYSTEMMEM,
+                                                            &pSurface->bounce.pVolumeTexture,
+                                                            NULL);
+                AssertMsgReturnStmt(hr == D3D_OK,
+                                    ("CreateVolumeTexture (systemmem) failed with %x\n", hr),
+                                    D3D_RELEASE(pSurface->u.pVolumeTexture),
+                                    VERR_INTERNAL_ERROR);
+            }
+            else
+            {
+                Log(("Format not accepted -> try old method\n"));
+                /* The format was probably not accepted; fall back to our old mode. */
+                hr = pContext->pDevice->CreateVolumeTexture(cWidth,
+                                                            cHeight,
+                                                            cDepth,
+                                                            numMipLevels,
+                                                            (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) |  D3DUSAGE_DYNAMIC /* Lockable */,
+                                                            pSurface->formatD3D,
+                                                            D3DPOOL_DEFAULT,
+                                                            &pSurface->u.pVolumeTexture,
+                                                            &pSurface->hSharedObject);
+                AssertMsgReturn(hr == D3D_OK, ("CreateVolumeTexture (fallback) failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            }
+
+            pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE;
+        }
+        else
+        {
+            Assert(pSurface->cFaces == 1);
+
             hr = pContext->pDevice->CreateTexture(cWidth,
                                                   cHeight,
                                                   numMipLevels,
-                                                  (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) | D3DUSAGE_DYNAMIC /* Lockable */,
-                                                  pSurface->formatD3D,
-                                                  D3DPOOL_SYSTEMMEM,
-                                                  &pSurface->bounce.pTexture,
-                                                  NULL);
-            AssertMsgReturn(hr == D3D_OK, ("CreateTexture (systemmem) failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        }
-        else
-        {
-            Log(("Format not accepted -> try old method\n"));
-            /* The format was probably not accepted; fall back to our old mode. */
-            hr = pContext->pDevice->CreateTexture(cWidth,
-                                                  cHeight,
-                                                  numMipLevels,
-                                                  (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) |  D3DUSAGE_DYNAMIC /* Lockable */,
+                                                  pSurface->fUsageD3D | D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
                                                   pSurface->formatD3D,
                                                   D3DPOOL_DEFAULT,
                                                   &pSurface->u.pTexture,
-                                                  &pSurface->hSharedObject /* might result in poor performance */);
-            AssertMsgReturn(hr == D3D_OK, ("CreateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
-        }
-    }
+                                                  &pSurface->hSharedObject);
+            if (hr == D3D_OK)
+            {
+                /* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
+                hr = pContext->pDevice->CreateTexture(cWidth,
+                                                      cHeight,
+                                                      numMipLevels,
+                                                      (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) | D3DUSAGE_DYNAMIC /* Lockable */,
+                                                      pSurface->formatD3D,
+                                                      D3DPOOL_SYSTEMMEM,
+                                                      &pSurface->bounce.pTexture,
+                                                      NULL);
+                AssertMsgReturn(hr == D3D_OK, ("CreateTexture (systemmem) failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            }
+            else
+            {
+                Log(("Format not accepted -> try old method\n"));
+                /* The format was probably not accepted; fall back to our old mode. */
+                hr = pContext->pDevice->CreateTexture(cWidth,
+                                                      cHeight,
+                                                      numMipLevels,
+                                                      (pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) |  D3DUSAGE_DYNAMIC /* Lockable */,
+                                                      pSurface->formatD3D,
+                                                      D3DPOOL_DEFAULT,
+                                                      &pSurface->u.pTexture,
+                                                      &pSurface->hSharedObject /* might result in poor performance */);
+                AssertMsgReturn(hr == D3D_OK, ("CreateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            }
+
+            pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_TEXTURE;
+        }
+    }
+
+    Assert(hr == D3D_OK);
 
     if (pSurface->autogenFilter != SVGA3D_TEX_FILTER_NONE)
     {
         /* Set the mip map generation filter settings. */
-        if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
-            hr = pSurface->u.pCubeTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
+        IDirect3DBaseTexture9 *pBaseTexture;
+        if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
+            pBaseTexture = pSurface->u.pVolumeTexture;
+        else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
+            pBaseTexture = pSurface->u.pCubeTexture;
         else
-            hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
+            pBaseTexture = pSurface->u.pTexture;
+        hr = pBaseTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
         AssertMsg(hr == D3D_OK, ("vmsvga3dBackCreateTexture: SetAutoGenFilterType failed with %x\n", hr));
     }
@@ -1824 +1901 @@
     Log(("vmsvga3dBackCreateTexture: sync texture\n"));
 
-    if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
+    if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
+    {
+        IDirect3DVolumeTexture9 *pVolumeTexture = pSurface->bounce.pVolumeTexture ?
+                                                      pSurface->bounce.pVolumeTexture :
+                                                      pSurface->u.pVolumeTexture;
+
+        for (uint32_t i = 0; i < numMipLevels; ++i)
+        {
+            D3DLOCKED_BOX LockedVolume;
+            hr = pVolumeTexture->LockBox(i, &LockedVolume, NULL, D3DLOCK_DISCARD);
+            AssertMsgBreak(hr == D3D_OK, ("LockBox failed with %x\n", hr));
+
+            PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->pMipmapLevels[i];
+
+            LogFunc(("sync volume texture mipmap level %d (pitch row %x vs %x, slice %x vs %x)\n",
+                      i, LockedVolume.RowPitch, pMipLevel->cbSurfacePitch, LockedVolume.SlicePitch, pMipLevel->cbSurfacePlane));
+
+
+            uint8_t *pDst = (uint8_t *)LockedVolume.pBits;
+            const uint8_t *pSrc = (uint8_t *)pMipLevel->pSurfaceData;
+            for (uint32_t d = 0; d < cDepth; ++d)
+            {
+                uint8_t *pRowDst = pDst;
+                const uint8_t *pRowSrc = pSrc;
+                for (uint32_t h = 0; h < pMipLevel->cBlocksY; ++h)
+                {
+//                    memcpy(pRowDst, pRowSrc, pMipLevel->cbSurfacePitch);
+                    pRowDst += LockedVolume.RowPitch;
+                    pRowSrc += pMipLevel->cbSurfacePitch;
+                }
+                pDst += LockedVolume.SlicePitch;
+                pSrc += pMipLevel->cbSurfacePlane;
+            }
+
+            hr = pVolumeTexture->UnlockBox(i);
+            AssertMsgBreak(hr == D3D_OK, ("UnlockBox failed with %x\n", hr));
+
+            pMipLevel->fDirty = false;
+        }
+    }
+    else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
     {
         IDirect3DCubeTexture9 *pCubeTexture = pSurface->bounce.pCubeTexture ?
@@ -1891 +2008 @@
             AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
-            Log(("vmsvga3dBackCreateTexture: sync texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pSurface->pMipmapLevels[i].cbSurfacePitch));
+            LogFunc(("sync texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pSurface->pMipmapLevels[i].cbSurfacePitch));
 
             uint8_t *pDest = (uint8_t *)LockedRect.pBits;
@@ -1914 +2031 @@
         Log(("vmsvga3dBackCreateTexture: sync dirty texture from bounce buffer\n"));
 
-        if (pSurface->flags & SVGA3D_SURFACE_CUBEMAP)
+        if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
+            hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pVolumeTexture, pSurface->u.pVolumeTexture);
+        else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
             hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pCubeTexture, pSurface->u.pCubeTexture);
         else
             hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pTexture, pSurface->u.pTexture);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
+        AssertMsgReturn(hr == D3D_OK, ("UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
         /* We will now use the bounce texture for all memory accesses, so free our surface memory buffer. */
@@ -1929 +2048 @@
     pSurface->fDirty = false;
 
-    pSurface->flags              |= SVGA3D_SURFACE_HINT_TEXTURE;
+    Assert(pSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_NONE);
+
+    pSurface->surfaceFlags       |= SVGA3D_SURFACE_HINT_TEXTURE;
     pSurface->idAssociatedContext = idAssociatedContext;
     return VINF_SUCCESS;
@@ -1960 +2081 @@
     int rc;
 
+    AssertReturn(pSrcSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE, VERR_NOT_IMPLEMENTED);
+    AssertReturn(pDstSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE, VERR_NOT_IMPLEMENTED);
+
     /* Flush the drawing pipeline for this surface as it could be used in a shared context. */
     vmsvga3dSurfaceFlush(pThis, pSrcSurface);
@@ -2042 +2166 @@
 {
     HRESULT hr = D3D_OK;
-    const uint32_t u32SurfHints = pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
+    const uint32_t u32SurfHints = pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
     const DWORD dwFlags = transfer == SVGA3D_READ_HOST_VRAM ? D3DLOCK_READONLY : 0;
     // if (u32SurfHints != 0x18 && u32SurfHints != 0x60) ASMBreakpoint();
 
-    bool fTexture =    RT_BOOL(u32SurfHints & (SVGA3D_SURFACE_HINT_TEXTURE |
-                                               SVGA3D_SURFACE_CUBEMAP))
-                    || pSurface->fStencilAsTexture;
-
-    bool fRenderTarget = RT_BOOL(u32SurfHints & SVGA3D_SURFACE_HINT_RENDERTARGET);
-
-    if (fTexture || fRenderTarget)
+    AssertReturn(pSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE, VERR_NOT_IMPLEMENTED);
+
+    const bool fTexture =    pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE
+                          || pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE;
+    if (   pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_SURFACE
+        || fTexture)
     {
         rc = vmsvga3dContextFromCid(pState, pSurface->idAssociatedContext, &pContext);
@@ -2068 +2191 @@
             {
                 if (   transfer == SVGA3D_READ_HOST_VRAM
-                    && fRenderTarget
+                    && RT_BOOL(u32SurfHints & SVGA3D_SURFACE_HINT_RENDERTARGET)
                     && iBox == 0 /* only the first time */)
                 {
@@ -2146 +2269 @@
         }
     }
-    else if (RT_BOOL(u32SurfHints & (SVGA3D_SURFACE_HINT_VERTEXBUFFER |
-                                     SVGA3D_SURFACE_HINT_INDEXBUFFER)))
+    else if (   pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER
+             || pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_INDEX_BUFFER)
     {
         /*
@@ -2162 +2285 @@
 
         /* Current type of the buffer. */
-        const bool fVertex = RT_BOOL(pSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER);
+        const bool fVertex = pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER;
 
         /* Caller already clipped pBox and buffers are 1-dimensional. */
@@ -2218 +2341 @@
     else
     {
-        AssertMsgFailed(("Unsupported surface hint 0x%08X\n", u32SurfHints));
+        AssertMsgFailed(("Unsupported surface hint 0x%08X, type %d\n", u32SurfHints, pSurface->enmD3DResType));
     }
 
@@ -2377 +2500 @@
 
         /* Unknown surface type; turn it into a texture. */
-        Log(("vmsvga3dGenerateMipmaps: unknown src surface sid=%x type=%d format=%d -> create texture\n", sid, pSurface->flags, pSurface->format));
+        LogFunc(("unknown src surface sid=%x type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
         rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
         AssertRCReturn(rc, rc);
@@ -2384 +2507 @@
     {
         hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)filter);
-        AssertMsg(hr == D3D_OK, ("vmsvga3dGenerateMipmaps: SetAutoGenFilterType failed with %x\n", hr));
+        AssertMsg(hr == D3D_OK, ("SetAutoGenFilterType failed with %x\n", hr));
     }
 
@@ -2398 +2521 @@
     PVMSVGA3DSURFACE    pSurface;
     PVMSVGA3DCONTEXT    pContext;
-    uint32_t            cid;
     HRESULT             hr;
+    int                 rc;
     IDirect3DSurface9  *pBackBuffer;
     IDirect3DSurface9  *pSurfaceD3D;
 
     AssertReturn(pState, VERR_NO_MEMORY);
-    AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
-    AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
-
-    pSurface = pState->papSurfaces[sid];
+
+    rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
+    AssertRCReturn(rc, rc);
+
     AssertReturn(pSurface->idAssociatedContext != SVGA3D_INVALID_ID, VERR_INTERNAL_ERROR);
 
-    /** @todo stricter checks for associated context */
-    cid = pSurface->idAssociatedContext;
-    Log(("vmsvga3dCommandPresent: sid=%x cRects=%d cid=%x\n", sid, cRects, cid));
-    for (uint32_t i=0; i < cRects; i++)
-    {
-        Log(("vmsvga3dCommandPresent: rectangle %d src=(%d,%d) (%d,%d)(%d,%d)\n", i, pRect[i].srcx, pRect[i].srcy, pRect[i].x, pRect[i].y, pRect[i].x + pRect[i].w, pRect[i].y + pRect[i].h));
-    }
-
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dCommandPresent invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+    LogFunc(("sid=%x cRects=%d cid=%x\n", sid, cRects, pSurface->idAssociatedContext));
+    for (uint32_t i = 0; i < cRects; ++i)
+    {
+        LogFunc(("rectangle %d src=(%d,%d) (%d,%d)(%d,%d)\n", i, pRect[i].srcx, pRect[i].srcy, pRect[i].x, pRect[i].y, pRect[i].x + pRect[i].w, pRect[i].y + pRect[i].h));
+    }
+
+    rc = vmsvga3dContextFromCid(pState, pSurface->idAssociatedContext, &pContext);
+    AssertRCReturn(rc, rc);
 
     hr = pContext->pDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: GetBackBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-    if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
-    {
-        hr = pSurface->u.pTexture->GetSurfaceLevel(0, &pSurfaceD3D);
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
-    }
-    else
-        pSurfaceD3D = pSurface->u.pSurface;
+    AssertMsgReturn(hr == D3D_OK, ("GetBackBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
+
+    rc = vmsvga3dGetD3DSurface(pContext, pSurface, 0, 0, false, &pSurfaceD3D);
+    AssertRCReturn(rc, rc);
 
     /* Read the destination viewport specs in one go to try avoid some unnecessary update races. */
@@ -2612 +2723 @@
     }
 
-    if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
-        D3D_RELEASE(pSurfaceD3D);
-
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    D3D_RELEASE(pSurfaceD3D);
+    D3D_RELEASE(pBackBuffer);
+
+    AssertMsgReturn(hr == D3D_OK, ("StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     hr = pContext->pDevice->Present(NULL, NULL, NULL, NULL);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: Present failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
-    D3D_RELEASE(pBackBuffer);
+    AssertMsgReturn(hr == D3D_OK, ("Present failed with %x\n", hr), VERR_INTERNAL_ERROR);
+
     return VINF_SUCCESS;
 }
@@ -2776 +2886 @@
                 int rc;
 
-                Log(("vmsvga3dContextDestroy: remove all dependencies for surface sid=%x\n", sid));
-
-                uint32_t            surfaceFlags = pSurface->flags;
+                LogFunc(("Remove all dependencies for surface sid=%x\n", sid));
+
+                uint32_t            surfaceFlags = pSurface->surfaceFlags;
                 SVGA3dSurfaceFormat format = pSurface->format;
                 SVGA3dSurfaceFace   face[SVGA3D_MAX_SURFACE_FACES];
@@ -2817 +2927 @@
                 if (pSharedSurface)
                 {
-                    Log(("vmsvga3dContextDestroy: remove shared dependency for surface sid=%x\n", sid));
-
-                    switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
+                    LogFunc(("Remove shared dependency for surface sid=%x\n", sid));
+
+                    switch (pSurface->enmD3DResType)
                     {
-                    case SVGA3D_SURFACE_HINT_TEXTURE:
-                    case SVGA3D_SURFACE_HINT_TEXTURE | SVGA3D_SURFACE_HINT_RENDERTARGET:
+                    case VMSVGA3D_D3DRESTYPE_TEXTURE:
                         Assert(pSharedSurface->u.pTexture);
                         D3D_RELEASE(pSharedSurface->u.pTexture);
+                        break;
+
+                    case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
+                        Assert(pSharedSurface->u.pCubeTexture);
+                        D3D_RELEASE(pSharedSurface->u.pCubeTexture);
+                        break;
+
+                    case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
+                        Assert(pSharedSurface->u.pVolumeTexture);
+                        D3D_RELEASE(pSharedSurface->u.pVolumeTexture);
                         break;
 
@@ -3988 +4107 @@
     AssertReturn(pState, VERR_NO_MEMORY);
     AssertReturn(type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
-    AssertReturn(target.face == 0, VERR_INVALID_PARAMETER);
-
-    Log(("vmsvga3dSetRenderTarget cid=%x type=%x sid=%x\n", cid, type, target.sid));
-
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dSetRenderTarget invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+
+    LogFunc(("cid=%x type=%x sid=%x\n", cid, type, target.sid));
+
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     /* Save for vm state save/restore. */
@@ -4010 +4123 @@
         case SVGA3D_RT_DEPTH:
             hr = pContext->pDevice->SetDepthStencilSurface(NULL);
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            AssertMsgReturn(hr == D3D_OK, ("SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
             break;
 
@@ -4029 +4142 @@
             if (pState->fSupportedSurfaceNULL)
             {
-                /* Create a dummy render target to satisfy D3D. This path is usually taken only to render into a depth buffer without
-                 * wishing to update an actual color render target
+                /* Create a dummy render target to satisfy D3D. This path is usually taken only to render
+                 * into a depth buffer without wishing to update an actual color render target.
                  */
-                IDirect3DSurface9* pDummyRenderTarget;
+                IDirect3DSurface9 *pDummyRenderTarget;
                 hr = pContext->pDevice->CreateRenderTarget(pThis->svga.uWidth,
                                                            pThis->svga.uHeight,
@@ -4042 +4155 @@
                                                            NULL);
 
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: CreateRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                AssertMsgReturn(hr == D3D_OK, ("CreateRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
                 hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pDummyRenderTarget);
@@ -4050 +4163 @@
                 hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, NULL);
 
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            AssertMsgReturn(hr == D3D_OK, ("SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
             break;
 
@@ -4059 +4172 @@
     }
 
-    AssertReturn(target.sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
-    AssertReturn(target.sid < pState->cSurfaces && pState->papSurfaces[target.sid]->id == target.sid, VERR_INVALID_PARAMETER);
-    pRenderTarget = pState->papSurfaces[target.sid];
+    rc = vmsvga3dSurfaceFromSid(pState, target.sid, &pRenderTarget);
+    AssertRCReturn(rc, rc);
 
     switch (type)
@@ -4067 +4179 @@
     case SVGA3D_RT_DEPTH:
     case SVGA3D_RT_STENCIL:
-        AssertReturn(target.mipmap == 0, VERR_INVALID_PARAMETER);
+        AssertReturn(target.face == 0 && target.mipmap == 0, VERR_INVALID_PARAMETER);
         if (!pRenderTarget->u.pSurface)
         {
@@ -4089 +4201 @@
                      || pRenderTarget->formatD3D == D3DFMT_D24X8))
             {
-                Log(("vmsvga3dSetRenderTarget: Creating stencil surface as texture!\n"));
+                LogFunc(("Creating stencil surface as texture!\n"));
                 int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
-                AssertRC(rc);   /* non-fatal */
+                AssertRC(rc);   /* non-fatal, will use CreateDepthStencilSurface */
             }
 
             if (!pRenderTarget->fStencilAsTexture)
             {
-                Log(("vmsvga3dSetRenderTarget DEPTH/STENCIL; cQualityLevels=%d\n", cQualityLevels));
+                Assert(!pRenderTarget->u.pSurface);
+
+                LogFunc(("DEPTH/STENCIL; cQualityLevels=%d\n", cQualityLevels));
                 hr = pContext->pDevice->CreateDepthStencilSurface(pRenderTarget->pMipmapLevels[0].mipmapSize.width,
                                                                   pRenderTarget->pMipmapLevels[0].mipmapSize.height,
@@ -4105 +4219 @@
                                                                   &pRenderTarget->u.pSurface,
                                                                   NULL);
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: CreateDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                AssertMsgReturn(hr == D3D_OK, ("CreateDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                pRenderTarget->enmD3DResType = VMSVGA3D_D3DRESTYPE_SURFACE;
             }
 
@@ -4157 +4272 @@
 
         pRenderTarget->fUsageD3D            |= D3DUSAGE_DEPTHSTENCIL;
-        pRenderTarget->flags                |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
+        pRenderTarget->surfaceFlags         |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
 
         if (pRenderTarget->fStencilAsTexture)
@@ -4164 +4279 @@
 
             hr = pRenderTarget->u.pTexture->GetSurfaceLevel(0, &pStencilSurface);
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            AssertMsgReturn(hr == D3D_OK, ("GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
             hr = pContext->pDevice->SetDepthStencilSurface(pStencilSurface);
             D3D_RELEASE(pStencilSurface);
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            AssertMsgReturn(hr == D3D_OK, ("SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
         }
         else
         {
             hr = pContext->pDevice->SetDepthStencilSurface(pRenderTarget->u.pSurface);
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            AssertMsgReturn(hr == D3D_OK, ("SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
         }
         break;
@@ -4188 +4303 @@
         IDirect3DSurface9 *pSurface;
         bool fTexture = false;
-        bool fShared = false;
 
         /* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
         vmsvga3dSurfaceFlush(pThis, pRenderTarget);
 
-        if (pRenderTarget->flags & SVGA3D_SURFACE_HINT_TEXTURE)
+        if (pRenderTarget->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE)
         {
             fTexture = true;
@@ -4200 +4314 @@
             if (!pRenderTarget->u.pTexture)
             {
-                Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; sid=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->flags, pRenderTarget->format));
+                LogFunc(("Create texture to be used as render target; sid=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
                 int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
                 AssertRCReturn(rc, rc);
             }
 
-#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
-            if (pRenderTarget->idAssociatedContext != cid)
-            {
-                Log(("vmsvga3dSetRenderTarget; using texture sid=%x created for another context (%d vs %d)\n", target.sid, pRenderTarget->idAssociatedContext, cid));
-
-                PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pContext, pRenderTarget);
-                AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
-
-                hr = pSharedSurface->u.pTexture->GetSurfaceLevel(target.mipmap,
-                                                                 &pSurface);
-
-                fShared = true;
-            }
-            else
-#endif
-                hr = pRenderTarget->u.pTexture->GetSurfaceLevel(target.mipmap,
-                                                                &pSurface);
-
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
+            rc = vmsvga3dGetD3DSurface(pContext,  pRenderTarget, target.face, target.mipmap, false, &pSurface);
+            AssertRCReturn(rc, rc);
         }
         else
         {
-            AssertReturn(target.mipmap == 0, VERR_INVALID_PARAMETER);
+            AssertReturn(target.face == 0 && target.mipmap == 0, VERR_INVALID_PARAMETER);
             if (!pRenderTarget->u.pSurface)
             {
@@ -4244 +4341 @@
                 }
 
-                Log(("vmsvga3dSetRenderTarget COLOR; cQualityLevels=%d\n", cQualityLevels));
-                Log(("Create rendertarget (%d,%d) format=%x multisample=%x\n", pRenderTarget->pMipmapLevels[0].mipmapSize.width, pRenderTarget->pMipmapLevels[0].mipmapSize.height, pRenderTarget->formatD3D, pRenderTarget->multiSampleTypeD3D));
+                LogFunc(("COLOR; cQualityLevels=%d\n", cQualityLevels));
+                LogFunc(("Create rendertarget (%d,%d) formatD3D=%x multisample=%x\n",
+                         pRenderTarget->pMipmapLevels[0].mipmapSize.width, pRenderTarget->pMipmapLevels[0].mipmapSize.height, pRenderTarget->formatD3D, pRenderTarget->multiSampleTypeD3D));
 
                 hr = pContext->pDevice->CreateRenderTarget(pRenderTarget->pMipmapLevels[0].mipmapSize.width,
@@ -4257 +4355 @@
                 AssertReturn(hr == D3D_OK, VERR_INTERNAL_ERROR);
 
-                pRenderTarget->idAssociatedContext   = cid;
+                pRenderTarget->idAssociatedContext = cid;
+                pRenderTarget->enmD3DResType       = VMSVGA3D_D3DRESTYPE_SURFACE;
             }
             else
@@ -4263 +4362 @@
 
             Assert(pRenderTarget->idAssociatedContext == cid);
+            Assert(pRenderTarget->enmD3DResType == VMSVGA3D_D3DRESTYPE_SURFACE);
             pSurface = pRenderTarget->u.pSurface;
         }
@@ -4270 +4370 @@
 
         pRenderTarget->fUsageD3D            |= D3DUSAGE_RENDERTARGET;
-        pRenderTarget->flags                |= SVGA3D_SURFACE_HINT_RENDERTARGET;
+        pRenderTarget->surfaceFlags         |= SVGA3D_SURFACE_HINT_RENDERTARGET;
 
         hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pSurface);
         if (fTexture)
             D3D_RELEASE(pSurface);    /* Release reference to texture level 0 */
-        AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
+        AssertMsgReturn(hr == D3D_OK, ("SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
         pContext->sidRenderTarget = target.sid;
@@ -4418 +4518 @@
     AssertReturn(pState, VERR_NO_MEMORY);
 
-    Log(("vmsvga3dSetTextureState %x cTextureState=%d\n", cid, cTextureStates));
-
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dSetTextureState invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+    LogFunc(("%x cTextureState=%d\n", cid, cTextureStates));
+
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     for (unsigned i = 0; i < cTextureStates; i++)
@@ -4434 +4529 @@
         uint32_t                 currentStage = pTextureState[i].stage;
 
-        Log(("vmsvga3dSetTextureState: cid=%x stage=%d type=%s (%x) val=%x\n", cid, currentStage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
+        LogFunc(("cid=%x stage=%d type=%s (%x) val=%x\n", cid, currentStage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
 
         /** @todo Is this the appropriate limit for all kinds of textures?  It is the
@@ -4440 +4535 @@
         if (RT_UNLIKELY(currentStage >= SVGA3D_MAX_TEXTURE_STAGE))
         {
-            AssertMsgFailed(("pTextureState[%d].stage=%#x name=%#x\n", i, pTextureState[i].stage, pTextureState[i].name));
+            AssertMsgFailed(("pTextureState[%d].stage=%#x name=%#x value=%#x\n", i, pTextureState[i].stage, pTextureState[i].name, pTextureState[i].value));
             continue;
         }
@@ -4541 +4636 @@
                 /* Unselect the currently associated texture. */
                 hr = pContext->pDevice->SetTexture(currentStage, NULL);
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                AssertMsgReturn(hr == D3D_OK, ("SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
             }
             else
             {
-                HRESULT hr;
-                uint32_t sid = pTextureState[i].value;
-
-                AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
-                AssertReturn(sid < pState->cSurfaces && pState->papSurfaces[sid]->id == sid, VERR_INVALID_PARAMETER);
-
-                PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
+                PVMSVGA3DSURFACE pSurface;
+                const uint32_t sid = pTextureState[i].value;
+
+                rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
+                AssertRCReturn(rc, rc);
 
                 Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture sid=%x (%d,%d)\n", currentStage, pTextureState[i].value, pSurface->pMipmapLevels[0].mipmapSize.width, pSurface->pMipmapLevels[0].mipmapSize.height));
@@ -4558 +4651 @@
                 {
                     Assert(pSurface->idAssociatedContext == SVGA3D_INVALID_ID);
-                    Log(("CreateTexture (%d,%d) level=%d fUsage=%x format=%x\n", pSurface->pMipmapLevels[0].mipmapSize.width, pSurface->pMipmapLevels[0].mipmapSize.height, pSurface->faces[0].numMipLevels, pSurface->fUsageD3D, pSurface->formatD3D));
-                    int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
+                    LogFunc(("CreateTexture (%d,%d) level=%d fUsage=%x format=%x\n", pSurface->pMipmapLevels[0].mipmapSize.width, pSurface->pMipmapLevels[0].mipmapSize.height, pSurface->faces[0].numMipLevels, pSurface->fUsageD3D, pSurface->formatD3D));
+                    rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
                     AssertRCReturn(rc, rc);
                 }
@@ -4571 +4664 @@
                 if (pSurface->idAssociatedContext != cid)
                 {
-                    Log(("vmsvga3dSetTextureState; using texture sid=%x created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
+                    LogFunc(("using texture sid=%x created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
 
                     PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pContext, pSurface);
@@ -4582 +4675 @@
                     hr = pContext->pDevice->SetTexture(currentStage, pSurface->u.pTexture);
 
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                AssertMsgReturn(hr == D3D_OK, ("SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
                 pContext->aSidActiveTexture[currentStage] = sid;
@@ -4691 +4784 @@
     AssertReturn(pState, VERR_NO_MEMORY);
 
-    Log(("vmsvga3dSetMaterial %x face %d\n", cid, face));
-
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dSetMaterial invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+    LogFunc(("cid=%x face %d\n", cid, face));
+
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     AssertReturn(face < SVGA3D_FACE_MAX, VERR_INVALID_PARAMETER);
@@ -4733 +4821 @@
 
     hr = pContext->pDevice->SetMaterial(&material);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetMaterial: SetMaterial failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("SetMaterial failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     return VINF_SUCCESS;
@@ -4748 +4836 @@
     Log(("vmsvga3dSetLightData %x index=%d\n", cid, index));
 
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dSetLightData invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     switch (pData->type)
@@ -4812 +4895 @@
 
     hr = pContext->pDevice->SetLight(index, &light);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetLightData: SetLight failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("SetLight failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     return VINF_SUCCESS;
@@ -4826 +4909 @@
     Log(("vmsvga3dSetLightEnabled %x %d -> %d\n", cid, index, enabled));
 
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dSetLightEnabled invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     /* Store for vm state save/restore */
@@ -4841 +4919 @@
 
     hr = pContext->pDevice->LightEnable(index, (BOOL)enabled);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetLightEnabled: LightEnable failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("LightEnable failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     return VINF_SUCCESS;
@@ -4856 +4934 @@
     Log(("vmsvga3dSetViewPort %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
 
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dSetViewPort invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
+
     /* Save for vm state save/restore. */
-    pContext = pState->papContexts[cid];
     pContext->state.RectViewPort = *pRect;
     pContext->state.u32UpdateFlags |= VMSVGA3D_UPDATE_VIEWPORT;
 
     hr = pContext->pDevice->GetViewport(&viewPort);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetViewPort: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     viewPort.X      = pRect->x;
@@ -4877 +4951 @@
 
     hr = pContext->pDevice->SetViewport(&viewPort);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetViewPort: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     return VINF_SUCCESS;
 }
 
-int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid,  uint32_t index, float plane[4])
+int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid, uint32_t index, float plane[4])
 {
     HRESULT               hr;
@@ -4892 +4966 @@
     AssertReturn(index < SVGA3D_CLIPPLANE_MAX, VERR_INVALID_PARAMETER);
 
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dSetClipPlane invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     /* Store for vm state save/restore. */
@@ -4905 +4974 @@
 
     hr = pContext->pDevice->SetClipPlane(index, plane);
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetClipPlane: SetClipPlane failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("SetClipPlane failed with %x\n", hr), VERR_INTERNAL_ERROR);
     return VINF_SUCCESS;
 }
@@ -4920 +4989 @@
     Log(("vmsvga3dCommandClear %x clearFlag=%x color=%x depth=%d stencil=%x cRects=%d\n", cid, clearFlag, color, (uint32_t)(depth * 100.0), stencil, cRects));
 
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dCommandClear invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-    pContext = pState->papContexts[cid];
+    int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     if (clearFlag & SVGA3D_CLEAR_COLOR)
@@ -4954 +5018 @@
         RTMemFree(pRectD3D);
 
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandClear: Clear failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("Clear failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
     /* Make sure we can track drawing usage of active render targets. */
@@ -4964 +5028 @@
 
 /* Convert VMWare vertex declaration to its D3D equivalent. */
-int vmsvga3dVertexDecl2D3D(SVGA3dVertexArrayIdentity &identity, D3DVERTEXELEMENT9 *pVertexElement)
+static int vmsvga3dVertexDecl2D3D(SVGA3dVertexArrayIdentity &identity, D3DVERTEXELEMENT9 *pVertexElement)
 {
     /* usage, method and type are identical; make sure. */
@@ -4984 +5048 @@
 
 /* Convert VMWare primitive type to its D3D equivalent. */
-int vmsvga3dPrimitiveType2D3D(SVGA3dPrimitiveType PrimitiveType, D3DPRIMITIVETYPE *pPrimitiveTypeD3D)
+static int vmsvga3dPrimitiveType2D3D(SVGA3dPrimitiveType PrimitiveType, D3DPRIMITIVETYPE *pPrimitiveTypeD3D)
 {
     switch (PrimitiveType)
@@ -5012 +5076 @@
 }
 
-int vmsvga3dDrawPrimitivesProcessVertexDecls(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t idStream, D3DVERTEXELEMENT9 *pVertexElement)
+static int vmsvga3dDrawPrimitivesProcessVertexDecls(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl, uint32_t idStream, D3DVERTEXELEMENT9 *pVertexElement)
 {
     HRESULT               hr;
@@ -5047 +5111 @@
             uVertexMinOffset = pVertexDecl[iVertex].array.offset;
 
-        /* pVertexSurface->u. is an union, so pVertexSurface->u.pIndexBuffer and pVertexSurface->u.pVertexBuffer are the same */
-        if (   pVertexSurface->u.pVertexBuffer
-            && !(pVertexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER))
+        if (   pVertexSurface->u.pSurface
+            && pVertexSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER)
         {
             /* The buffer object is not an vertex one. Switch type. */
-            Assert(pVertexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_INDEXBUFFER);
-            pVertexSurface->fu32ActualUsageFlags &= ~SVGA3D_SURFACE_HINT_INDEXBUFFER;
-
+            Assert(pVertexSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_INDEX_BUFFER);
             D3D_RELEASE(pVertexSurface->u.pIndexBuffer);
+            pVertexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_NONE;
+
             LogFunc(("index -> vertex buffer sid=%x\n", sidVertex));
         }
@@ -5063 +5126 @@
             Assert(iVertex == 0);
 
-            Log(("vmsvga3dDrawPrimitives: create vertex buffer fDirty=%d\n", pVertexSurface->fDirty));
+            LogFunc(("create vertex buffer fDirty=%d\n", pVertexSurface->fDirty));
             hr = pContext->pDevice->CreateVertexBuffer(pVertexSurface->pMipmapLevels[0].cbSurface,
                                                        D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY /* possible severe performance penalty otherwise (according to d3d debug output) */,
@@ -5070 +5133 @@
                                                        &pVertexSurface->u.pVertexBuffer,
                                                        NULL);
-            AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateVertexBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
-
+            AssertMsgReturn(hr == D3D_OK, ("CreateVertexBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
+
+            pVertexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER;
             pVertexSurface->idAssociatedContext = pContext->id;
 
@@ -5079 +5143 @@
 
                 hr = pVertexSurface->u.pVertexBuffer->Lock(0, 0, &pData, 0);
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Lock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                AssertMsgReturn(hr == D3D_OK, ("Lock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
 
                 memcpy(pData, pVertexSurface->pMipmapLevels[0].pSurfaceData, pVertexSurface->pMipmapLevels[0].cbSurface);
 
                 hr = pVertexSurface->u.pVertexBuffer->Unlock();
-                AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Unlock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
+                AssertMsgReturn(hr == D3D_OK, ("Unlock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
                 pVertexSurface->pMipmapLevels[0].fDirty = false;
                 pVertexSurface->fDirty = false;
             }
-            pVertexSurface->flags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
-            pVertexSurface->fu32ActualUsageFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
+            pVertexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
         }
     }
@@ -5099 +5162 @@
 #ifdef LOG_ENABLED
         if (pVertexElement[iVertex].Offset >= pVertexDecl[0].array.stride)
-            Log(("vmsvga3dDrawPrimitives: WARNING: offset > stride!!\n"));
+            LogFunc(("WARNING: offset > stride!!\n"));
 #endif
 
-        Log(("vmsvga3dDrawPrimitives: vertex %d offset = %d (stride %d) (min=%d max=%d)\n", iVertex, pVertexDecl[iVertex].array.offset, pVertexDecl[iVertex].array.stride, uVertexMinOffset, uVertexMaxOffset));
+        LogFunc(("vertex %d offset = %d (stride %d) (min=%d max=%d)\n", iVertex, pVertexDecl[iVertex].array.offset, pVertexDecl[iVertex].array.stride, uVertexMinOffset, uVertexMaxOffset));
     }
 
@@ -5111 +5174 @@
     pVertexSurface = pState->papSurfaces[sidVertex];
 
-    Log(("vmsvga3dDrawPrimitives: SetStreamSource %d min offset=%d stride=%d\n", idStream, uVertexMinOffset, strideVertex));
+    LogFunc(("SetStreamSource %d min offset=%d stride=%d\n", idStream, uVertexMinOffset, strideVertex));
     hr = pContext->pDevice->SetStreamSource(idStream,
                                             pVertexSurface->u.pVertexBuffer,
@@ -5117 +5180 @@
                                             strideVertex);
 
-    AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetStreamSource failed with %x\n", hr), VERR_INTERNAL_ERROR);
+    AssertMsgReturn(hr == D3D_OK, ("SetStreamSource failed with %x\n", hr), VERR_INTERNAL_ERROR);
     return VINF_SUCCESS;
 }
@@ -5136 +5199 @@
     D3DVERTEXELEMENT9            VertexEnd = D3DDECL_END();
 
-    Log(("vmsvga3dDrawPrimitives %x numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
+    LogFunc(("%x numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
 
     AssertReturn(numVertexDecls && numVertexDecls <= SVGA3D_MAX_VERTEX_ARRAYS, VERR_INVALID_PARAMETER);
@@ -5144 +5207 @@
     Assert(!cVertexDivisor);
 
-    if (    cid >= pState->cContexts
-        ||  pState->papContexts[cid]->id != cid)
-    {
-        Log(("vmsvga3dDrawPrimitives invalid context id!\n"));
-        return VERR_INVALID_PARAMETER;
-    }
-
-    pContext = pState->papContexts[cid];
+    rc = vmsvga3dContextFromCid(pState, cid, &pContext);
+    AssertRCReturn(rc, rc);
 
     /* Begin a scene before rendering anything. */
@@ -5246 +5303 @@
             AssertMsg(pRange[iPrimitive].indexWidth == sizeof(uint32_t) || pRange[iPrimitive].indexWidth == sizeof(uint16_t), ("Unsupported primitive width %d\n", pRange[iPrimitive].indexWidth));
 
-            if (    sidIndex >= SVGA3D_MAX_SURFACE_IDS
-                ||  sidIndex >= pState->cSurfaces
-                ||  pState->papSurfaces[sidIndex]->id != sidIndex)
-            {
-                Assert(sidIndex < SVGA3D_MAX_SURFACE_IDS);
-                Assert(sidIndex < pState->cSurfaces && pState->papSurfaces[sidIndex]->id == sidIndex);
-                rc = VERR_INVALID_PARAMETER;
+            rc = vmsvga3dSurfaceFromSid(pState, sidIndex, &pIndexSurface);
+            if (RT_FAILURE(rc))
                 goto internal_error;
-            }
-            pIndexSurface = pState->papSurfaces[sidIndex];
+
             Log(("vmsvga3dDrawPrimitives: index sid=%x\n", sidIndex));
 
-            /* pIndexSurface->u. is an union, so pIndexSurface->u.pIndexBuffer and pIndexSurface->u.pVertexBuffer are the same */
-            if (   pIndexSurface->u.pIndexBuffer
-                && !(pIndexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_INDEXBUFFER))
+            if (   pIndexSurface->u.pSurface
+                && pIndexSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_INDEX_BUFFER)
             {
                 /* The buffer object is not an index one. Switch type. */
-                Assert(pIndexSurface->fu32ActualUsageFlags & SVGA3D_SURFACE_HINT_VERTEXBUFFER);
-                pIndexSurface->fu32ActualUsageFlags &= ~SVGA3D_SURFACE_HINT_VERTEXBUFFER;
-
+                Assert(pIndexSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER);
                 D3D_RELEASE(pIndexSurface->u.pVertexBuffer);
+                pIndexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_NONE;
+
                 LogFunc(("vertex -> index buffer sid=%x\n", sidIndex));
             }
@@ -5286 +5336 @@
                     goto internal_error;
                 }
+                pIndexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_INDEX_BUFFER;
 
                 if (pIndexSurface->fDirty)
@@ -5304 +5355 @@
                     pIndexSurface->fDirty = false;
                 }
-                pIndexSurface->flags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
-                pIndexSurface->fu32ActualUsageFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
+                pIndexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
             }
 
             hr = pContext->pDevice->SetIndices(pIndexSurface->u.pIndexBuffer);
-            AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetIndices vertex failed with %x\n", hr));
+            AssertMsg(hr == D3D_OK, ("SetIndices vertex failed with %x\n", hr));
         }
         else
         {
             hr = pContext->pDevice->SetIndices(NULL);
-            AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetIndices vertex (NULL) failed with %x\n", hr));
+            AssertMsg(hr == D3D_OK, ("SetIndices vertex (NULL) failed with %x\n", hr));
         }
 

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

@@ -209 +209 @@
     }
 
-    pSurface->flags             = surfaceFlags;
+    pSurface->surfaceFlags      = surfaceFlags;
     pSurface->format            = format;
     memcpy(pSurface->faces, face, sizeof(pSurface->faces));
@@ -242 +242 @@
     if (surfaceFlags & SVGA3D_SURFACE_AUTOGENMIPMAPS)
         pSurface->fUsageD3D |= D3DUSAGE_AUTOGENMIPMAP;
-    pSurface->fu32ActualUsageFlags = 0;
+    pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_NONE;
+    /* pSurface->u.pSurface = NULL; */
+    /* pSurface->bounce.pTexture = NULL; */
 #else
     vmsvga3dSurfaceFormat2OGL(pSurface, format);
@@ -429 +431 @@
     {
         /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
-        LogFunc(("unknown src sid=%x type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->flags, pSrcSurface->format));
+        LogFunc(("unknown src sid=%x type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->surfaceFlags, pSrcSurface->format));
         rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pSrcSurface);
         AssertRCReturn(rc, rc);
@@ -437 +439 @@
     {
         /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
-        LogFunc(("unknown dest sid=%x type=%d format=%d -> create texture\n", sidDst, pDstSurface->flags, pDstSurface->format));
+        LogFunc(("unknown dest sid=%x type=%d format=%d -> create texture\n", sidDst, pDstSurface->surfaceFlags, pDstSurface->format));
         rc = vmsvga3dBackCreateTexture(pState, pContext, pContext->id, pDstSurface);
         AssertRCReturn(rc, rc);
@@ -483 +485 @@
 
     LogFunc(("%sguestptr gmr=%x offset=%x pitch=%x host sid=%x face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n",
-             (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE) ? "TEXTURE " : "",
+             (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE) ? "TEXTURE " : "",
              guest.ptr.gmrId, guest.ptr.offset, guest.pitch,
              host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));