Changeset 91361 in vbox for trunk/src/VBox/Devices

Timestamp:

Sep 24, 2021 12:48:04 PM (3 years ago)

Author:

vboxsync

Message:

Devices/Graphics: VMSVGA new commands

Location:

trunk/src/VBox/Devices

Files:

• Graphics/DevVGA-SVGA-cmd.cpp (modified) (32 diffs)
• Graphics/DevVGA-SVGA.cpp (modified) (3 diffs)
• Graphics/DevVGA-SVGA.h (modified) (1 diff)
• Graphics/DevVGA-SVGA3d-dx.cpp (modified) (18 diffs)
• Graphics/DevVGA-SVGA3d-internal.h (modified) (2 diffs)
• Graphics/DevVGA-SVGA3d-savedstate.cpp (modified) (1 diff)
• Graphics/DevVGA-SVGA3d-win-dx.cpp (modified) (125 diffs)
• Graphics/DevVGA-SVGA3d-win.cpp (modified) (1 diff)
• Graphics/DevVGA-SVGA3d.cpp (modified) (7 diffs)
• Graphics/DevVGA-SVGA3d.h (modified) (12 diffs)
• Makefile.kmk (modified) (1 diff)

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA-cmd.cpp

@@ -942 +942 @@
 
 
-int vmsvgaR3UpdateGBSurface(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBox)
+int vmsvgaR3UpdateGBSurface(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBox)
 {
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
@@ -955 +955 @@
         {
             VMSVGA3D_MAPPED_SURFACE map;
-            rc = pSvgaR3State->pFuncsMap->pfnSurfaceMap(pThisCC, idDXContext, pImageId, pBox, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &map);
+            rc = vmsvga3dSurfaceMap(pThisCC, pImageId, pBox, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &map);
             if (RT_SUCCESS(rc))
             {
@@ -979 +979 @@
                 }
 
-                pSvgaR3State->pFuncsMap->pfnSurfaceUnmap(pThisCC, pImageId, &map, /* fWritten= */ true);
+                vmsvga3dSurfaceUnmap(pThisCC, pImageId, &map, /* fWritten= */ true);
             }
         }
@@ -990 +990 @@
 
 
-int vmsvgaR3UpdateGBSurfaceEx(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBoxDst, SVGA3dPoint const *pPtSrc)
+int vmsvgaR3UpdateGBSurfaceEx(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBoxDst, SVGA3dPoint const *pPtSrc)
 {
     /* pPtSrc must be verified by the caller. */
@@ -1004 +1004 @@
         {
             VMSVGA3D_MAPPED_SURFACE map;
-            rc = pSvgaR3State->pFuncsMap->pfnSurfaceMap(pThisCC, idDXContext, pImageId, pBoxDst, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &map);
+            rc = vmsvga3dSurfaceMap(pThisCC, pImageId, pBoxDst, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &map);
             if (RT_SUCCESS(rc))
             {
@@ -1028 +1028 @@
                 }
 
-                pSvgaR3State->pFuncsMap->pfnSurfaceUnmap(pThisCC, pImageId, &map, /* fWritten= */ true);
+                vmsvga3dSurfaceUnmap(pThisCC, pImageId, &map, /* fWritten= */ true);
             }
         }
@@ -1281 +1281 @@
     vmsvga3dSurfaceDefine(pThisCC, pCmd->sid, pCmd->surfaceFlags, pCmd->format,
                           pCmd->multisampleCount, pCmd->autogenFilter,
-                          pCmd->face[0].numMipLevels, &paMipLevelSizes[0]);
+                          pCmd->face[0].numMipLevels, &paMipLevelSizes[0], /* fAllocMipLevels = */ true);
 }
 
@@ -1351 +1351 @@
     {
         /* Create the host surface. */
-        /** @todo fGBO = true flag. */
         vmsvga3dSurfaceDefine(pThisCC, pCmd->sid, pCmd->surfaceFlags, pCmd->format,
                               pCmd->multisampleCount, pCmd->autogenFilter,
-                              pCmd->numMipLevels, &pCmd->size);
+                              pCmd->numMipLevels, &pCmd->size, /* fAllocMipLevels = */ false);
     }
 }
@@ -1469 +1468 @@
 
 
+static int vmsvgaR3TransferSurfaceLevel(PVGASTATECC pThisCC,
+                                        PVMSVGAMOB pMob,
+                                        SVGA3dSurfaceImageId const *pImage,
+                                        SVGA3dBox const *pBox,
+                                        SVGA3dTransferType enmTransfer)
+{
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+
+    VMSVGA3D_SURFACE_MAP enmMapType;
+    if (enmTransfer == SVGA3D_WRITE_HOST_VRAM)
+        enmMapType = VMSVGA3D_SURFACE_MAP_WRITE_DISCARD;
+    else if (enmTransfer == SVGA3D_READ_HOST_VRAM)
+        enmMapType = VMSVGA3D_SURFACE_MAP_READ;
+    else
+        AssertFailedReturn(VERR_INVALID_PARAMETER);
+
+    VMSGA3D_BOX_DIMENSIONS dims;
+    int rc = vmsvga3dGetBoxDimensions(pThisCC, pImage, pBox, &dims);
+    AssertRCReturn(rc, rc);
+
+    VMSVGA3D_MAPPED_SURFACE map;
+    rc = vmsvga3dSurfaceMap(pThisCC, pImage, pBox, enmMapType, &map);
+    if (RT_SUCCESS(rc))
+    {
+        /* Copy mapped surface <-> MOB. */
+        uint8_t *pu8Map = (uint8_t *)map.pvData;
+        uint32_t offMob = dims.offSubresource + dims.offBox;
+        for (uint32_t z = 0; z < dims.cDepth; ++z)
+        {
+            for (uint32_t y = 0; y < dims.cyBlocks; ++y)
+            {
+                if (enmTransfer == SVGA3D_READ_HOST_VRAM)
+                    rc = vmsvgaR3GboWrite(pSvgaR3State, &pMob->Gbo, offMob, pu8Map, dims.cbRow);
+                else
+                    rc = vmsvgaR3GboRead(pSvgaR3State, &pMob->Gbo, offMob, pu8Map, dims.cbRow);
+                if (RT_FAILURE(rc))
+                    break;
+
+                pu8Map += map.cbRowPitch;
+                offMob += dims.cbPitch;
+            }
+        }
+
+        // vmsvga3dMapWriteBmpFile(&map, "Dynamic");
+
+        bool const fWritten = (enmTransfer == SVGA3D_WRITE_HOST_VRAM);
+        vmsvga3dSurfaceUnmap(pThisCC, pImage, &map, fWritten);
+    }
+
+    return rc;
+}
+
+
 /* SVGA_3D_CMD_UPDATE_GB_IMAGE 1101 */
-static void vmsvga3dCmdUpdateGBImage(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdUpdateGBImage const *pCmd)
-{
-//     ASMBreakpoint();
+static void vmsvga3dCmdUpdateGBImage(PVGASTATECC pThisCC, SVGA3dCmdUpdateGBImage const *pCmd)
+{
+//ASMBreakpoint();
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
 
     LogFlowFunc(("sid=%u @%u,%u,%u %ux%ux%u\n",
                  pCmd->image.sid, pCmd->box.x, pCmd->box.y, pCmd->box.z, pCmd->box.w, pCmd->box.h, pCmd->box.d));
+
+/*
+   SVGA3dSurfaceFormat format;
+   SVGA3dSurface1Flags surface1Flags;
+   uint32 numMipLevels;
+   uint32 multisampleCount;
+   SVGA3dTextureFilter autogenFilter;
+   SVGA3dSize size;
+   SVGAMobId mobid;
+   uint32 arraySize;
+   uint32 mobPitch;
+   SVGA3dSurface2Flags surface2Flags;
+   uint8 multisamplePattern;
+   uint8 qualityLevel;
+   uint16 bufferByteStride;
+   float minLOD;
+*/
 
     /* "update a surface from its backing MOB." */
@@ -1487 +1556 @@
         if (pMob)
         {
-            VMSVGA3D_MAPPED_SURFACE map;
-            /** @todo vmsvga3dSurfaceMap */
-            rc = pSvgaR3State->pFuncsMap->pfnSurfaceMap(pThisCC, idDXContext, &pCmd->image, &pCmd->box, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &map);
-            if (RT_SUCCESS(rc))
+            rc = vmsvgaR3TransferSurfaceLevel(pThisCC, pMob, &pCmd->image, &pCmd->box, SVGA3D_WRITE_HOST_VRAM);
+            AssertRC(rc);
+        }
+    }
+}
+
+
+/* SVGA_3D_CMD_UPDATE_GB_SURFACE 1102 */
+static void vmsvga3dCmdUpdateGBSurface(PVGASTATECC pThisCC, SVGA3dCmdUpdateGBSurface const *pCmd)
+{
+//ASMBreakpoint();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+
+    LogFlowFunc(("sid=%u\n",
+                 pCmd->sid));
+
+    /* "update a surface from its backing MOB." */
+    SVGAOTableSurfaceEntry entrySurface;
+    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                            pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
+    if (RT_SUCCESS(rc))
+    {
+        PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entrySurface.mobid);
+        if (pMob)
+        {
+            uint32 const arraySize = (entrySurface.surface1Flags & SVGA3D_SURFACE_CUBEMAP)
+                                   ? SVGA3D_MAX_SURFACE_FACES
+                                   : RT_MAX(entrySurface.arraySize, 1);
+            for (uint32_t iArray = 0; iArray < arraySize; ++iArray)
             {
-                /* Copy MOB -> mapped surface. */
-                uint32_t offSrc = pCmd->box.x * map.cbPixel
-                                + pCmd->box.y * entrySurface.size.width * map.cbPixel
-                                + pCmd->box.z * entrySurface.size.height * entrySurface.size.width * map.cbPixel;
-                uint8_t *pu8Dst = (uint8_t *)map.pvData;
-                for (uint32_t z = 0; z < pCmd->box.d; ++z)
+                for (uint32_t iMipmap = 0; iMipmap < entrySurface.numMipLevels; ++iMipmap)
                 {
-                    for (uint32_t y = 0; y < pCmd->box.h; ++y)
-                    {
-                        rc = vmsvgaR3GboRead(pSvgaR3State, &pMob->Gbo, offSrc, pu8Dst, pCmd->box.w * map.cbPixel);
-                        if (RT_FAILURE(rc))
-                            break;
-
-                        pu8Dst += map.cbRowPitch;
-                        offSrc += entrySurface.size.width * map.cbPixel;
-                    }
-
-                    pu8Dst += map.cbDepthPitch;
-                    offSrc += entrySurface.size.height * entrySurface.size.width * map.cbPixel;
+                    SVGA3dSurfaceImageId image;
+                    image.sid = pCmd->sid;
+                    image.face = iArray;
+                    image.mipmap = iMipmap;
+
+                    rc = vmsvgaR3TransferSurfaceLevel(pThisCC, pMob, &image, /* all pBox = */ NULL, SVGA3D_WRITE_HOST_VRAM);
+                    AssertRCBreak(rc);
                 }
-
-                // vmsvga3dMapWriteBmpFile(&map, "Dynamic");
-
-                pSvgaR3State->pFuncsMap->pfnSurfaceUnmap(pThisCC, &pCmd->image, &map, /* fWritten =  */true);
+            }
+        }
+    }
+}
+
+
+/* SVGA_3D_CMD_READBACK_GB_IMAGE 1103 */
+static void vmsvga3dCmdReadbackGBImage(PVGASTATECC pThisCC, SVGA3dCmdReadbackGBImage const *pCmd)
+{
+//ASMBreakpoint();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+
+    LogFlowFunc(("sid=%u, face=%u, mipmap=%u\n",
+                 pCmd->image.sid, pCmd->image.face, pCmd->image.mipmap));
+
+    /* Read a surface to its backing MOB. */
+    SVGAOTableSurfaceEntry entrySurface;
+    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                            pCmd->image.sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
+    if (RT_SUCCESS(rc))
+    {
+        PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entrySurface.mobid);
+        if (pMob)
+        {
+            rc = vmsvgaR3TransferSurfaceLevel(pThisCC, pMob, &pCmd->image, /* all pBox = */ NULL, SVGA3D_READ_HOST_VRAM);
+            AssertRC(rc);
+        }
+    }
+}
+
+
+/* SVGA_3D_CMD_READBACK_GB_SURFACE 1104 */
+static void vmsvga3dCmdReadbackGBSurface(PVGASTATECC pThisCC, SVGA3dCmdReadbackGBSurface const *pCmd)
+{
+//ASMBreakpoint();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+
+    LogFlowFunc(("sid=%u\n",
+                 pCmd->sid));
+
+    /* Read a surface to its backing MOB. */
+    SVGAOTableSurfaceEntry entrySurface;
+    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                            pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
+    if (RT_SUCCESS(rc))
+    {
+        PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entrySurface.mobid);
+        if (pMob)
+        {
+            uint32 const arraySize = (entrySurface.surface1Flags & SVGA3D_SURFACE_CUBEMAP)
+                                   ? SVGA3D_MAX_SURFACE_FACES
+                                   : RT_MAX(entrySurface.arraySize, 1);
+            for (uint32_t iArray = 0; iArray < arraySize; ++iArray)
+            {
+                for (uint32_t iMipmap = 0; iMipmap < entrySurface.numMipLevels; ++iMipmap)
+                {
+                    SVGA3dSurfaceImageId image;
+                    image.sid = pCmd->sid;
+                    image.face = iArray;
+                    image.mipmap = iMipmap;
+
+                    rc = vmsvgaR3TransferSurfaceLevel(pThisCC, pMob, &image, /* all pBox = */ NULL, SVGA3D_READ_HOST_VRAM);
+                    AssertRCBreak(rc);
+                }
             }
         }
@@ -1742 +1886 @@
                         /* Copy the screen target surface to the memory buffer. */
                         VMSVGA3D_MAPPED_SURFACE map;
-                        rc = pSvgaR3State->pFuncsMap->pfnSurfaceMap(pThisCC, SVGA_ID_INVALID, &entryScreenTarget.image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
+                        rc = vmsvga3dSurfaceMap(pThisCC, &entryScreenTarget.image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
                         if (RT_SUCCESS(rc))
                         {
@@ -1759 +1903 @@
                             }
 
-                            pSvgaR3State->pFuncsMap->pfnSurfaceUnmap(pThisCC, &entryScreenTarget.image, &map, /* fWritten =  */ false);
+                            vmsvga3dSurfaceUnmap(pThisCC, &entryScreenTarget.image, &map, /* fWritten =  */ false);
 
                             vmsvgaR3UpdateScreen(pThisCC, pScreen, pCmd->rect.x, pCmd->rect.y, pCmd->rect.w, pCmd->rect.h);
@@ -1791 +1935 @@
     entry.arraySize = pCmd->arraySize;
     // entry.mobPitch = 0;
+    // ...
     int rc = vmsvgaR3OTableWrite(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
                                  pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entry, sizeof(entry));
@@ -1796 +1941 @@
     {
         /* Create the host surface. */
-        /** @todo fGBO = true flag. */
+        /** @todo SVGAOTableSurfaceEntry as input parameter? */
         vmsvga3dSurfaceDefine(pThisCC, pCmd->sid, pCmd->surfaceFlags, pCmd->format,
                               pCmd->multisampleCount, pCmd->autogenFilter,
-                              pCmd->numMipLevels, &pCmd->size);
+                              pCmd->numMipLevels, &pCmd->size, /* fAllocMipLevels = */ false);
     }
 }
@@ -1807 +1952 @@
 static void vmsvga3dCmdDefineGBMob64(PVGASTATECC pThisCC, SVGA3dCmdDefineGBMob64 const *pCmd)
 {
-//     ASMBreakpoint();
+//ASMBreakpoint();
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
 
@@ -1965 +2110 @@
 
 /* SVGA_3D_CMD_DX_READBACK_CONTEXT 1146 */
-static int vmsvga3dCmdDXReadbackContext(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXReadbackContext const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXReadbackContext(pThisCC, idDXContext);
-#else
-    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
+static int vmsvga3dCmdDXReadbackContext(PVGASTATECC pThisCC, SVGA3dCmdDXReadbackContext const *pCmd, uint32_t cbCmd)
+{
+#ifdef VMSVGA3D_DX
+//ASMBreakpoint();
+    RT_NOREF(cbCmd);
+
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+
+    /* "Request that the device flush the contents back into guest memory." */
+    SVGAOTableDXContextEntry entry;
+    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_DXCONTEXT],
+                                pCmd->cid, sizeof(SVGAOTableDXContextEntry), &entry, sizeof(entry));
+    if (RT_SUCCESS(rc))
+    {
+        if (entry.mobid != SVGA_ID_INVALID)
+        {
+            PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entry.mobid);
+            if (pMob)
+            {
+                /* Get the content. */
+                SVGADXContextMobFormat *pSvgaDXContext = (SVGADXContextMobFormat *)RTMemAlloc(sizeof(SVGADXContextMobFormat));
+                if (pSvgaDXContext)
+                {
+                    rc = vmsvga3dDXReadbackContext(pThisCC, pCmd->cid, pSvgaDXContext);
+                    if (RT_SUCCESS(rc))
+                        rc = vmsvgaR3GboWrite(pSvgaR3State, &pMob->Gbo, 0, pSvgaDXContext, sizeof(SVGADXContextMobFormat));
+
+                    RTMemFree(pSvgaDXContext);
+                }
+                else
+                    rc = VERR_NO_MEMORY;
+            }
+        }
+    }
+
+    return rc;
+#else
+    RT_NOREF(pThisCC, pCmd, cbCmd);
     return VERR_NOT_SUPPORTED;
 #endif
@@ -2084 +2258 @@
 {
 #ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXDrawInstanced(pThisCC, idDXContext);
+//ASMBreakpoint();
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXDrawInstanced(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -2099 +2272 @@
 {
 #ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXDrawIndexedInstanced(pThisCC, idDXContext);
+//ASMBreakpoint();
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXDrawIndexedInstanced(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -2491 +2663 @@
 
 /* SVGA_3D_CMD_DX_UPDATE_SUBRESOURCE 1182 */
-static int vmsvga3dCmdDXUpdateSubResource(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXUpdateSubResource const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXUpdateSubResource(pThisCC, idDXContext);
-#else
-    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
+static int vmsvga3dCmdDXUpdateSubResource(PVGASTATECC pThisCC, SVGA3dCmdDXUpdateSubResource const *pCmd, uint32_t cbCmd)
+{
+#ifdef VMSVGA3D_DX
+//ASMBreakpoint();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    RT_NOREF(cbCmd);
+
+    LogFlowFunc(("sid=%u, subResource=%u, box=%d,%d,%d %ux%ux%u\n",
+                 pCmd->sid, pCmd->subResource, pCmd->box.x, pCmd->box.y, pCmd->box.z, pCmd->box.w, pCmd->box.h, pCmd->box.z));
+
+    /* "Inform the device that the guest-contents have been updated." */
+    SVGAOTableSurfaceEntry entrySurface;
+    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                                pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
+    if (RT_SUCCESS(rc))
+    {
+        PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entrySurface.mobid);
+        if (pMob)
+        {
+            uint32 const arraySize = (entrySurface.surface1Flags & SVGA3D_SURFACE_CUBEMAP)
+                                   ? SVGA3D_MAX_SURFACE_FACES
+                                   : RT_MAX(entrySurface.arraySize, 1);
+            ASSERT_GUEST_RETURN(pCmd->subResource < arraySize * entrySurface.numMipLevels, VERR_INVALID_PARAMETER);
+            /* pCmd->box will be verified by the mapping function. */
+            RT_UNTRUSTED_VALIDATED_FENCE();
+
+            /** @todo Mapping functions should use subresource index rather than SVGA3dSurfaceImageId? */
+            SVGA3dSurfaceImageId image;
+            image.sid = pCmd->sid;
+            vmsvga3dCalcMipmapAndFace(entrySurface.numMipLevels, pCmd->subResource, &image.mipmap, &image.face);
+
+            rc = vmsvgaR3TransferSurfaceLevel(pThisCC, pMob, &image, &pCmd->box, SVGA3D_WRITE_HOST_VRAM);
+            AssertRC(rc);
+        }
+    }
+
+    return rc;
+#else
+    RT_NOREF(pThisCC, pCmd, cbCmd);
     return VERR_NOT_SUPPORTED;
 #endif
@@ -2506 +2708 @@
 
 /* SVGA_3D_CMD_DX_READBACK_SUBRESOURCE 1183 */
-static int vmsvga3dCmdDXReadbackSubResource(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXReadbackSubResource const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXReadbackSubResource(pThisCC, idDXContext);
-#else
-    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
+static int vmsvga3dCmdDXReadbackSubResource(PVGASTATECC pThisCC, SVGA3dCmdDXReadbackSubResource const *pCmd, uint32_t cbCmd)
+{
+#ifdef VMSVGA3D_DX
+//ASMBreakpoint();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    RT_NOREF(cbCmd);
+
+    LogFlowFunc(("sid=%u, subResource=%u\n",
+                 pCmd->sid, pCmd->subResource));
+
+    /* "Request the device to flush the dirty contents into the guest." */
+    SVGAOTableSurfaceEntry entrySurface;
+    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                                pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
+    if (RT_SUCCESS(rc))
+    {
+        PVMSVGAMOB pMob = vmsvgaR3MobGet(pSvgaR3State, entrySurface.mobid);
+        if (pMob)
+        {
+            uint32 const arraySize = (entrySurface.surface1Flags & SVGA3D_SURFACE_CUBEMAP)
+                                   ? SVGA3D_MAX_SURFACE_FACES
+                                   : RT_MAX(entrySurface.arraySize, 1);
+            ASSERT_GUEST_RETURN(pCmd->subResource < arraySize * entrySurface.numMipLevels, VERR_INVALID_PARAMETER);
+            RT_UNTRUSTED_VALIDATED_FENCE();
+
+            /** @todo Mapping functions should use subresource index rather than SVGA3dSurfaceImageId? */
+            SVGA3dSurfaceImageId image;
+            image.sid = pCmd->sid;
+            vmsvga3dCalcMipmapAndFace(entrySurface.numMipLevels, pCmd->subResource, &image.mipmap, &image.face);
+
+            rc = vmsvgaR3TransferSurfaceLevel(pThisCC, pMob, &image, /* all pBox = */ NULL, SVGA3D_READ_HOST_VRAM);
+            AssertRC(rc);
+        }
+    }
+
+    return rc;
+#else
+    RT_NOREF(pThisCC, pCmd, cbCmd);
     return VERR_NOT_SUPPORTED;
 #endif
@@ -2521 +2752 @@
 
 /* SVGA_3D_CMD_DX_INVALIDATE_SUBRESOURCE 1184 */
-static int vmsvga3dCmdDXInvalidateSubResource(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXInvalidateSubResource const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXInvalidateSubResource(pThisCC, idDXContext);
-#else
-    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
+static int vmsvga3dCmdDXInvalidateSubResource(PVGASTATECC pThisCC, SVGA3dCmdDXInvalidateSubResource const *pCmd, uint32_t cbCmd)
+{
+#ifdef VMSVGA3D_DX
+ASMBreakpoint();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+    RT_NOREF(cbCmd);
+
+    LogFlowFunc(("sid=%u, subResource=%u\n",
+                 pCmd->sid, pCmd->subResource));
+
+    /* "Notify the device that the contents can be lost." */
+    SVGAOTableSurfaceEntry entrySurface;
+    int rc = vmsvgaR3OTableRead(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                                pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entrySurface, sizeof(entrySurface));
+    if (RT_SUCCESS(rc))
+    {
+        uint32_t iFace;
+        uint32_t iMipmap;
+        vmsvga3dCalcMipmapAndFace(entrySurface.numMipLevels, pCmd->subResource, &iMipmap, &iFace);
+        vmsvga3dSurfaceInvalidate(pThisCC, pCmd->sid, iFace, iMipmap);
+    }
+
+    return rc;
+#else
+    RT_NOREF(pThisCC, pCmd, cbCmd);
     return VERR_NOT_SUPPORTED;
 #endif
@@ -2912 +3159 @@
 
 /* SVGA_3D_CMD_DX_TRANSFER_FROM_BUFFER 1210 */
-static int vmsvga3dCmdDXTransferFromBuffer(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXTransferFromBuffer const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXTransferFromBuffer(pThisCC, idDXContext);
-#else
-    RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
+static int vmsvga3dCmdDXTransferFromBuffer(PVGASTATECC pThisCC, SVGA3dCmdDXTransferFromBuffer const *pCmd, uint32_t cbCmd)
+{
+#ifdef VMSVGA3D_DX
+//ASMBreakpoint();
+    RT_NOREF(cbCmd);
+
+    /* Plan:
+     * - map the buffer;
+     * - map the surface;
+     * - copy from buffer map to the surface map.
+     */
+
+    int rc;
+
+    SVGA3dSurfaceImageId imageBuffer;
+    imageBuffer.sid = pCmd->srcSid;
+    imageBuffer.face = 0;
+    imageBuffer.mipmap = 0;
+
+    SVGA3dSurfaceImageId imageSurface;
+    imageSurface.sid = pCmd->destSid;
+    rc = vmsvga3dCalcSurfaceMipmapAndFace(pThisCC, pCmd->destSid, pCmd->destSubResource, &imageSurface.mipmap, &imageSurface.face);
+    AssertRCReturn(rc, rc);
+
+    /*
+     * Map the buffer.
+     */
+    VMSVGA3D_MAPPED_SURFACE mapBuffer;
+    rc = vmsvga3dSurfaceMap(pThisCC, &imageBuffer, NULL, VMSVGA3D_SURFACE_MAP_READ, &mapBuffer);
+    if (RT_SUCCESS(rc))
+    {
+        /*
+         * Map the surface.
+         */
+        VMSVGA3D_MAPPED_SURFACE mapSurface;
+        rc = vmsvga3dSurfaceMap(pThisCC, &imageSurface, &pCmd->destBox, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &mapSurface);
+        if (RT_SUCCESS(rc))
+        {
+            /*
+             * Copy the mapped buffer to the surface.
+             */
+            uint8_t const *pu8Buffer = (uint8_t *)mapBuffer.pvData;
+            uint32_t const cbBuffer = mapBuffer.box.w * mapBuffer.cbPixel;
+
+            if (pCmd->srcOffset <= cbBuffer)
+            {
+                RT_UNTRUSTED_VALIDATED_FENCE();
+                uint8_t const *pu8BufferBegin = pu8Buffer;
+                uint8_t const *pu8BufferEnd = pu8Buffer + (cbBuffer - pCmd->srcOffset);
+
+                pu8Buffer += pCmd->srcOffset;
+
+                uint8_t *pu8Surface = (uint8_t *)mapSurface.pvData;
+
+                uint32_t const cbWidth = mapSurface.box.w * mapSurface.cbPixel;
+                for (uint32_t z = 0; z < mapSurface.box.d && RT_SUCCESS(rc); ++z)
+                {
+                    uint8_t const *pu8BufferRow = pu8Buffer;
+                    uint8_t *pu8SurfaceRow = pu8Surface;
+                    for (uint32_t y = 0; y < mapSurface.box.h; ++y)
+                    {
+                        ASSERT_GUEST_STMT_BREAK(   (uintptr_t)pu8BufferRow >= (uintptr_t)pu8BufferBegin
+                                                && (uintptr_t)pu8BufferRow < (uintptr_t)pu8BufferEnd
+                                                && (uintptr_t)(pu8BufferRow + cbWidth) > (uintptr_t)pu8BufferBegin
+                                                && (uintptr_t)(pu8BufferRow + cbWidth) <= (uintptr_t)pu8BufferEnd,
+                                                rc = VERR_INVALID_PARAMETER);
+
+                        memcpy(pu8SurfaceRow, pu8BufferRow, cbWidth);
+
+                        pu8SurfaceRow += mapSurface.cbRowPitch;
+                        pu8BufferRow += pCmd->srcPitch;
+                    }
+
+                    pu8Buffer += pCmd->srcSlicePitch;
+                    pu8Surface += mapSurface.cbDepthPitch;
+                }
+            }
+            else
+                ASSERT_GUEST_FAILED_STMT(rc = VERR_INVALID_PARAMETER);
+
+            vmsvga3dSurfaceUnmap(pThisCC, &imageSurface, &mapSurface, true);
+        }
+
+        vmsvga3dSurfaceUnmap(pThisCC, &imageBuffer, &mapBuffer, false);
+    }
+
+    return rc;
+#else
+    RT_NOREF(pThisCC, pCmd, cbCmd);
     return VERR_NOT_SUPPORTED;
 #endif
@@ -2990 +3317 @@
 {
 #ifdef VMSVGA3D_DX
-ASMBreakpoint();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXPredTransferFromBuffer(pThisCC, idDXContext);
+//ASMBreakpoint();
+    RT_NOREF(idDXContext, cbCmd);
+
+    /* This command is executed in a context: "The context is implied from the command buffer header."
+     * However the device design allows to do the transfer without a context, so re-use context-less command handler.
+     */
+    SVGA3dCmdDXTransferFromBuffer cmd;
+    cmd.srcSid          = pCmd->srcSid;
+    cmd.srcOffset       = pCmd->srcOffset;
+    cmd.srcPitch        = pCmd->srcPitch;
+    cmd.srcSlicePitch   = pCmd->srcSlicePitch;
+    cmd.destSid         = pCmd->destSid;
+    cmd.destSubResource = pCmd->destSubResource;
+    cmd.destBox         = pCmd->destBox;
+    return vmsvga3dCmdDXTransferFromBuffer(pThisCC, &cmd, sizeof(cmd));
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -4313 +4651 @@
         SVGA3dCmdUpdateGBImage *pCmd = (SVGA3dCmdUpdateGBImage *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        vmsvga3dCmdUpdateGBImage(pThisCC, idDXContext, pCmd);
+        vmsvga3dCmdUpdateGBImage(pThisCC, pCmd);
         break;
     }
@@ -4321 +4659 @@
         SVGA3dCmdUpdateGBSurface *pCmd = (SVGA3dCmdUpdateGBSurface *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        VMSVGA_3D_CMD_NOTIMPL(); RT_NOREF(pCmd);
+        vmsvga3dCmdUpdateGBSurface(pThisCC, pCmd);
         break;
     }
@@ -4329 +4667 @@
         SVGA3dCmdReadbackGBImage *pCmd = (SVGA3dCmdReadbackGBImage *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        VMSVGA_3D_CMD_NOTIMPL(); RT_NOREF(pCmd);
+        vmsvga3dCmdReadbackGBImage(pThisCC, pCmd);
         break;
     }
@@ -4337 +4675 @@
         SVGA3dCmdReadbackGBSurface *pCmd = (SVGA3dCmdReadbackGBSurface *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        VMSVGA_3D_CMD_NOTIMPL(); RT_NOREF(pCmd);
+        vmsvga3dCmdReadbackGBSurface(pThisCC, pCmd);
         break;
     }
@@ -4666 +5004 @@
         SVGA3dCmdDXReadbackContext *pCmd = (SVGA3dCmdDXReadbackContext *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDXReadbackContext(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDXReadbackContext(pThisCC, pCmd, cbCmd);
         break;
     }
@@ -4954 +5292 @@
         SVGA3dCmdDXUpdateSubResource *pCmd = (SVGA3dCmdDXUpdateSubResource *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDXUpdateSubResource(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDXUpdateSubResource(pThisCC, pCmd, cbCmd);
         break;
     }
@@ -4962 +5300 @@
         SVGA3dCmdDXReadbackSubResource *pCmd = (SVGA3dCmdDXReadbackSubResource *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDXReadbackSubResource(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDXReadbackSubResource(pThisCC, pCmd, cbCmd);
         break;
     }
@@ -4970 +5308 @@
         SVGA3dCmdDXInvalidateSubResource *pCmd = (SVGA3dCmdDXInvalidateSubResource *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDXInvalidateSubResource(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDXInvalidateSubResource(pThisCC, pCmd, cbCmd);
         break;
     }
@@ -5178 +5516 @@
         SVGA3dCmdDXTransferFromBuffer *pCmd = (SVGA3dCmdDXTransferFromBuffer *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDXTransferFromBuffer(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDXTransferFromBuffer(pThisCC, pCmd, cbCmd);
         break;
     }

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

@@ -3324 +3324 @@
         if (RT_SUCCESS(rc))
         {
+            LogFunc(("status %RX32 errorOffset %RX32 id %RX64 flags %RX32 length %RX32 ptr %RX64 offset %RX32 dxContext %RX32 (%RX32 %RX32 %RX32 %RX32 %RX32 %RX32)\n",
+                     pCmdBuf->hdr.status,
+                     pCmdBuf->hdr.errorOffset,
+                     pCmdBuf->hdr.id,
+                     pCmdBuf->hdr.flags,
+                     pCmdBuf->hdr.length,
+                     pCmdBuf->hdr.ptr.pa,
+                     pCmdBuf->hdr.offset,
+                     pCmdBuf->hdr.dxContext,
+                     pCmdBuf->hdr.mustBeZero[0],
+                     pCmdBuf->hdr.mustBeZero[1],
+                     pCmdBuf->hdr.mustBeZero[2],
+                     pCmdBuf->hdr.mustBeZero[3],
+                     pCmdBuf->hdr.mustBeZero[4],
+                     pCmdBuf->hdr.mustBeZero[5]));
+
             /* Verify the command buffer header. */
             if (RT_LIKELY(   pCmdBuf->hdr.status == SVGA_CB_STATUS_NONE
@@ -5827 +5843 @@
 
 extern VMSVGA3DBACKENDDESC const g_BackendLegacy;
-#ifdef VMSVGA3D_DX
+#if defined(VMSVGA3D_DX_BACKEND)
 extern VMSVGA3DBACKENDDESC const g_BackendDX;
 #endif
@@ -5857 +5873 @@
 
     VMSVGA3DBACKENDDESC const *pBackend = NULL;
-#ifdef VMSVGA3D_DX
+#if defined(VMSVGA3D_DX_BACKEND)
     if (pThis->fVMSVGA10)
         pBackend = &g_BackendDX;

trunk/src/VBox/Devices/Graphics/DevVGA-SVGA.h

@@ -648 +648 @@
 
 #ifdef VBOX_WITH_VMSVGA3D
-int vmsvgaR3UpdateGBSurface(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBox);
-int vmsvgaR3UpdateGBSurfaceEx(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBoxDst, SVGA3dPoint const *pPtSrc);
+int vmsvgaR3UpdateGBSurface(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBox);
+int vmsvgaR3UpdateGBSurfaceEx(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImageId, SVGA3dBox const *pBoxDst, SVGA3dPoint const *pPtSrc);
 #endif
 

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

@@ -153 +153 @@
 
 
-int vmsvga3dDXReadbackContext(PVGASTATECC pThisCC, uint32_t idDXContext)
+int vmsvga3dDXReadbackContext(PVGASTATECC pThisCC, uint32_t idDXContext, SVGADXContextMobFormat *pSvgaDXContext)
 {
     int rc;
@@ -166 +166 @@
 
     rc = pSvgaR3State->pFuncsDX->pfnDXReadbackContext(pThisCC, pDXContext);
+    if (RT_SUCCESS(rc))
+        memcpy(pSvgaDXContext, &pDXContext->svgaDXContext, sizeof(*pSvgaDXContext));
     return rc;
 }
@@ -292 +294 @@
     ASSERT_GUEST_RETURN(pDXContext->cot.paSampler, VERR_INVALID_STATE);
     for (uint32_t i = 0; i < cSamplerId; ++i)
-        ASSERT_GUEST_RETURN(paSamplerId[i] < pDXContext->cot.cSampler, VERR_INVALID_PARAMETER);
+    {
+        SVGA3dSamplerId const samplerId = paSamplerId[i];
+        ASSERT_GUEST_RETURN(   samplerId < pDXContext->cot.cSampler
+                            || samplerId == SVGA_ID_INVALID, VERR_INVALID_PARAMETER);
+    }
     RT_UNTRUSTED_VALIDATED_FENCE();
 
@@ -320 +326 @@
     image.mipmap = 0;
     VMSVGA3D_MAPPED_SURFACE map;
-    int rc2 = pSvgaR3State->pFuncsMap->pfnSurfaceMap(pThisCC, idDXContext, &image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
+    int rc2 = vmsvga3dSurfaceMap(pThisCC, &image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
     if (RT_SUCCESS(rc2))
     {
         vmsvga3dMapWriteBmpFile(&map, "rt-");
-        pSvgaR3State->pFuncsMap->pfnSurfaceUnmap(pThisCC, &image, &map, /* fWritten =  */ false);
+        vmsvga3dSurfaceUnmap(pThisCC, &image, &map, /* fWritten =  */ false);
     }
 #endif
@@ -348 +354 @@
 
 
-int vmsvga3dDXDrawInstanced(PVGASTATECC pThisCC, uint32_t idDXContext)
+int vmsvga3dDXDrawInstanced(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDrawInstanced const *pCmd)
 {
     int rc;
@@ -360 +366 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXDrawInstanced(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXDrawIndexedInstanced(PVGASTATECC pThisCC, uint32_t idDXContext)
+    rc = pSvgaR3State->pFuncsDX->pfnDXDrawInstanced(pThisCC, pDXContext,
+             pCmd->vertexCountPerInstance, pCmd->instanceCount, pCmd->startVertexLocation, pCmd->startInstanceLocation);
+    return rc;
+}
+
+
+int vmsvga3dDXDrawIndexedInstanced(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDrawIndexedInstanced const *pCmd)
 {
     int rc;
@@ -377 +384 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXDrawIndexedInstanced(pThisCC, pDXContext);
+    rc = pSvgaR3State->pFuncsDX->pfnDXDrawIndexedInstanced(pThisCC, pDXContext,
+             pCmd->indexCountPerInstance, pCmd->instanceCount, pCmd->startIndexLocation, pCmd->baseVertexLocation, pCmd->startInstanceLocation);
     return rc;
 }
@@ -827 +835 @@
     AssertRCReturn(rc, rc);
 
+    /** @todo Memcpy if both resources do not have the hardware resource. */
+
     rc = pSvgaR3State->pFuncsDX->pfnDXPredCopyRegion(pThisCC, pDXContext, pCmd->dstSid, pCmd->dstSubResource, pCmd->srcSid, pCmd->srcSubResource, &pCmd->box);
     return rc;
@@ -885 +895 @@
 
     rc = pSvgaR3State->pFuncsDX->pfnDXGenMips(pThisCC, pDXContext, shaderResourceViewId);
-    return rc;
-}
-
-
-int vmsvga3dDXUpdateSubResource(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXUpdateSubResource, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    rc = pSvgaR3State->pFuncsDX->pfnDXUpdateSubResource(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXReadbackSubResource(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXReadbackSubResource, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    rc = pSvgaR3State->pFuncsDX->pfnDXReadbackSubResource(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXInvalidateSubResource(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXInvalidateSubResource, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    rc = pSvgaR3State->pFuncsDX->pfnDXInvalidateSubResource(pThisCC, pDXContext);
     return rc;
 }
@@ -1400 +1359 @@
     AssertRCReturn(rc, rc);
 
+    AssertReturn(pDXContext->paShader, VERR_INVALID_STATE);
+
     SVGA3dShaderId const shaderId = pCmd->shaderId;
 
@@ -1414 +1375 @@
     pEntry->mobid         = SVGA_ID_INVALID;
 
-    if (!pDXContext->paShader)
-    {
-        /* Create host array for information abput shaders. */
-        pDXContext->paShader = (PVMSVGA3DSHADER)RTMemAllocZ(pDXContext->cot.cShader * sizeof(VMSVGA3DSHADER));
-        AssertReturn(pDXContext->paShader, VERR_NO_MEMORY);
-        for (uint32_t i = 0; i < pDXContext->cot.cShader; ++i)
-            pDXContext->paShader[i].id = SVGA_ID_INVALID;
-    }
+    /** @todo Remove from here. */
+//    if (!pDXContext->paShader)
+//    {
+//        /* Create host array for information about shaders. */
+//        pDXContext->paShader = (PVMSVGA3DSHADER)RTMemAllocZ(pDXContext->cot.cShader * sizeof(VMSVGA3DSHADER));
+//        AssertReturn(pDXContext->paShader, VERR_NO_MEMORY);
+//        for (uint32_t i = 0; i < pDXContext->cot.cShader; ++i)
+//            pDXContext->paShader[i].id = SVGA_ID_INVALID;
+//    }
 
     PVMSVGA3DSHADER pShader = &pDXContext->paShader[shaderId];
@@ -1438 +1400 @@
     pShader->u.pvBackendShader = NULL;
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXDefineShader(pThisCC, pDXContext, pShader);
+    rc = pSvgaR3State->pFuncsDX->pfnDXDefineShader(pThisCC, pDXContext, shaderId, pEntry);
     return rc;
 }
@@ -1668 +1630 @@
 
     uint32_t cEntries = 0;
+    uint32_t cValidEntries = 0;
     if (RT_SUCCESS(rc))
     {
@@ -1687 +1650 @@
 
         cEntries = cbCOT / s_acbEntry[pCmd->type];
-        uint32_t const cValidEntries = validSizeInBytes / s_acbEntry[pCmd->type];
-
-        rc = pSvgaR3State->pFuncsDX->pfnDXSetCOTable(pThisCC, pDXContext, pCmd->type, cEntries, cValidEntries);
+        cValidEntries = validSizeInBytes / s_acbEntry[pCmd->type];
     }
 
@@ -1742 +1703 @@
                 pDXContext->cot.paShader          = (SVGACOTableDXShaderEntry *)pvCOT;
                 pDXContext->cot.cShader           = cEntries;
+
+                /* Create host array for information about shaders. */
+                RTMemFree(pDXContext->paShader);
+                pDXContext->paShader = NULL;
+
+                if (pDXContext->cot.cShader)
+                {
+                    pDXContext->paShader = (PVMSVGA3DSHADER)RTMemAllocZ(pDXContext->cot.cShader * sizeof(VMSVGA3DSHADER));
+                    AssertReturn(pDXContext->paShader, VERR_NO_MEMORY);
+                    for (uint32_t i = 0; i < pDXContext->cot.cShader; ++i)
+                        pDXContext->paShader[i].id = SVGA_ID_INVALID;
+                }
                 break;
             case SVGA_COTABLE_UAVIEW:
@@ -1753 +1726 @@
         vmsvgaR3MobBackingStoreDelete(pSvgaR3State, pMob);
 
+    /* Notify the backend. */
+    if (RT_SUCCESS(rc))
+        rc = pSvgaR3State->pFuncsDX->pfnDXSetCOTable(pThisCC, pDXContext, pCmd->type, cValidEntries);
+
     return rc;
 }
@@ -1796 +1773 @@
 
 
-int vmsvga3dDXTransferFromBuffer(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXTransferFromBuffer, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    rc = pSvgaR3State->pFuncsDX->pfnDXTransferFromBuffer(pThisCC, pDXContext);
-    return rc;
-}
-
-
 int vmsvga3dDXSurfaceCopyAndReadback(PVGASTATECC pThisCC, uint32_t idDXContext)
 {
@@ -1881 +1841 @@
 
 
-int vmsvga3dDXPredTransferFromBuffer(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDXPredTransferFromBuffer, VERR_INVALID_STATE);
-    PVMSVGA3DSTATE p3dState = pThisCC->svga.p3dState;
-    AssertReturn(p3dState, VERR_INVALID_STATE);
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-    rc = vmsvga3dDXContextFromCid(p3dState, idDXContext, &pDXContext);
-    AssertRCReturn(rc, rc);
-
-    rc = pSvgaR3State->pFuncsDX->pfnDXPredTransferFromBuffer(pThisCC, pDXContext);
-    return rc;
-}
-
-
 int vmsvga3dDXMobFence64(PVGASTATECC pThisCC, uint32_t idDXContext)
 {

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

@@ -547 +547 @@
     uint32_t                id; /** @todo sid */
     /* Which context created the corresponding resource.
-     * SVGA_ID_INVALID means that resource has not been created yet, or has been created by the shared context.
+     * SVGA_ID_INVALID means that resource has not been created yet.
      * A resource has been created if VMSVGA3DSURFACE_HAS_HW_SURFACE is true.
      *
@@ -1315 +1315 @@
 {
     *ppDXContext = NULL;
-    if (cid == SVGA_ID_INVALID)
-        return VERR_INVALID_STATE;
     AssertReturn(cid < pState->cDXContexts, VERR_INVALID_PARAMETER);
     PVMSVGA3DDXCONTEXT const pDXContext = pState->papDXContexts[cid];

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

@@ -497 +497 @@
 
                 rc = vmsvga3dSurfaceDefine(pThisCC, sid, surface.surfaceFlags, surface.format, surface.multiSampleCount,
-                                           surface.autogenFilter, surface.cLevels, &pMipmapLevelSize[0]);
+                                           surface.autogenFilter, surface.cLevels, &pMipmapLevelSize[0], /* fAllocMipLevels = */ true);
                 AssertRCReturn(rc, rc);
 

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

@@ -44 +44 @@
 #include <d3d11.h>
 
+
+/** Fake ID for the backend DX context. The context creates all shared textures. */
+#define DX_CID_BACKEND UINT32_C(0xfffffffe)
+
 #define DX_RELEASE_ARRAY(a_Count, a_papArray) do { \
     for (uint32_t i = 0; i < (a_Count); ++i) \
@@ -73 +77 @@
     VMSVGA3DBACKRESTYPE enmResType;
     DXGI_FORMAT enmDxgiFormat;
+    union
+    {
+        ID3D11Resource     *pResource;
+        ID3D11Texture2D    *pTexture2D;
+        ID3D11Texture3D    *pTexture3D;
+        ID3D11Buffer       *pBuffer;
+    } u;
+
+    ID3D11Texture2D    *pDynamicTexture;  /* For screen updates from memory. */ /** @todo One for all screens. */
+    ID3D11Texture2D    *pStagingTexture;  /* For Reading the screen content. */ /** @todo One for all screens. */
+    ID3D11Texture3D    *pDynamicTexture3D;  /* For screen updates from memory. */ /** @todo One for all screens. */
+    ID3D11Texture3D    *pStagingTexture3D;  /* For Reading the screen content. */ /** @todo One for all screens. */
+
+    /* Screen targets are created as shared surfaces. */
+    HANDLE              SharedHandle;     /* The shared handle of this structure. */
+
+    /* DX context which last rendered to the texture.
+     * This is only for render targets and screen targets, which can be shared between contexts.
+     * The backend context (cid == DX_CID_BACKEND) can also be a drawing context.
+     */
+    uint32_t cidDrawing;
+
     /** AVL tree containing DXSHAREDTEXTURE structures. */
     AVLU32TREE SharedTextureTree;
-    union
-    {
-        struct
-        {
-            ID3D11Resource     *pResource;
-        } Resource;
-        struct
-        {
-            ID3D11Texture2D    *pTexture;         /* The texture for the screen content. */
-            ID3D11Texture2D    *pDynamicTexture;  /* For screen updates from memory. */ /** @todo One for all screens. */
-            ID3D11Texture2D    *pStagingTexture;  /* For Reading the screen content. */ /** @todo One for all screens. */
-            /* Screen targets are created as shared surfaces. */
-            HANDLE              SharedHandle;     /* The shared handle of this structure. */
-        } ScreenTarget;
-        struct
-        {
-            ID3D11Texture2D    *pTexture;         /* The texture for the screen content. */
-            ID3D11Texture2D    *pDynamicTexture;  /* For screen updates from memory. */ /** @todo One for every format. */
-            ID3D11Texture2D    *pStagingTexture;  /* For Reading the screen content. */ /** @todo One for every format. */
-        } Texture;
-        struct
-        {
-             ID3D11Buffer      *pBuffer;
-        } Buffer;
-    } u;
+
 } VMSVGA3DBACKENDSURFACE;
 
@@ -147 +149 @@
 typedef struct VMSVGA3DBACKENDDXCONTEXT
 {
-    DXDEVICE                   device;                 /* Device for the this context operation. */
+    DXDEVICE                   device;                 /* DX device interfaces for this context operations. */
 
     /* Arrays for Context-Object Tables. Number of entries depends on COTable size. */
@@ -206 +208 @@
 }
 
-
+#define DX_REPLACE_X8_WITH_A8
 static DXGI_FORMAT vmsvgaDXSurfaceFormat2Dxgi(SVGA3dSurfaceFormat format)
 {
@@ -218 +220 @@
     switch (format)
     {
+#ifdef DX_REPLACE_X8_WITH_A8
+        case SVGA3D_X8R8G8B8:                   return DXGI_FORMAT_B8G8R8A8_UNORM;
+#else
         case SVGA3D_X8R8G8B8:                   return DXGI_FORMAT_B8G8R8X8_UNORM;
+#endif
         case SVGA3D_A8R8G8B8:                   return DXGI_FORMAT_B8G8R8A8_UNORM;
         case SVGA3D_R5G6B5:                     return DXGI_FORMAT_B5G6R5_UNORM;
@@ -333 +339 @@
         case SVGA3D_B8G8R8A8_TYPELESS:          return DXGI_FORMAT_B8G8R8A8_TYPELESS;
         case SVGA3D_B8G8R8A8_UNORM_SRGB:        return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+#ifdef DX_REPLACE_X8_WITH_A8
+        case SVGA3D_B8G8R8X8_TYPELESS:          return DXGI_FORMAT_B8G8R8A8_TYPELESS;
+        case SVGA3D_B8G8R8X8_UNORM_SRGB:        return DXGI_FORMAT_B8G8R8A8_UNORM_SRGB;
+#else
         case SVGA3D_B8G8R8X8_TYPELESS:          return DXGI_FORMAT_B8G8R8X8_TYPELESS;
         case SVGA3D_B8G8R8X8_UNORM_SRGB:        return DXGI_FORMAT_B8G8R8X8_UNORM_SRGB;
+#endif
         case SVGA3D_Z_DF16:                     break;
         case SVGA3D_Z_DF24:                     break;
@@ -359 +370 @@
         case SVGA3D_B5G5R5A1_UNORM:             return DXGI_FORMAT_B5G5R5A1_UNORM;
         case SVGA3D_B8G8R8A8_UNORM:             return DXGI_FORMAT_B8G8R8A8_UNORM;
+#ifdef DX_REPLACE_X8_WITH_A8
+        case SVGA3D_B8G8R8X8_UNORM:             return DXGI_FORMAT_B8G8R8A8_UNORM;
+#else
         case SVGA3D_B8G8R8X8_UNORM:             return DXGI_FORMAT_B8G8R8X8_UNORM;
+#endif
         case SVGA3D_BC4_UNORM:                  return DXGI_FORMAT_BC4_UNORM;
         case SVGA3D_BC5_UNORM:                  return DXGI_FORMAT_BC5_UNORM;
@@ -698 +713 @@
         LogRel(("VMSVGA: Feature level %#x\n", pDevice->FeatureLevel));
 
+#ifdef DEBUG
+        /* Break into debugger when DX runtime detects anything unusual. */
+        HRESULT hr2;
+        ID3D11Debug *pDebug = 0;
+        hr2 = pDevice->pDevice->QueryInterface(__uuidof(ID3D11Debug), (void**)&pDebug);
+        if (SUCCEEDED(hr2))
+        {
+            ID3D11InfoQueue *pInfoQueue = 0;
+            hr2 = pDebug->QueryInterface(__uuidof(ID3D11InfoQueue), (void**)&pInfoQueue);
+            if (SUCCEEDED(hr2))
+            {
+                pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
+                pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
+                pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, true);
+
+                D3D11_MESSAGE_ID saIgnoredMessageIds[] =
+                {
+                    /* Message ID:                                    Caused by: */
+                    D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_TYPE_MISMATCH, /* Autogenerated input signatures. */
+                };
+
+                D3D11_INFO_QUEUE_FILTER filter;
+                RT_ZERO(filter);
+                filter.DenyList.NumIDs = RT_ELEMENTS(saIgnoredMessageIds);
+                filter.DenyList.pIDList = saIgnoredMessageIds;
+                pInfoQueue->AddStorageFilterEntries(&filter);
+
+                D3D_RELEASE(pInfoQueue);
+            }
+            D3D_RELEASE(pDebug);
+        }
+#endif
+
         IDXGIDevice *pDxgiDevice = 0;
         hr = pDevice->pDevice->QueryInterface(__uuidof(IDXGIDevice), (void**)&pDxgiDevice);
@@ -731 +779 @@
 
 
-static ID3D11Resource *dxResource(PVMSVGA3DSURFACE pSurface, VMSVGA3DDXCONTEXT *pDXContext)
+DECLINLINE(bool) dxIsSurfaceShareable(PVMSVGA3DSURFACE pSurface)
+{
+    /* It is not expected that volume textures will be shared between contexts. */
+    if (pSurface->surfaceFlags & SVGA3D_SURFACE_VOLUME)
+        return false;
+
+    return pSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET
+        || pSurface->surfaceFlags & SVGA3D_SURFACE_BIND_RENDER_TARGET;
+}
+
+
+DXDEVICE *dxDeviceFromCid(uint32_t cid, PVMSVGA3DSTATE pState)
+{
+    if (cid != DX_CID_BACKEND)
+    {
+        VMSVGA3DDXCONTEXT *pDXContext;
+        int rc = vmsvga3dDXContextFromCid(pState, cid, &pDXContext);
+        if (RT_SUCCESS(rc))
+            return &pDXContext->pBackendDXContext->device;
+    }
+    else
+        return &pState->pBackend->device;
+
+    AssertFailed();
+    return NULL;
+}
+
+
+static int dxDeviceFlush(DXDEVICE *pDevice)
+{
+    /** @todo Should the flush follow the query submission? */
+    pDevice->pImmediateContext->Flush();
+
+    ID3D11Query *pQuery = 0;
+    D3D11_QUERY_DESC qd;
+    RT_ZERO(qd);
+    qd.Query = D3D11_QUERY_EVENT;
+
+    HRESULT hr = pDevice->pDevice->CreateQuery(&qd, &pQuery);
+    Assert(hr == S_OK); RT_NOREF(hr);
+    pDevice->pImmediateContext->End(pQuery);
+
+    BOOL queryData;
+    while (pDevice->pImmediateContext->GetData(pQuery, &queryData, sizeof(queryData), 0) != S_OK)
+        RTThreadYield();
+
+    D3D_RELEASE(pQuery);
+
+    return VINF_SUCCESS;
+}
+
+
+static int dxContextWait(uint32_t cidDrawing, PVMSVGA3DSTATE pState)
+{
+    /* Flush cidDrawing context and issue a query. */
+    DXDEVICE *pDXDevice = dxDeviceFromCid(cidDrawing, pState);
+    return dxDeviceFlush(pDXDevice);
+}
+
+
+static ID3D11Resource *dxResource(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface, VMSVGA3DDXCONTEXT *pDXContext)
 {
     VMSVGA3DBACKENDSURFACE *pBackendSurface = pSurface->pBackendSurface;
@@ -737 +845 @@
         AssertFailedReturn(NULL);
 
-    if (pDXContext->cid == pSurface->idAssociatedContext)
-        return pBackendSurface->u.Resource.pResource;
+    uint32_t const cidRequesting = pDXContext ? pDXContext->cid : DX_CID_BACKEND;
+    if (cidRequesting == pSurface->idAssociatedContext)
+        return pBackendSurface->u.pResource;
+
+    AssertReturn(pDXContext, NULL);
 
     /*
      * Another context is requesting.
      */
-    /* Expecting this for screen targets only. */
-    Assert(pSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET);
-    Assert(pSurface->idAssociatedContext == SVGA_ID_INVALID);
+    Assert(dxIsSurfaceShareable(pSurface));
+    Assert(pSurface->idAssociatedContext == DX_CID_BACKEND);
 
     DXSHAREDTEXTURE *pSharedTexture = (DXSHAREDTEXTURE *)RTAvlU32Get(&pBackendSurface->SharedTextureTree, pDXContext->cid);
@@ -753 +863 @@
         AssertReturn(pDevice->pDevice, NULL);
 
-        AssertReturn(pBackendSurface->u.ScreenTarget.SharedHandle, NULL);
+        AssertReturn(pBackendSurface->SharedHandle, NULL);
 
         /* This context has not yet opened the texture. */
@@ -763 +873 @@
         AssertReturn(fSuccess, NULL);
 
-        HRESULT hr = pDevice->pDevice->OpenSharedResource(pBackendSurface->u.ScreenTarget.SharedHandle, __uuidof(ID3D11Texture2D), (void**)&pSharedTexture->pTexture);
+        HRESULT hr = pDevice->pDevice->OpenSharedResource(pBackendSurface->SharedHandle, __uuidof(ID3D11Texture2D), (void**)&pSharedTexture->pTexture);
         Assert(SUCCEEDED(hr));
         if (SUCCEEDED(hr))
@@ -775 +885 @@
     }
 
+    /* Wait for drawing to finish. */
+    if (pBackendSurface->cidDrawing != SVGA_ID_INVALID)
+    {
+        if (pBackendSurface->cidDrawing != pDXContext->cid)
+        {
+            dxContextWait(pBackendSurface->cidDrawing, pState);
+            pBackendSurface->cidDrawing = SVGA_ID_INVALID;
+        }
+    }
+
     return pSharedTexture->pTexture;
 }
 
+
+static int dxTrackRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
+    AssertReturn(pState, VERR_INVALID_STATE);
+
+//ASMBreakpoint();
+    for (int i = 0; i < RT_ELEMENTS(pDXContext->svgaDXContext.renderState.renderTargetViewIds); ++i)
+    {
+        uint32_t const renderTargetViewId = pDXContext->svgaDXContext.renderState.renderTargetViewIds[i];
+        if (renderTargetViewId == SVGA_ID_INVALID)
+            continue;
+
+        AssertContinue(renderTargetViewId < pDXContext->cot.cRTView);
+
+        SVGACOTableDXRTViewEntry const *pRTViewEntry = &pDXContext->cot.paRTView[renderTargetViewId];
+
+        PVMSVGA3DSURFACE pSurface;
+        int rc = vmsvga3dSurfaceFromSid(pState, pRTViewEntry->sid, &pSurface);
+        if (   RT_SUCCESS(rc)
+            && pSurface->pBackendSurface)
+        {
+            pSurface->pBackendSurface->cidDrawing = pDXContext->cid;
+        }
+    }
+    return VINF_SUCCESS;
+}
+
+static D3D11_BLEND dxBlendFactorAlpha(uint8_t svgaBlend)
+{
+    /* "Blend options that end in _COLOR are not allowed." but the guest sometimes sends them. */
+    switch (svgaBlend)
+    {
+        case SVGA3D_BLENDOP_SRCCOLOR:     return D3D11_BLEND_SRC_ALPHA;
+        case SVGA3D_BLENDOP_INVSRCCOLOR:  return D3D11_BLEND_INV_SRC_ALPHA;
+        case SVGA3D_BLENDOP_DESTCOLOR:    return D3D11_BLEND_DEST_ALPHA;
+        case SVGA3D_BLENDOP_INVDESTCOLOR: return D3D11_BLEND_INV_DEST_ALPHA;
+        case SVGA3D_BLENDOP_SRC1COLOR:    return D3D11_BLEND_SRC1_ALPHA;
+        case SVGA3D_BLENDOP_INVSRC1COLOR: return D3D11_BLEND_INV_SRC1_ALPHA;
+        default:
+            break;
+    }
+    return (D3D11_BLEND)svgaBlend;
+}
+
+static D3D11_BLEND dxBlendFactorColor(uint8_t svgaBlend)
+{
+    return (D3D11_BLEND)svgaBlend;
+}
+
+static D3D11_BLEND_OP dxBlendOp(uint8_t svgaBlendEq)
+{
+    return (D3D11_BLEND_OP)svgaBlendEq;
+}
 
 /** @todo AssertCompile for types like D3D11_COMPARISON_FUNC and SVGA3dComparisonFunc */
@@ -788 +962 @@
     {
         BlendDesc.RenderTarget[i].BlendEnable           = RT_BOOL(pEntry->perRT[i].blendEnable);
-        BlendDesc.RenderTarget[i].SrcBlend              = (D3D11_BLEND)pEntry->perRT[i].srcBlend;
-        BlendDesc.RenderTarget[i].DestBlend             = (D3D11_BLEND)pEntry->perRT[i].destBlend;
-        BlendDesc.RenderTarget[i].BlendOp               = (D3D11_BLEND_OP)pEntry->perRT[i].blendOp;
-        BlendDesc.RenderTarget[i].SrcBlendAlpha         = (D3D11_BLEND)pEntry->perRT[i].srcBlendAlpha;
-        BlendDesc.RenderTarget[i].DestBlendAlpha        = (D3D11_BLEND)pEntry->perRT[i].destBlendAlpha;
-        BlendDesc.RenderTarget[i].BlendOpAlpha          = (D3D11_BLEND_OP)pEntry->perRT[i].blendOpAlpha;
+        BlendDesc.RenderTarget[i].SrcBlend              = dxBlendFactorColor(pEntry->perRT[i].srcBlend);
+        BlendDesc.RenderTarget[i].DestBlend             = dxBlendFactorColor(pEntry->perRT[i].destBlend);
+        BlendDesc.RenderTarget[i].BlendOp               = dxBlendOp         (pEntry->perRT[i].blendOp);
+        BlendDesc.RenderTarget[i].SrcBlendAlpha         = dxBlendFactorAlpha(pEntry->perRT[i].srcBlendAlpha);
+        BlendDesc.RenderTarget[i].DestBlendAlpha        = dxBlendFactorAlpha(pEntry->perRT[i].destBlendAlpha);
+        BlendDesc.RenderTarget[i].BlendOpAlpha          = dxBlendOp         (pEntry->perRT[i].blendOpAlpha);
         BlendDesc.RenderTarget[i].RenderTargetWriteMask = pEntry->perRT[i].renderTargetWriteMask;
         /** @todo logicOpEnable and logicOp */
@@ -832 +1006 @@
 {
     D3D11_SAMPLER_DESC desc;
-    desc.Filter         = (D3D11_FILTER)pEntry->filter;
+    /* Guest sometimes sends inconsistent (from D3D11 point of view) set of filter flags. */
+    if (pEntry->filter & SVGA3D_FILTER_ANISOTROPIC)
+        desc.Filter     = (pEntry->filter & SVGA3D_FILTER_COMPARE)
+                        ? D3D11_FILTER_COMPARISON_ANISOTROPIC
+                        : D3D11_FILTER_ANISOTROPIC;
+    else
+        desc.Filter     = (D3D11_FILTER)pEntry->filter;
     desc.AddressU       = (D3D11_TEXTURE_ADDRESS_MODE)pEntry->addressU;
     desc.AddressV       = (D3D11_TEXTURE_ADDRESS_MODE)pEntry->addressV;
@@ -874 +1054 @@
 
 
-static HRESULT dxRenderTargetViewCreate(PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXRTViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11RenderTargetView **pp)
+static HRESULT dxRenderTargetViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXRTViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11RenderTargetView **pp)
 {
     DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
 
-    ID3D11Resource *pResource = dxResource(pSurface, pDXContext);
-    //pBackendSurface->u.Texture.pTexture;
+    ID3D11Resource *pResource = dxResource(pThisCC->svga.p3dState, pSurface, pDXContext);
 
     D3D11_RENDER_TARGET_VIEW_DESC desc;
@@ -949 +1128 @@
 
 
-static HRESULT dxShaderResourceViewCreate(PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXSRViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11ShaderResourceView **pp)
+static HRESULT dxShaderResourceViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXSRViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11ShaderResourceView **pp)
 {
     DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
 
-    ID3D11Resource *pResource = dxResource(pSurface, pDXContext);
-//    ID3D11Resource *pResource = pBackendSurface->u.Texture.pTexture;
+    ID3D11Resource *pResource = dxResource(pThisCC->svga.p3dState, pSurface, pDXContext);
 
     D3D11_SHADER_RESOURCE_VIEW_DESC desc;
@@ -1006 +1184 @@
             break;
         case SVGA3D_RESOURCE_TEXTURECUBE:
-            AssertFailed(); /** @todo test. */
             desc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURECUBE;
             desc.TextureCube.MostDetailedMip = pEntry->desc.tex.mostDetailedMip;
@@ -1028 +1205 @@
 
 
-static HRESULT dxDepthStencilViewCreate(DXDEVICE *pDevice, SVGACOTableDXDSViewEntry const *pEntry, VMSVGA3DBACKENDSURFACE *pBackendSurface, ID3D11DepthStencilView **pp)
-{
-    ID3D11Resource *pResource = pBackendSurface->u.Texture.pTexture;
+static HRESULT dxDepthStencilViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXDSViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11DepthStencilView **pp)
+{
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+
+    ID3D11Resource *pResource = dxResource(pThisCC->svga.p3dState, pSurface, pDXContext);
 
     D3D11_DEPTH_STENCIL_VIEW_DESC desc;
@@ -1183 +1362 @@
 
 
+static int dxBackendSurfaceAlloc(PVMSVGA3DBACKENDSURFACE *ppBackendSurface)
+{
+    PVMSVGA3DBACKENDSURFACE pBackendSurface = (PVMSVGA3DBACKENDSURFACE)RTMemAllocZ(sizeof(VMSVGA3DBACKENDSURFACE));
+    AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
+    pBackendSurface->cidDrawing = SVGA_ID_INVALID;
+    *ppBackendSurface = pBackendSurface;
+    return VINF_SUCCESS;
+}
+
+
 static int vmsvga3dBackSurfaceCreateScreenTarget(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface)
 {
@@ -1203 +1392 @@
     }
 
-    PVMSVGA3DBACKENDSURFACE pBackendSurface = (PVMSVGA3DBACKENDSURFACE)RTMemAllocZ(sizeof(VMSVGA3DBACKENDSURFACE));
-    AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
+    PVMSVGA3DBACKENDSURFACE pBackendSurface;
+    int rc = dxBackendSurfaceAlloc(&pBackendSurface);
+    AssertRCReturn(rc, rc);
 
     D3D11_TEXTURE2D_DESC td;
@@ -1221 +1411 @@
     td.MiscFlags          = D3D11_RESOURCE_MISC_SHARED;
 
-    HRESULT hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.ScreenTarget.pTexture);
+    HRESULT hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.pTexture2D);
     Assert(SUCCEEDED(hr));
     if (SUCCEEDED(hr))
@@ -1230 +1420 @@
         td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
         td.MiscFlags      = 0;
-        hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.ScreenTarget.pDynamicTexture);
+        hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->pDynamicTexture);
         Assert(SUCCEEDED(hr));
     }
@@ -1240 +1430 @@
         td.BindFlags      = 0; /* No flags allowed. */
         td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-        hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.ScreenTarget.pStagingTexture);
+        hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->pStagingTexture);
         Assert(SUCCEEDED(hr));
     }
@@ -1248 +1438 @@
         /* Get the shared handle. */
         IDXGIResource *pDxgiResource = NULL;
-        hr = pBackendSurface->u.ScreenTarget.pTexture->QueryInterface(__uuidof(IDXGIResource), (void**)&pDxgiResource);
+        hr = pBackendSurface->u.pTexture2D->QueryInterface(__uuidof(IDXGIResource), (void**)&pDxgiResource);
         Assert(SUCCEEDED(hr));
         if (SUCCEEDED(hr))
         {
-            hr = pDxgiResource->GetSharedHandle(&pBackendSurface->u.ScreenTarget.SharedHandle);
+            hr = pDxgiResource->GetSharedHandle(&pBackendSurface->SharedHandle);
             Assert(SUCCEEDED(hr));
             D3D_RELEASE(pDxgiResource);
@@ -1266 +1456 @@
         pBackendSurface->enmDxgiFormat = td.Format;
         pSurface->pBackendSurface = pBackendSurface;
-        pSurface->idAssociatedContext = SVGA_ID_INVALID;
+        pSurface->idAssociatedContext = DX_CID_BACKEND;
         pSurface->fDirty = true;
         return VINF_SUCCESS;
@@ -1272 +1462 @@
 
     /* Failure. */
-    D3D_RELEASE(pBackendSurface->u.ScreenTarget.pStagingTexture);
-    D3D_RELEASE(pBackendSurface->u.ScreenTarget.pDynamicTexture);
-    D3D_RELEASE(pBackendSurface->u.ScreenTarget.pTexture);
+    D3D_RELEASE(pBackendSurface->pStagingTexture);
+    D3D_RELEASE(pBackendSurface->pDynamicTexture);
+    D3D_RELEASE(pBackendSurface->u.pTexture2D);
     RTMemFree(pBackendSurface);
     return VERR_NO_MEMORY;
@@ -1305 +1495 @@
     AssertReturn(p3dState, VERR_INVALID_STATE);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+    PVMSVGA3DBACKEND pBackend = p3dState->pBackend;
+    AssertReturn(pBackend, VERR_INVALID_STATE);
+
+    UINT MiscFlags;
+    DXDEVICE *pDXDevice;
+    if (dxIsSurfaceShareable(pSurface))
+    {
+        pDXDevice = &pBackend->device;
+        MiscFlags = D3D11_RESOURCE_MISC_SHARED;
+    }
+    else
+    {
+        pDXDevice = &pDXContext->pBackendDXContext->device;
+        MiscFlags = 0;
+    }
+    AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
     if (pSurface->pBackendSurface != NULL)
@@ -1314 +1518 @@
     }
 
-    PVMSVGA3DBACKENDSURFACE pBackendSurface = (PVMSVGA3DBACKENDSURFACE)RTMemAllocZ(sizeof(VMSVGA3DBACKENDSURFACE));
-    AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
+    PVMSVGA3DBACKENDSURFACE pBackendSurface;
+    int rc = dxBackendSurfaceAlloc(&pBackendSurface);
+    AssertRCReturn(rc, rc);
 
     uint32_t const cWidth = pSurface->paMipmapLevels[0].mipmapSize.width;
@@ -1334 +1539 @@
          * Create the texture in backend device and open for the specified context.
          */
-        PVMSVGA3DBACKEND pBackend = p3dState->pBackend;
-        AssertReturn(pBackend, VERR_INVALID_STATE);
-
-        DXDEVICE *pDXDevice = &pBackend->device;
-        AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
-
         D3D11_TEXTURE2D_DESC td;
         RT_ZERO(td);
@@ -1353 +1552 @@
         td.BindFlags          = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
         td.CPUAccessFlags     = 0;
-        td.MiscFlags          = D3D11_RESOURCE_MISC_SHARED;
-
-        hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.ScreenTarget.pTexture);
+        td.MiscFlags          = MiscFlags;
+
+        hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.pTexture2D);
         Assert(SUCCEEDED(hr));
         if (SUCCEEDED(hr))
@@ -1364 +1563 @@
             td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
             td.MiscFlags      = 0;
-            hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.ScreenTarget.pDynamicTexture);
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->pDynamicTexture);
             Assert(SUCCEEDED(hr));
         }
@@ -1374 +1573 @@
             td.BindFlags      = 0; /* No flags allowed. */
             td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
-            hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.ScreenTarget.pStagingTexture);
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->pStagingTexture);
             Assert(SUCCEEDED(hr));
         }
@@ -1382 +1581 @@
             /* Get the shared handle. */
             IDXGIResource *pDxgiResource = NULL;
-            hr = pBackendSurface->u.ScreenTarget.pTexture->QueryInterface(__uuidof(IDXGIResource), (void**)&pDxgiResource);
+            hr = pBackendSurface->u.pTexture2D->QueryInterface(__uuidof(IDXGIResource), (void**)&pDxgiResource);
             Assert(SUCCEEDED(hr));
             if (SUCCEEDED(hr))
             {
-                hr = pDxgiResource->GetSharedHandle(&pBackendSurface->u.ScreenTarget.SharedHandle);
+                hr = pDxgiResource->GetSharedHandle(&pBackendSurface->SharedHandle);
                 Assert(SUCCEEDED(hr));
                 D3D_RELEASE(pDxgiResource);
@@ -1402 +1601 @@
         Assert(cWidth == cHeight);
         Assert(cDepth == 1);
-
-        pBackendSurface->enmResType = VMSVGA3D_RESTYPE_CUBE_TEXTURE;
-        AssertFailed(); /** @todo implement */
-        hr = E_FAIL;
+//ASMBreakpoint();
+        D3D11_SUBRESOURCE_DATA *paInitialData = NULL;
+        D3D11_SUBRESOURCE_DATA aInitialData[6 * SVGA3D_MAX_MIP_LEVELS];
+        if (pSurface->paMipmapLevels[0].pSurfaceData)
+        {
+            /** @todo Can happen for a non GBO surface or if GBO texture was updated prior to creation if the hardware resource. Test this. */
+            /** @todo for (i = 0; i < pSurface->cFaces * numMipLevels; ++i) */
+            for (uint32_t iFace = 0; iFace < 6; ++iFace)
+            {
+                for (uint32_t i = 0; i < numMipLevels; ++i)
+                {
+                    uint32_t const iSubresource = vmsvga3dCalcSubresource(i, iFace, numMipLevels);
+
+                    PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[iSubresource];
+                    D3D11_SUBRESOURCE_DATA *p = &aInitialData[iSubresource];
+                    p->pSysMem          = pMipmapLevel->pSurfaceData;
+                    p->SysMemPitch      = pMipmapLevel->cbSurfacePitch;
+                    p->SysMemSlicePitch = pMipmapLevel->cbSurfacePlane;
+                }
+            }
+            paInitialData = &aInitialData[0];
+        }
+
+        D3D11_TEXTURE2D_DESC td;
+        RT_ZERO(td);
+        td.Width              = cWidth;
+        td.Height             = cHeight;
+        td.MipLevels          = numMipLevels;
+        td.ArraySize          = 6;
+        td.Format             = dxgiFormat;
+        td.SampleDesc.Count   = 1;
+        td.SampleDesc.Quality = 0;
+        td.Usage              = D3D11_USAGE_DEFAULT;
+        td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
+        td.CPUAccessFlags     = 0; /** @todo */
+        td.MiscFlags          = MiscFlags | D3D11_RESOURCE_MISC_TEXTURECUBE; /** @todo */
+        if (   numMipLevels > 1
+            && (td.BindFlags & (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET)) == (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET))
+            td.MiscFlags     |= D3D11_RESOURCE_MISC_GENERATE_MIPS; /* Required for GenMips. */
+
+        hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->u.pTexture2D);
+        Assert(SUCCEEDED(hr));
+        if (SUCCEEDED(hr))
+        {
+            /* Map-able texture. */
+            td.MipLevels      = 1; /* Must be for D3D11_USAGE_DYNAMIC. */
+            td.ArraySize      = 1; /* Must be for D3D11_USAGE_DYNAMIC. */
+            td.Usage          = D3D11_USAGE_DYNAMIC;
+            td.BindFlags      = D3D11_BIND_SHADER_RESOURCE; /* Have to specify a supported flag, otherwise E_INVALIDARG will be returned. */
+            td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+            td.MiscFlags      = 0;
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pDynamicTexture);
+            Assert(SUCCEEDED(hr));
+        }
+
+        if (SUCCEEDED(hr))
+        {
+            /* Staging texture. */
+            td.Usage          = D3D11_USAGE_STAGING;
+            td.BindFlags      = 0; /* No flags allowed. */
+            td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+            td.MiscFlags      = 0;
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pStagingTexture);
+            Assert(SUCCEEDED(hr));
+        }
+
+        if (   SUCCEEDED(hr)
+            && MiscFlags == D3D11_RESOURCE_MISC_SHARED)
+        {
+            /* Get the shared handle. */
+            IDXGIResource *pDxgiResource = NULL;
+            hr = pBackendSurface->u.pTexture2D->QueryInterface(__uuidof(IDXGIResource), (void**)&pDxgiResource);
+            Assert(SUCCEEDED(hr));
+            if (SUCCEEDED(hr))
+            {
+                hr = pDxgiResource->GetSharedHandle(&pBackendSurface->SharedHandle);
+                Assert(SUCCEEDED(hr));
+                D3D_RELEASE(pDxgiResource);
+            }
+        }
+
+        if (SUCCEEDED(hr))
+        {
+            pBackendSurface->enmResType = VMSVGA3D_RESTYPE_CUBE_TEXTURE;
+        }
     }
     else if (pSurface->surfaceFlags & SVGA3D_SURFACE_1D)
@@ -1419 +1699 @@
              * Volume texture.
              */
-            pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE_3D;
-            AssertFailed(); /** @todo implement */
-            hr = E_FAIL;
+            Assert(pSurface->cFaces == 1);
+
+            D3D11_SUBRESOURCE_DATA *paInitialData = NULL;
+            D3D11_SUBRESOURCE_DATA aInitialData[SVGA3D_MAX_MIP_LEVELS];
+            if (pSurface->paMipmapLevels[0].pSurfaceData)
+            {
+                /** @todo Can happen for a non GBO surface or if GBO texture was updated prior to creation if the hardware resource. Test this. */
+                for (uint32_t i = 0; i < numMipLevels; ++i)
+                {
+                    PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
+                    D3D11_SUBRESOURCE_DATA *p = &aInitialData[i];
+                    p->pSysMem          = pMipmapLevel->pSurfaceData;
+                    p->SysMemPitch      = pMipmapLevel->cbSurfacePitch;
+                    p->SysMemSlicePitch = pMipmapLevel->cbSurfacePlane;
+                }
+                paInitialData = &aInitialData[0];
+            }
+
+            D3D11_TEXTURE3D_DESC td;
+            RT_ZERO(td);
+            td.Width              = cWidth;
+            td.Height             = cHeight;
+            td.Depth              = cDepth;
+            td.MipLevels          = numMipLevels;
+            td.Format             = dxgiFormat;
+            td.Usage              = D3D11_USAGE_DEFAULT;
+            td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
+            td.CPUAccessFlags     = 0; /** @todo */
+            td.MiscFlags          = MiscFlags; /** @todo */
+            if (   numMipLevels > 1
+                && (td.BindFlags & (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET)) == (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET))
+                td.MiscFlags     |= D3D11_RESOURCE_MISC_GENERATE_MIPS; /* Required for GenMips. */
+
+            hr = pDXDevice->pDevice->CreateTexture3D(&td, paInitialData, &pBackendSurface->u.pTexture3D);
+            Assert(SUCCEEDED(hr));
+            if (SUCCEEDED(hr))
+            {
+                /* Map-able texture. */
+                td.MipLevels      = 1; /* Must be for D3D11_USAGE_DYNAMIC. */
+                td.Usage          = D3D11_USAGE_DYNAMIC;
+                td.BindFlags      = D3D11_BIND_SHADER_RESOURCE; /* Have to specify a supported flag, otherwise E_INVALIDARG will be returned. */
+                td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+                td.MiscFlags      = 0;
+                hr = pDXDevice->pDevice->CreateTexture3D(&td, paInitialData, &pBackendSurface->pDynamicTexture3D);
+                Assert(SUCCEEDED(hr));
+            }
+
+            if (SUCCEEDED(hr))
+            {
+                /* Staging texture. */
+                td.Usage          = D3D11_USAGE_STAGING;
+                td.BindFlags      = 0; /* No flags allowed. */
+                td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+                td.MiscFlags      = 0;
+                hr = pDXDevice->pDevice->CreateTexture3D(&td, paInitialData, &pBackendSurface->pStagingTexture3D);
+                Assert(SUCCEEDED(hr));
+            }
+
+            if (   SUCCEEDED(hr)
+                && MiscFlags == D3D11_RESOURCE_MISC_SHARED)
+            {
+                /* Get the shared handle. */
+                IDXGIResource *pDxgiResource = NULL;
+                hr = pBackendSurface->u.pTexture3D->QueryInterface(__uuidof(IDXGIResource), (void**)&pDxgiResource);
+                Assert(SUCCEEDED(hr));
+                if (SUCCEEDED(hr))
+                {
+                    hr = pDxgiResource->GetSharedHandle(&pBackendSurface->SharedHandle);
+                    Assert(SUCCEEDED(hr));
+                    D3D_RELEASE(pDxgiResource);
+                }
+            }
+
+            if (SUCCEEDED(hr))
+            {
+                pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE_3D;
+            }
         }
         else
@@ -1434 +1788 @@
             if (pSurface->paMipmapLevels[0].pSurfaceData)
             {
-                /** @todo Can happen for a non GBO surface. Test this. */
+                /** @todo Can happen for a non GBO surface or if GBO texture was updated prior to creation if the hardware resource. Test this. */
                 for (uint32_t i = 0; i < numMipLevels; ++i)
                 {
@@ -1458 +1812 @@
             td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
             td.CPUAccessFlags     = 0; /** @todo */
-            td.MiscFlags          = 0; /** @todo */
+            td.MiscFlags          = MiscFlags; /** @todo */
             if (   numMipLevels > 1
                 && (td.BindFlags & (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET)) == (D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET))
                 td.MiscFlags     |= D3D11_RESOURCE_MISC_GENERATE_MIPS; /* Required for GenMips. */
 
-            hr = pDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->u.Texture.pTexture);
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->u.pTexture2D);
             Assert(SUCCEEDED(hr));
             if (SUCCEEDED(hr))
@@ -1473 +1827 @@
                 td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
                 td.MiscFlags      = 0;
-                hr = pDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->u.Texture.pDynamicTexture);
+                hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pDynamicTexture);
                 Assert(SUCCEEDED(hr));
             }
@@ -1484 +1838 @@
                 td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
                 td.MiscFlags      = 0;
-                hr = pDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->u.Texture.pStagingTexture);
+                hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pStagingTexture);
                 Assert(SUCCEEDED(hr));
+            }
+
+            if (   SUCCEEDED(hr)
+                && MiscFlags == D3D11_RESOURCE_MISC_SHARED)
+            {
+                /* Get the shared handle. */
+                IDXGIResource *pDxgiResource = NULL;
+                hr = pBackendSurface->u.pTexture2D->QueryInterface(__uuidof(IDXGIResource), (void**)&pDxgiResource);
+                Assert(SUCCEEDED(hr));
+                if (SUCCEEDED(hr))
+                {
+                    hr = pDxgiResource->GetSharedHandle(&pBackendSurface->SharedHandle);
+                    Assert(SUCCEEDED(hr));
+                    D3D_RELEASE(pDxgiResource);
+                }
             }
 
@@ -1508 +1877 @@
         pBackendSurface->enmDxgiFormat = dxgiFormat;
         pSurface->pBackendSurface = pBackendSurface;
-        if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
-            pSurface->idAssociatedContext = SVGA_ID_INVALID;
+        if (RT_BOOL(MiscFlags & D3D11_RESOURCE_MISC_SHARED))
+            pSurface->idAssociatedContext = DX_CID_BACKEND;
         else
             pSurface->idAssociatedContext = pDXContext->cid;
@@ -1516 +1885 @@
 
     /* Failure. */
-    D3D_RELEASE(pBackendSurface->u.Texture.pStagingTexture);
-    D3D_RELEASE(pBackendSurface->u.Texture.pDynamicTexture);
-    D3D_RELEASE(pBackendSurface->u.Texture.pTexture);
+    D3D_RELEASE(pBackendSurface->pStagingTexture);
+    D3D_RELEASE(pBackendSurface->pDynamicTexture);
+    D3D_RELEASE(pBackendSurface->u.pTexture2D);
     RTMemFree(pBackendSurface);
     return VERR_NO_MEMORY;
@@ -1526 +1895 @@
 static int vmsvga3dBackSurfaceCreateDepthStencilTexture(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+    DXDEVICE *pDXDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
     if (pSurface->pBackendSurface != NULL)
@@ -1535 +1904 @@
     }
 
-    PVMSVGA3DBACKENDSURFACE pBackendSurface = (PVMSVGA3DBACKENDSURFACE)RTMemAllocZ(sizeof(VMSVGA3DBACKENDSURFACE));
-    AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
+    PVMSVGA3DBACKENDSURFACE pBackendSurface;
+    int rc = dxBackendSurfaceAlloc(&pBackendSurface);
+    AssertRCReturn(rc, rc);
+
+    uint32_t const cWidth = pSurface->paMipmapLevels[0].mipmapSize.width;
+    uint32_t const cHeight = pSurface->paMipmapLevels[0].mipmapSize.height;
+    uint32_t const numMipLevels = pSurface->cLevels;
+
+    D3D11_SUBRESOURCE_DATA *paInitialData = NULL;
+    D3D11_SUBRESOURCE_DATA aInitialData[SVGA3D_MAX_MIP_LEVELS];
+    if (pSurface->paMipmapLevels[0].pSurfaceData)
+    {
+        /** @todo Can happen for a non GBO surface or if GBO texture was updated prior to creation if the hardware resource. Test this. */
+        for (uint32_t i = 0; i < numMipLevels; ++i)
+        {
+            PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
+            D3D11_SUBRESOURCE_DATA *p = &aInitialData[i];
+            p->pSysMem          = pMipmapLevel->pSurfaceData;
+            p->SysMemPitch      = pMipmapLevel->cbSurfacePitch;
+            p->SysMemSlicePitch = pMipmapLevel->cbSurfacePlane;
+        }
+        paInitialData = &aInitialData[0];
+    }
 
     D3D11_TEXTURE2D_DESC td;
     RT_ZERO(td);
-    td.Width              = pSurface->paMipmapLevels[0].mipmapSize.width;
-    td.Height             = pSurface->paMipmapLevels[0].mipmapSize.height;
+    td.Width              = cWidth;
+    td.Height             = cHeight;
     Assert(pSurface->cLevels == 1);
     td.MipLevels          = 1;
@@ -1550 +1940 @@
     td.SampleDesc.Quality = 0;
     td.Usage              = D3D11_USAGE_DEFAULT;
-    td.BindFlags          = D3D11_BIND_DEPTH_STENCIL;
+    td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
     td.CPUAccessFlags     = 0;
     td.MiscFlags          = 0;
 
-    HRESULT hr = pDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.Texture.pTexture);
+    HRESULT hr = pDXDevice->pDevice->CreateTexture2D(&td, 0, &pBackendSurface->u.pTexture2D);
     Assert(SUCCEEDED(hr));
+    if (SUCCEEDED(hr))
+    {
+        /* Map-able texture. */
+        td.MipLevels      = 1; /* Must be for D3D11_USAGE_DYNAMIC. */
+        td.Usage          = D3D11_USAGE_DYNAMIC;
+        td.BindFlags      = D3D11_BIND_SHADER_RESOURCE; /* Have to specify a supported flag, otherwise E_INVALIDARG will be returned. */
+        td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+        td.MiscFlags      = 0;
+        hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pDynamicTexture);
+        Assert(SUCCEEDED(hr));
+    }
+
+    if (SUCCEEDED(hr))
+    {
+        /* Staging texture. */
+        td.Usage          = D3D11_USAGE_STAGING;
+        td.BindFlags      = 0; /* No flags allowed. */
+        td.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
+        td.MiscFlags      = 0;
+        hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pStagingTexture);
+        Assert(SUCCEEDED(hr));
+    }
+
     if (SUCCEEDED(hr))
     {
@@ -1565 +1978 @@
         pSurface->pBackendSurface = pBackendSurface;
         pSurface->idAssociatedContext = pDXContext->cid;
-        pSurface->fDirty = true;
+        //pSurface->fDirty = true;
         return VINF_SUCCESS;
     }
 
     /* Failure. */
-    D3D_RELEASE(pBackendSurface->u.Texture.pStagingTexture);
-    D3D_RELEASE(pBackendSurface->u.Texture.pDynamicTexture);
-    D3D_RELEASE(pBackendSurface->u.Texture.pTexture);
+    D3D_RELEASE(pBackendSurface->pStagingTexture);
+    D3D_RELEASE(pBackendSurface->pDynamicTexture);
+    D3D_RELEASE(pBackendSurface->u.pTexture2D);
     RTMemFree(pBackendSurface);
     return VERR_NO_MEMORY;
@@ -1598 +2011 @@
     }
 
-    PVMSVGA3DBACKENDSURFACE pBackendSurface = (PVMSVGA3DBACKENDSURFACE)RTMemAllocZ(sizeof(VMSVGA3DBACKENDSURFACE));
-    AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
+    PVMSVGA3DBACKENDSURFACE pBackendSurface;
+    int rc = dxBackendSurfaceAlloc(&pBackendSurface);
+    AssertRCReturn(rc, rc);
 
     D3D11_BUFFER_DESC bd;
@@ -1614 +2028 @@
     bd.StructureByteStride = 0;
 
-    HRESULT hr = pDevice->pDevice->CreateBuffer(&bd, 0, &pBackendSurface->u.Buffer.pBuffer);
+    HRESULT hr = pDevice->pDevice->CreateBuffer(&bd, 0, &pBackendSurface->u.pBuffer);
     if (SUCCEEDED(hr))
     {
@@ -1629 +2043 @@
 
     /* Failure. */
-    D3D_RELEASE(pBackendSurface->u.Buffer.pBuffer);
+    D3D_RELEASE(pBackendSurface->u.pBuffer);
     RTMemFree(pBackendSurface);
     return VERR_NO_MEMORY;
@@ -1649 +2063 @@
     }
 
-    PVMSVGA3DBACKENDSURFACE pBackendSurface = (PVMSVGA3DBACKENDSURFACE)RTMemAllocZ(sizeof(VMSVGA3DBACKENDSURFACE));
-    AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
+    PVMSVGA3DBACKENDSURFACE pBackendSurface;
+    int rc = dxBackendSurfaceAlloc(&pBackendSurface);
+    AssertRCReturn(rc, rc);
 
     D3D11_BUFFER_DESC bd;
@@ -1661 +2076 @@
     bd.StructureByteStride = 0;
 
-    HRESULT hr = pDevice->pDevice->CreateBuffer(&bd, 0, &pBackendSurface->u.Buffer.pBuffer);
+    HRESULT hr = pDevice->pDevice->CreateBuffer(&bd, 0, &pBackendSurface->u.pBuffer);
     if (SUCCEEDED(hr))
     {
@@ -1676 +2091 @@
 
     /* Failure. */
-    D3D_RELEASE(pBackendSurface->u.Buffer.pBuffer);
+    D3D_RELEASE(pBackendSurface->u.pBuffer);
     RTMemFree(pBackendSurface);
     return VERR_NO_MEMORY;
@@ -1694 +2109 @@
     bd.StructureByteStride = 0;
 
-    return pDevice->pDevice->CreateBuffer(&bd, pInitialData, &pBackendSurface->u.Buffer.pBuffer);
+    return pDevice->pDevice->CreateBuffer(&bd, pInitialData, &pBackendSurface->u.pBuffer);
 }
 
@@ -1711 +2126 @@
     bd.StructureByteStride = 0;
 
-    return pDevice->pDevice->CreateBuffer(&bd, pInitialData, &pBackendSurface->u.Buffer.pBuffer);
+    return pDevice->pDevice->CreateBuffer(&bd, pInitialData, &pBackendSurface->u.pBuffer);
 }
 
@@ -1726 +2141 @@
     }
 
-    PVMSVGA3DBACKENDSURFACE pBackendSurface = (PVMSVGA3DBACKENDSURFACE)RTMemAllocZ(sizeof(VMSVGA3DBACKENDSURFACE));
-    AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
+    PVMSVGA3DBACKENDSURFACE pBackendSurface;
+    int rc = dxBackendSurfaceAlloc(&pBackendSurface);
+    AssertRCReturn(rc, rc);
 
     HRESULT hr;
@@ -1743 +2159 @@
         }
         else
-            D3D_RELEASE(pBackendSurface->u.Buffer.pBuffer);
+            D3D_RELEASE(pBackendSurface->u.pBuffer);
     }
     else if (pSurface->surfaceFlags & (  SVGA3D_SURFACE_BIND_VERTEX_BUFFER
@@ -1757 +2173 @@
         }
         else
-            D3D_RELEASE(pBackendSurface->u.Buffer.pBuffer);
+            D3D_RELEASE(pBackendSurface->u.pBuffer);
     }
     else
@@ -1801 +2217 @@
     }
 
-    rc = RTLdrLoadSystem("D3DCompiler_47", /* fNoUnload = */ true, &pBackend->hD3DCompiler);
-    AssertRC(rc);
     if (RT_SUCCESS(rc))
     {
-        rc = RTLdrGetSymbol(pBackend->hD3DCompiler, "D3DDisassemble", (void **)&pBackend->pfnD3DDisassemble);
-        AssertRC(rc);
-    }
-
+        /* Failure to load the shader disassembler is ignored. */
+        int rc2 = RTLdrLoadSystem("D3DCompiler_47", /* fNoUnload = */ true, &pBackend->hD3DCompiler);
+        AssertRC(rc2);
+        if (RT_SUCCESS(rc2))
+        {
+            rc2 = RTLdrGetSymbol(pBackend->hD3DCompiler, "D3DDisassemble", (void **)&pBackend->pfnD3DDisassemble);
+            AssertRC(rc2);
+        }
+        Log6Func(("Load D3DDisassemble: %Rrc\n", rc2));
+    }
+//ASMBreakpoint();
     return rc;
 }
@@ -1835 +2256 @@
     if (pState->pBackend)
     {
+        /** @todo Clean up backends. */
+
         dxDeviceDestroy(pState->pBackend, &pState->pBackend->device);
 
@@ -2079 +2502 @@
 
 
-static DECLCALLBACK(int) dxContextFlushShared(PAVLU32NODECORE pCore, void *pvUser)
-{
-    PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pvUser;
-
-    // Flush pCore->Key context and issue a query.
-    PVMSVGA3DDXCONTEXT pDXContextDrawing;
-    int rc = vmsvga3dDXContextFromCid(pState, pCore->Key, &pDXContextDrawing);
-    AssertRCReturn(rc, rc);
-
-    DXDEVICE *pDeviceDrawing = &pDXContextDrawing->pBackendDXContext->device;
-    pDeviceDrawing->pImmediateContext->Flush();
-
-    ID3D11Query *pQuery = 0;
-    D3D11_QUERY_DESC qd;
-    RT_ZERO(qd);
-    qd.Query = D3D11_QUERY_EVENT;
-    HRESULT hr2 = pDeviceDrawing->pDevice->CreateQuery(&qd, &pQuery);
-    Assert(hr2 == S_OK); RT_NOREF(hr2);
-
-    pDeviceDrawing->pImmediateContext->End(pQuery);
-
-    BOOL queryData;
-    while (pDeviceDrawing->pImmediateContext->GetData(pQuery, &queryData, sizeof(queryData), 0) != S_OK)
-    {
-        RTThreadYield();
-    }
-    D3D_RELEASE(pQuery);
-
-    return VINF_SUCCESS;
-}
-
-
-
-static DECLCALLBACK(int) vmsvga3dSurfaceMap(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox,
-                                            VMSVGA3D_SURFACE_MAP enmMapType, VMSVGA3D_MAPPED_SURFACE *pMap)
+static DECLCALLBACK(int) vmsvga3dBackSurfaceMap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox,
+                                                VMSVGA3D_SURFACE_MAP enmMapType, VMSVGA3D_MAPPED_SURFACE *pMap)
 {
     PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
@@ -2125 +2515 @@
     AssertRCReturn(rc, rc);
 
-    Assert(pImage->face == 0 && pImage->mipmap == 0); /** @todo implement. */
-
-    PVMSVGA3DDXCONTEXT pDXContext;
-
     PVMSVGA3DBACKENDSURFACE pBackendSurface = pSurface->pBackendSurface;
-    if (!pBackendSurface)
-    {
-        /* This means that the guest uploads new data to the surface.
-         * So the data should be copied either to a host memory buffer,
-         * or to the actual surface.
-         * In the latter case the BackendSurface must be created here.
-         */
-        rc = vmsvga3dDXContextFromCid(pState, idDXContext, &pDXContext);
-        AssertRCReturn(rc, rc);
-
-        rc = vmsvga3dBackSurfaceCreate(pThisCC, pDXContext, pSurface);
-        AssertRCReturn(rc, rc);
-
-        pBackendSurface = pSurface->pBackendSurface;
-    }
-
-    /* Figure out whether the surface belongs to a DXContext or to the backend. */
-    if (pSurface->idAssociatedContext != SVGA_ID_INVALID)
-        vmsvga3dDXContextFromCid(pState, pSurface->idAssociatedContext, &pDXContext);
-    else
-        pDXContext = NULL;
-
-    DXDEVICE *pDevice;
-    if (pDXContext)
-        pDevice = &pDXContext->pBackendDXContext->device;
-    else
-        pDevice = &pBackend->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+    AssertPtrReturn(pBackendSurface, VERR_INVALID_STATE);
+
+    PVMSVGA3DMIPMAPLEVEL pMipLevel;
+    rc = vmsvga3dMipmapLevel(pSurface, pImage->face, pImage->mipmap, &pMipLevel);
+    ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+    /* A surface is always mapped by the DX context which has created the surface. */
+    DXDEVICE *pDevice = dxDeviceFromCid(pSurface->idAssociatedContext, pState);
+    AssertReturn(pDevice && pDevice->pDevice, VERR_INVALID_STATE);
 
     SVGA3dBox clipBox;
@@ -2163 +2530 @@
     {
         clipBox = *pBox;
-        vmsvgaR3ClipBox(&pSurface->paMipmapLevels[0].mipmapSize, &clipBox);
+        vmsvgaR3ClipBox(&pMipLevel->mipmapSize, &clipBox);
         ASSERT_GUEST_RETURN(clipBox.w && clipBox.h && clipBox.d, VERR_INVALID_PARAMETER);
     }
@@ -2171 +2538 @@
         clipBox.y = 0;
         clipBox.z = 0;
-        clipBox.w = pSurface->paMipmapLevels[0].mipmapSize.width;
-        clipBox.h = pSurface->paMipmapLevels[0].mipmapSize.height;
-        clipBox.d = pSurface->paMipmapLevels[0].mipmapSize.depth;
+        clipBox.w = pMipLevel->mipmapSize.width;
+        clipBox.h = pMipLevel->mipmapSize.height;
+        clipBox.d = pMipLevel->mipmapSize.depth;
     }
 
@@ -2194 +2561 @@
     if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
     {
+        Assert(pImage->face == 0 && pImage->mipmap == 0);
+
         ID3D11Texture2D *pMappedTexture;
         if (enmMapType == VMSVGA3D_SURFACE_MAP_READ)
         {
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pStagingTexture;
-
-            /** @todo Wait for the surface to finish drawing. */
-            if (pBackendSurface->SharedTextureTree)
+            pMappedTexture = pBackendSurface->pStagingTexture;
+
+            /* Wait for the surface to finish drawing. */
+            if (pBackendSurface->cidDrawing != SVGA_ID_INVALID)
             {
-                 int rc2 = RTAvlU32DoWithAll(&pBackendSurface->SharedTextureTree, 0, dxContextFlushShared, pState);
-                 AssertRC(rc2);
+                dxContextWait(pBackendSurface->cidDrawing, pState);
+                pBackendSurface->cidDrawing = SVGA_ID_INVALID;
             }
 
             /* Copy the texture content to the staging texture. */
-            pDevice->pImmediateContext->CopyResource(pBackendSurface->u.ScreenTarget.pStagingTexture, pBackendSurface->u.ScreenTarget.pTexture);
+            pDevice->pImmediateContext->CopyResource(pBackendSurface->pStagingTexture, pBackendSurface->u.pTexture2D);
         }
         else
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pDynamicTexture;
+            pMappedTexture = pBackendSurface->pDynamicTexture;
 
         UINT const Subresource = 0; /* Screen target surfaces have only one subresource. */
@@ -2230 +2599 @@
             rc = VERR_NOT_SUPPORTED;
     }
-    else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE)
-    {
+    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_CUBE_TEXTURE
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
+    {
+//Assert(pImage->face == 0 && pImage->mipmap == 0);
+if (!pBackendSurface->pStagingTexture || !pBackendSurface->pDynamicTexture) return VERR_NOT_IMPLEMENTED;
         ID3D11Texture2D *pMappedTexture;
         if (enmMapType == VMSVGA3D_SURFACE_MAP_READ)
         {
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pStagingTexture;
-
-            /* Copy the texture content to the staging texture. */
-            pDevice->pImmediateContext->CopyResource(pBackendSurface->u.ScreenTarget.pStagingTexture, pBackendSurface->u.ScreenTarget.pTexture);
+            pMappedTexture = pBackendSurface->pStagingTexture;
+
+            /* Wait for the surface to finish drawing. */
+            if (pBackendSurface->cidDrawing != SVGA_ID_INVALID)
+            {
+                dxContextWait(pBackendSurface->cidDrawing, pState);
+                pBackendSurface->cidDrawing = SVGA_ID_INVALID;
+            }
+
+            /* Copy the texture content to the staging texture.
+             * The requested miplevel of the texture is copied to the miplevel 0 of the staging texture,
+             * because the staging (and dynamic) structures do not have miplevels.
+             * Always copy entire miplevel so all Dst are zero and pSrcBox is NULL, as D3D11 requires.
+             */
+            ID3D11Resource *pDstResource = pBackendSurface->pStagingTexture;
+            UINT DstSubresource = 0;
+            UINT DstX = 0;
+            UINT DstY = 0;
+            UINT DstZ = 0;
+            ID3D11Resource *pSrcResource = pBackendSurface->u.pTexture2D;
+            UINT SrcSubresource = D3D11CalcSubresource(pImage->mipmap, pImage->face, pSurface->cLevels);
+            D3D11_BOX *pSrcBox = NULL;
+            //D3D11_BOX SrcBox;
+            //SrcBox.left   = 0;
+            //SrcBox.top    = 0;
+            //SrcBox.front  = 0;
+            //SrcBox.right  = pMipLevel->mipmapSize.width;
+            //SrcBox.bottom = pMipLevel->mipmapSize.height;
+            //SrcBox.back   = pMipLevel->mipmapSize.depth;
+            pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
+                                                              pSrcResource, SrcSubresource, pSrcBox);
         }
         else
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pDynamicTexture;
-
-        UINT const Subresource = 0; /* Screen target surfaces have only one subresource. */
+            pMappedTexture = pBackendSurface->pDynamicTexture;
+
+        UINT const Subresource = 0;
         HRESULT hr = pDevice->pImmediateContext->Map(pMappedTexture, Subresource,
                                                      d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
@@ -2264 +2664 @@
     {
         UINT const Subresource = 0; /* Buffers have only one subresource. */
-        HRESULT hr = pDevice->pImmediateContext->Map(pSurface->pBackendSurface->u.Buffer.pBuffer, Subresource,
+        HRESULT hr = pDevice->pImmediateContext->Map(pSurface->pBackendSurface->u.pBuffer, Subresource,
                                                      d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
         if (SUCCEEDED(hr))
@@ -2293 +2693 @@
 
 
-static DECLCALLBACK(int) vmsvga3dSurfaceUnmap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, VMSVGA3D_MAPPED_SURFACE *pMap, bool fWritten)
+static DECLCALLBACK(int) vmsvga3dBackSurfaceUnmap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, VMSVGA3D_MAPPED_SURFACE *pMap, bool fWritten)
 {
     PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
@@ -2309 +2709 @@
     AssertReturn(pBackendSurface, VERR_INVALID_PARAMETER);
 
-    PVMSVGA3DDXCONTEXT pDXContext;
-    /* Figure out whether the surface belongs to a DXContext or to the backend. */
-    if (pSurface->idAssociatedContext != SVGA_ID_INVALID)
-        vmsvga3dDXContextFromCid(pState, pSurface->idAssociatedContext, &pDXContext);
-    else
-        pDXContext = NULL;
-
-    DXDEVICE *pDevice;
-    if (pDXContext)
-        pDevice = &pDXContext->pBackendDXContext->device;
-    else
-        pDevice = &pBackend->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+    PVMSVGA3DMIPMAPLEVEL pMipLevel;
+    rc = vmsvga3dMipmapLevel(pSurface, pImage->face, pImage->mipmap, &pMipLevel);
+    ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+    /* A surface is always mapped by the DX context which has created the surface. */
+    DXDEVICE *pDevice = dxDeviceFromCid(pSurface->idAssociatedContext, pState);
+    AssertReturn(pDevice && pDevice->pDevice, VERR_INVALID_STATE);
 
     if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
@@ -2327 +2721 @@
         ID3D11Texture2D *pMappedTexture;
         if (pMap->enmMapType == VMSVGA3D_SURFACE_MAP_READ)
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pStagingTexture;
+            pMappedTexture = pBackendSurface->pStagingTexture;
         else
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pDynamicTexture;
+            pMappedTexture = pBackendSurface->pDynamicTexture;
 
         UINT const Subresource = 0; /* Screen target surfaces have only one subresource. */
@@ -2339 +2733 @@
                 || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE_DISCARD))
         {
-            ID3D11Resource *pDstResource = pBackendSurface->u.ScreenTarget.pTexture;
+            ID3D11Resource *pDstResource = pBackendSurface->u.pTexture2D;
             UINT DstSubresource = Subresource;
             UINT DstX = pMap->box.x;
             UINT DstY = pMap->box.y;
             UINT DstZ = pMap->box.z;
-            ID3D11Resource *pSrcResource = pBackendSurface->u.ScreenTarget.pDynamicTexture;
+            ID3D11Resource *pSrcResource = pBackendSurface->pDynamicTexture;
             UINT SrcSubresource = Subresource;
             D3D11_BOX SrcBox;
@@ -2353 +2747 @@
             SrcBox.bottom = pMap->box.y + pMap->box.h;
             SrcBox.back   = pMap->box.z + pMap->box.d;
+
             pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
                                                               pSrcResource, SrcSubresource, &SrcBox);
+
+            pBackendSurface->cidDrawing = pSurface->idAssociatedContext;
         }
     }
-    else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE)
+    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_CUBE_TEXTURE
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
     {
         ID3D11Texture2D *pMappedTexture;
         if (pMap->enmMapType == VMSVGA3D_SURFACE_MAP_READ)
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pStagingTexture;
+            pMappedTexture = pBackendSurface->pStagingTexture;
         else
-            pMappedTexture = pBackendSurface->u.ScreenTarget.pDynamicTexture;
-
-        UINT const Subresource = 0; /* Screen target surfaces have only one subresource. */
+            pMappedTexture = pBackendSurface->pDynamicTexture;
+
+        UINT const Subresource = 0; /* Staging or dynamic textures have one subresource. */
         pDevice->pImmediateContext->Unmap(pMappedTexture, Subresource);
 
@@ -2373 +2772 @@
                 || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE_DISCARD))
         {
-            ID3D11Resource *pDstResource = pBackendSurface->u.ScreenTarget.pTexture;
-            UINT DstSubresource = Subresource;
+            ID3D11Resource *pDstResource = pBackendSurface->u.pTexture2D;
+            UINT DstSubresource = D3D11CalcSubresource(pImage->mipmap, pImage->face, pSurface->cLevels);
             UINT DstX = pMap->box.x;
             UINT DstY = pMap->box.y;
             UINT DstZ = pMap->box.z;
-            ID3D11Resource *pSrcResource = pBackendSurface->u.ScreenTarget.pDynamicTexture;
+            ID3D11Resource *pSrcResource = pBackendSurface->pDynamicTexture;
             UINT SrcSubresource = Subresource;
             D3D11_BOX SrcBox;
@@ -2387 +2786 @@
             SrcBox.bottom = pMap->box.y + pMap->box.h;
             SrcBox.back   = pMap->box.z + pMap->box.d;
+
             pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
                                                               pSrcResource, SrcSubresource, &SrcBox);
+
+            pBackendSurface->cidDrawing = pSurface->idAssociatedContext;
         }
     }
@@ -2394 +2796 @@
     {
         UINT const Subresource = 0; /* Buffers have only one subresource. */
-        pDevice->pImmediateContext->Unmap(pBackendSurface->u.Buffer.pBuffer, Subresource);
+        pDevice->pImmediateContext->Unmap(pBackendSurface->u.pBuffer, Subresource);
     }
     else
@@ -2487 +2889 @@
     ASSERT_GUEST_RETURN(clipRect.w && clipRect.h, VERR_INVALID_PARAMETER);
 
+    /* Wait for the surface to finish drawing. */
+    if (pBackendSurface->cidDrawing != SVGA_ID_INVALID)
+    {
+        dxContextWait(pBackendSurface->cidDrawing, pState);
+        pBackendSurface->cidDrawing = SVGA_ID_INVALID;
+    }
+
     /* Copy the screen texture to the shared surface. */
     DWORD result = pHwScreen->pDXGIKeyedMutex->AcquireSync(0, 10000);
     if (result == WAIT_OBJECT_0)
     {
-        ID3D11Query *pQuery = 0;
-        D3D11_QUERY_DESC qd;
-        RT_ZERO(qd);
-        qd.Query = D3D11_QUERY_EVENT;
-        HRESULT hr2 = pBackend->device.pDevice->CreateQuery(&qd, &pQuery);
-        Assert(hr2 == S_OK); RT_NOREF(hr2);
-
-        pBackend->device.pImmediateContext->CopyResource(pHwScreen->pTexture, pBackendSurface->u.ScreenTarget.pTexture);
-
-        pBackend->device.pImmediateContext->Flush();
-
-        pBackend->device.pImmediateContext->End(pQuery);
-
-        BOOL queryData;
-        while (pBackend->device.pImmediateContext->GetData(pQuery, &queryData, sizeof(queryData), 0) != S_OK)
-        {
-            RTThreadYield();
-        }
-        D3D_RELEASE(pQuery);
+        pBackend->device.pImmediateContext->CopyResource(pHwScreen->pTexture, pBackendSurface->u.pTexture2D);
+
+        dxDeviceFlush(&pBackend->device);
 
         result = pHwScreen->pDXGIKeyedMutex->ReleaseSync(1);
@@ -3097 +3490 @@
                                uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
 {
-    RT_NOREF(dest, src, cCopyBoxes, pBox);
+    RT_NOREF(cCopyBoxes, pBox);
+
+    LogFunc(("src sid %d -> dst sid %d\n", src.sid, dest.sid));
 
     PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_INVALID_STATE);
 
-    AssertFailed();
-    return VERR_NOT_IMPLEMENTED;
+    PVMSVGA3DBACKEND pBackend = pState->pBackend;
+
+    PVMSVGA3DSURFACE pSrcSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, src.sid, &pSrcSurface);
+    AssertRCReturn(rc, rc);
+
+    PVMSVGA3DSURFACE pDstSurface;
+    rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, dest.sid, &pDstSurface);
+    AssertRCReturn(rc, rc);
+
+    LogFunc(("src%s cid %d -> dst%s cid %d\n",
+             pSrcSurface->pBackendSurface ? "" : " sysmem",
+             pSrcSurface ? pSrcSurface->idAssociatedContext : SVGA_ID_INVALID,
+             pDstSurface->pBackendSurface ? "" : " sysmem",
+             pDstSurface ? pDstSurface->idAssociatedContext : SVGA_ID_INVALID));
+
+    //DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    //AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    if (pSrcSurface->pBackendSurface)
+    {
+        if (pDstSurface->pBackendSurface == NULL)
+        {
+            /* Create the target if it can be used as a device context shared resource (render or screen target). */
+            if (dxIsSurfaceShareable(pDstSurface))
+            {
+                rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, NULL, pDstSurface);
+                AssertRCReturn(rc, rc);
+            }
+        }
+
+        if (pDstSurface->pBackendSurface)
+        {
+            /* Surface -> Surface. */
+            /* Expect both of them to be shared surfaces created by the backend context. */
+            Assert(pSrcSurface->idAssociatedContext == DX_CID_BACKEND && pDstSurface->idAssociatedContext == DX_CID_BACKEND);
+
+            DXDEVICE *pDXDevice = &pBackend->device;
+
+            /* Clip the box. */
+            PVMSVGA3DMIPMAPLEVEL pSrcMipLevel;
+            rc = vmsvga3dMipmapLevel(pSrcSurface, src.face, src.mipmap, &pSrcMipLevel);
+            ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+            PVMSVGA3DMIPMAPLEVEL pDstMipLevel;
+            rc = vmsvga3dMipmapLevel(pDstSurface, dest.face, dest.mipmap, &pDstMipLevel);
+            ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+            SVGA3dCopyBox clipBox = *pBox;
+            vmsvgaR3ClipCopyBox(&pSrcMipLevel->mipmapSize, &pDstMipLevel->mipmapSize, &clipBox);
+
+            UINT DstSubresource = vmsvga3dCalcSubresource(dest.mipmap, dest.face, pDstSurface->cLevels);
+            UINT DstX = clipBox.x;
+            UINT DstY = clipBox.y;
+            UINT DstZ = clipBox.z;
+
+            UINT SrcSubresource = vmsvga3dCalcSubresource(src.mipmap, src.face, pSrcSurface->cLevels);
+            D3D11_BOX SrcBox;
+            SrcBox.left   = clipBox.srcx;
+            SrcBox.top    = clipBox.srcy;
+            SrcBox.front  = clipBox.srcz;
+            SrcBox.right  = clipBox.srcx + clipBox.w;
+            SrcBox.bottom = clipBox.srcy + clipBox.h;
+            SrcBox.back   = clipBox.srcz + clipBox.d;
+
+            Assert(cCopyBoxes == 1); /** @todo */
+
+            ID3D11Resource *pDstResource;
+            ID3D11Resource *pSrcResource;
+            pDstResource = dxResource(pState, pDstSurface, NULL);
+            pSrcResource = dxResource(pState, pSrcSurface, NULL);
+
+            pDXDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
+                                                                pSrcResource, SrcSubresource, &SrcBox);
+
+            pDstSurface->pBackendSurface->cidDrawing = DX_CID_BACKEND;
+        }
+        else
+        {
+            /* Surface -> Memory. */
+            AssertFailed(); /** @todo implement */
+        }
+    }
+    else
+    {
+        /* Memory -> Surface. */
+        AssertFailed(); /** @todo implement */
+    }
+
+    return rc;
 }
 
@@ -3405 +3888 @@
     pSurface->pBackendSurface = NULL;
 
+    LogFunc(("sid=%u\n", pSurface->id));
+
     if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
     {
-        D3D_RELEASE(pBackendSurface->u.ScreenTarget.pStagingTexture);
-        D3D_RELEASE(pBackendSurface->u.ScreenTarget.pDynamicTexture);
-        D3D_RELEASE(pBackendSurface->u.ScreenTarget.pTexture);
-    }
-    else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE)
-    {
-        D3D_RELEASE(pBackendSurface->u.Texture.pStagingTexture);
-        D3D_RELEASE(pBackendSurface->u.Texture.pDynamicTexture);
-        D3D_RELEASE(pBackendSurface->u.Texture.pTexture);
+        D3D_RELEASE(pBackendSurface->pStagingTexture);
+        D3D_RELEASE(pBackendSurface->pDynamicTexture);
+        D3D_RELEASE(pBackendSurface->u.pTexture2D);
+    }
+    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_CUBE_TEXTURE)
+    {
+        D3D_RELEASE(pBackendSurface->pStagingTexture);
+        D3D_RELEASE(pBackendSurface->pDynamicTexture);
+        D3D_RELEASE(pBackendSurface->u.pTexture2D);
+    }
+    else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
+    {
+        D3D_RELEASE(pBackendSurface->pStagingTexture3D);
+        D3D_RELEASE(pBackendSurface->pDynamicTexture3D);
+        D3D_RELEASE(pBackendSurface->u.pTexture3D);
     }
     else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_BUFFER)
     {
-        D3D_RELEASE(pBackendSurface->u.Buffer.pBuffer);
+        D3D_RELEASE(pBackendSurface->u.pBuffer);
     }
     else
@@ -3427 +3919 @@
 
     RTMemFree(pBackendSurface);
+
+    /* No context has created the surface, because the surface does not exist anymore. */
+    pSurface->idAssociatedContext = SVGA_ID_INVALID;
 }
 
@@ -3525 +4020 @@
 
         VMSVGA3D_MAPPED_SURFACE map;
-        rc = vmsvga3dSurfaceMap(pThisCC, pSurface->idAssociatedContext, &image, &box, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &map);
+        rc = vmsvga3dBackSurfaceMap(pThisCC, &image, &box, VMSVGA3D_SURFACE_MAP_WRITE_DISCARD, &map);
         if (RT_SUCCESS(rc))
         {
@@ -3553 +4048 @@
             //vmsvga3dMapWriteBmpFile(&map, "Dynamic");
 
-            vmsvga3dSurfaceUnmap(pThisCC, &image, &map, /* fWritten = */ true);
+            vmsvga3dBackSurfaceUnmap(pThisCC, &image, &map, /* fWritten = */ true);
         }
 #if 0
 //ASMBreakpoint();
-            rc = vmsvga3dSurfaceMap(pThisCC, &image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
+            rc = vmsvga3dBackSurfaceMap(pThisCC, &image, NULL, VMSVGA3D_SURFACE_MAP_READ, &map);
             if (RT_SUCCESS(rc))
             {
                 vmsvga3dMapWriteBmpFile(&map, "Staging");
 
-                vmsvga3dSurfaceUnmap(pThisCC, &image, &map, /* fWritten =  */ false);
+                vmsvga3dBackSurfaceUnmap(pThisCC, &image, &map, /* fWritten =  */ false);
             }
 #endif
@@ -3604 +4099 @@
 
         VMSVGA3D_MAPPED_SURFACE map;
-        rc = vmsvga3dSurfaceMap(pThisCC, pSurface->idAssociatedContext, &image, &box, enmMap, &map);
+        rc = vmsvga3dBackSurfaceMap(pThisCC, &image, &box, enmMap, &map);
         if (RT_SUCCESS(rc))
         {
@@ -3629 +4124 @@
 
             bool const fWritten = (transfer == SVGA3D_WRITE_HOST_VRAM);
-            vmsvga3dSurfaceUnmap(pThisCC, &image, &map, fWritten);
+            vmsvga3dBackSurfaceUnmap(pThisCC, &image, &map, fWritten);
         }
     }
@@ -3717 +4212 @@
     pDXContext->pBackendDXContext = pBackendDXContext;
 
+    LogFunc(("cid %d\n", pDXContext->cid));
+
     int rc = dxDeviceCreate(pBackend, &pBackendDXContext->device);
     return rc;
@@ -3726 +4223 @@
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
 
+    LogFunc(("cid %d\n", pDXContext->cid));
+
     if (pDXContext->pBackendDXContext)
     {
-        dxDeviceDestroy(pBackend, &pDXContext->pBackendDXContext->device);
-
-        RTMemFree(pDXContext->pBackendDXContext);
+        /* Clean up context resources. */
+        VMSVGA3DBACKENDDXCONTEXT *pBackendDXContext = pDXContext->pBackendDXContext;
+
+        if (pBackendDXContext->papRenderTargetView)
+            DX_RELEASE_ARRAY(pBackendDXContext->cRenderTargetView, pBackendDXContext->papRenderTargetView);
+        if (pBackendDXContext->papDepthStencilView)
+            DX_RELEASE_ARRAY(pBackendDXContext->cDepthStencilView, pBackendDXContext->papDepthStencilView);
+        if (pBackendDXContext->papShaderResourceView)
+            DX_RELEASE_ARRAY(pBackendDXContext->cShaderResourceView, pBackendDXContext->papShaderResourceView);
+        if (pBackendDXContext->paElementLayout)
+        {
+            for (uint32_t i = 0; i < pBackendDXContext->cElementLayout; ++i)
+                D3D_RELEASE(pBackendDXContext->paElementLayout[i].pElementLayout);
+        }
+        if (pBackendDXContext->papBlendState)
+            DX_RELEASE_ARRAY(pBackendDXContext->cBlendState, pBackendDXContext->papBlendState);
+        if (pBackendDXContext->papDepthStencilState)
+            DX_RELEASE_ARRAY(pBackendDXContext->cDepthStencilState, pBackendDXContext->papDepthStencilState);
+        if (pBackendDXContext->papRasterizerState)
+            DX_RELEASE_ARRAY(pBackendDXContext->cRasterizerState, pBackendDXContext->papRasterizerState);
+        if (pBackendDXContext->papSamplerState)
+            DX_RELEASE_ARRAY(pBackendDXContext->cSamplerState, pBackendDXContext->papSamplerState);
+        if (pBackendDXContext->papQuery)
+            DX_RELEASE_ARRAY(pBackendDXContext->cQuery, pBackendDXContext->papQuery);
+        if (pBackendDXContext->paShader)
+        {
+            for (uint32_t i = 0; i < pBackendDXContext->cShader; ++i)
+                D3D_RELEASE(pBackendDXContext->paShader[i].pShader);
+        }
+
+        RTMemFreeZ(pBackendDXContext->papBlendState, sizeof(pBackendDXContext->papBlendState[0]) * pBackendDXContext->cBlendState);
+        RTMemFreeZ(pBackendDXContext->papDepthStencilState, sizeof(pBackendDXContext->papDepthStencilState[0]) * pBackendDXContext->cDepthStencilState);
+        RTMemFreeZ(pBackendDXContext->papSamplerState, sizeof(pBackendDXContext->papSamplerState[0]) * pBackendDXContext->cSamplerState);
+        RTMemFreeZ(pBackendDXContext->papRasterizerState, sizeof(pBackendDXContext->papRasterizerState[0]) * pBackendDXContext->cRasterizerState);
+        RTMemFreeZ(pBackendDXContext->paElementLayout, sizeof(pBackendDXContext->paElementLayout[0]) * pBackendDXContext->cElementLayout);
+        RTMemFreeZ(pBackendDXContext->papRenderTargetView, sizeof(pBackendDXContext->papRenderTargetView[0]) * pBackendDXContext->cRenderTargetView);
+        RTMemFreeZ(pBackendDXContext->papDepthStencilView, sizeof(pBackendDXContext->papDepthStencilView[0]) * pBackendDXContext->cDepthStencilView);
+        RTMemFreeZ(pBackendDXContext->papShaderResourceView, sizeof(pBackendDXContext->papShaderResourceView[0]) * pBackendDXContext->cShaderResourceView);
+        RTMemFreeZ(pBackendDXContext->papQuery, sizeof(pBackendDXContext->papQuery[0]) * pBackendDXContext->cQuery);
+        RTMemFreeZ(pBackendDXContext->paShader, sizeof(pBackendDXContext->paShader[0]) * pBackendDXContext->cShader);
+
+        /* Destroy backend surfaces which belong to this context. */
+        /** @todo The context should have a list of surfaces (and also shared resources). */
+        for (uint32_t sid = 0; sid < pThisCC->svga.p3dState->cSurfaces; ++sid)
+        {
+            PVMSVGA3DSURFACE const pSurface = pThisCC->svga.p3dState->papSurfaces[sid];
+            if (   pSurface
+                && pSurface->id == sid)
+            {
+                if (pSurface->idAssociatedContext == pDXContext->cid)
+                {
+                    Assert(pSurface->pBackendSurface);
+                    vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
+                }
+                else if (pSurface->idAssociatedContext == DX_CID_BACKEND)
+                {
+                    /* May have shared resources in this context. */
+                    Assert(pSurface->pBackendSurface);
+                    DXSHAREDTEXTURE *pSharedTexture = (DXSHAREDTEXTURE *)RTAvlU32Get(&pSurface->pBackendSurface->SharedTextureTree, pDXContext->cid);
+                    if (pSharedTexture)
+                    {
+                        Assert(pSharedTexture->sid == sid);
+                        RTAvlU32Remove(&pSurface->pBackendSurface->SharedTextureTree, pDXContext->cid);
+                        D3D_RELEASE(pSharedTexture->pTexture);
+                        RTMemFreeZ(pSharedTexture, sizeof(*pSharedTexture));
+                    }
+                }
+            }
+        }
+
+        dxDeviceDestroy(pBackend, &pBackendDXContext->device);
+
+        RTMemFreeZ(pBackendDXContext, sizeof(*pBackendDXContext));
         pDXContext->pBackendDXContext = NULL;
     }
@@ -3748 +4317 @@
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
+    RT_NOREF(pBackend, pDXContext);
+    return VINF_SUCCESS;
 }
 
@@ -3815 +4382 @@
         boxDst.d = 1;
 
-        rc = vmsvgaR3UpdateGBSurfaceEx(pThisCC, pDXContext->cid, &imageId, &boxDst, &ptSrc);
+        rc = vmsvgaR3UpdateGBSurfaceEx(pThisCC, &imageId, &boxDst, &ptSrc);
         AssertRCReturn(rc, rc);
     }
 
-    dxConstantBufferSet(pDevice, slot, type, pSurface->pBackendSurface->u.Buffer.pBuffer);
+    dxConstantBufferSet(pDevice, slot, type, pSurface->pBackendSurface->u.pBuffer);
     return VINF_SUCCESS;
 }
@@ -3865 +4432 @@
     {
         pDXShader = &pDXContext->pBackendDXContext->paShader[pShader->id];
+        Assert(pDXShader->enmShaderType >= SVGA3D_SHADERTYPE_MIN && pDXShader->enmShaderType < SVGA3D_SHADERTYPE_MAX);
         uint32_t const idxShaderState = pDXShader->enmShaderType - SVGA3D_SHADERTYPE_MIN;
         pDXContext->svgaDXContext.shaderState[idxShaderState].shaderId = pShader->id;
@@ -3980 +4548 @@
     }
 
+    /* Note which surfaces are being drawn. */
+    dxTrackRenderTargets(pThisCC, pDXContext);
+
     return VINF_SUCCESS;
 }
@@ -3995 +4566 @@
 
     pDevice->pImmediateContext->DrawIndexed(indexCount, startIndexLocation, baseVertexLocation);
+
+    /* Note which surfaces are being drawn. */
+    dxTrackRenderTargets(pThisCC, pDXContext);
+
     return VINF_SUCCESS;
 }
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDrawInstanced(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
+static DECLCALLBACK(int) vmsvga3dBackDXDrawInstanced(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
+                                                     uint32_t vertexCountPerInstance, uint32_t instanceCount, uint32_t startVertexLocation, uint32_t startInstanceLocation)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
     Assert(pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN);
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXDrawIndexedInstanced(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
+
+    pDevice->pImmediateContext->DrawInstanced(vertexCountPerInstance, instanceCount, startVertexLocation, startInstanceLocation);
+
+    /* Note which surfaces are being drawn. */
+    dxTrackRenderTargets(pThisCC, pDXContext);
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDrawIndexedInstanced(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
+                                                            uint32_t indexCountPerInstance, uint32_t instanceCount, uint32_t startIndexLocation, int32_t baseVertexLocation, uint32_t startInstanceLocation)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
     Assert(pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN);
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
+
+    pDevice->pImmediateContext->DrawIndexedInstanced(indexCountPerInstance, instanceCount, startIndexLocation, baseVertexLocation, startInstanceLocation);
+
+    /* Note which surfaces are being drawn. */
+    dxTrackRenderTargets(pThisCC, pDXContext);
+
+    return VINF_SUCCESS;
 }
 
@@ -4119 +4712 @@
                 box.d = 1;
 
-                rc = vmsvgaR3UpdateGBSurface(pThisCC, pDXContext->cid, &imageId, &box);
+                rc = vmsvgaR3UpdateGBSurface(pThisCC, &imageId, &box);
                 AssertRCReturn(rc, rc);
             }
 
-            paResources[idxVertexBuffer] = pSurface->pBackendSurface->u.Buffer.pBuffer;
+            paResources[idxVertexBuffer] = pSurface->pBackendSurface->u.pBuffer;
             paStride[idxVertexBuffer] = paVertexBuffer[i].stride;
             paOffset[idxVertexBuffer] = paVertexBuffer[i].offset;
@@ -4139 +4732 @@
     }
 
-    pDevice->pImmediateContext->IASetVertexBuffers(startBuffer, cVertexBuffer, paResources, paStride, paOffset);
+    pDevice->pImmediateContext->IASetVertexBuffers(startBuffer, cVertexBuffer,
+                                                   &paResources[startBuffer], &paStride[startBuffer], &paOffset[startBuffer]);
 
     return VINF_SUCCESS;
@@ -4186 +4780 @@
             box.d = 1;
 
-            rc = vmsvgaR3UpdateGBSurface(pThisCC, pDXContext->cid, &imageId, &box);
+            rc = vmsvgaR3UpdateGBSurface(pThisCC, &imageId, &box);
             AssertRCReturn(rc, rc);
         }
 
-        pResource = pSurface->pBackendSurface->u.Buffer.pBuffer;
+        pResource = pSurface->pBackendSurface->u.pBuffer;
         enmDxgiFormat = vmsvgaDXSurfaceFormat2Dxgi(format);
         AssertReturn(enmDxgiFormat == DXGI_FORMAT_R16_UINT || enmDxgiFormat == DXGI_FORMAT_R32_UINT, VERR_INVALID_PARAMETER);
@@ -4539 +5133 @@
              (pDstSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET) ? " st" : ""));
 
+    /* Clip the box. */
+    /** @todo Use [src|dst]SubResource to index p[Src|Dst]Surface->paMipmapLevels array directly. */
+    uint32_t iSrcFace;
+    uint32_t iSrcMipmap;
+    vmsvga3dCalcMipmapAndFace(pSrcSurface->cLevels, srcSubResource, &iSrcMipmap, &iSrcFace);
+
+    uint32_t iDstFace;
+    uint32_t iDstMipmap;
+    vmsvga3dCalcMipmapAndFace(pDstSurface->cLevels, dstSubResource, &iDstMipmap, &iDstFace);
+
+    PVMSVGA3DMIPMAPLEVEL pSrcMipLevel;
+    rc = vmsvga3dMipmapLevel(pSrcSurface, iSrcFace, iSrcMipmap, &pSrcMipLevel);
+    ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+    PVMSVGA3DMIPMAPLEVEL pDstMipLevel;
+    rc = vmsvga3dMipmapLevel(pDstSurface, iDstFace, iDstMipmap, &pDstMipLevel);
+    ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+    SVGA3dCopyBox clipBox = *pBox;
+    vmsvgaR3ClipCopyBox(&pSrcMipLevel->mipmapSize, &pDstMipLevel->mipmapSize, &clipBox);
+
     UINT DstSubresource = dstSubResource;
-    UINT DstX = pBox->x;
-    UINT DstY = pBox->y;
-    UINT DstZ = pBox->z;
+    UINT DstX = clipBox.x;
+    UINT DstY = clipBox.y;
+    UINT DstZ = clipBox.z;
 
     UINT SrcSubresource = srcSubResource;
     D3D11_BOX SrcBox;
-    SrcBox.left   = pBox->x;
-    SrcBox.top    = pBox->y;
-    SrcBox.front  = pBox->z;
-    SrcBox.right  = pBox->x + pBox->w;
-    SrcBox.bottom = pBox->y + pBox->h;
-    SrcBox.back   = pBox->z + pBox->d;
+    SrcBox.left   = clipBox.srcx;
+    SrcBox.top    = clipBox.srcy;
+    SrcBox.front  = clipBox.srcz;
+    SrcBox.right  = clipBox.srcx + clipBox.w;
+    SrcBox.bottom = clipBox.srcy + clipBox.h;
+    SrcBox.back   = clipBox.srcz + clipBox.d;
 
     ID3D11Resource *pDstResource;
     ID3D11Resource *pSrcResource;
 
-    if (pDstSurface->idAssociatedContext == pSrcSurface->idAssociatedContext)
-    {
-        /* Use the context which created the surfaces. */
-        if (pSrcSurface->idAssociatedContext != SVGA_ID_INVALID)
-        {
-            /* One of DXContexts has created the resources. */
-            if (pDXContext->cid != pSrcSurface->idAssociatedContext)
-            {
-                /** @todo test */
-                /* Get the context which has created the surfaces. */
-                rc = vmsvga3dDXContextFromCid(pThisCC->svga.p3dState, pSrcSurface->idAssociatedContext, &pDXContext);
-                AssertRCReturn(rc, rc);
-
-                pDevice = &pDXContext->pBackendDXContext->device;
-                AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-            }
-
-            pDstResource = dxResource(pDstSurface, pDXContext);
-            pSrcResource = dxResource(pSrcSurface, pDXContext);
-            pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
-                                                              pSrcResource, SrcSubresource, &SrcBox);
-        }
-        else
-        {
-            /* Backend context has created the resources. */
-            pDstResource = pDstSurface->pBackendSurface->u.Resource.pResource;
-            pSrcResource = pSrcSurface->pBackendSurface->u.Resource.pResource;
-            pBackend->device.pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
-                                                                      pSrcResource, SrcSubresource, &SrcBox);
-        }
-    }
-    else
-    {
-        /* Different contexts. */
-
-        /* One of the surfaces must be shared. */
-        AssertReturn(   pSrcSurface->idAssociatedContext == SVGA_ID_INVALID
-                     || pDstSurface->idAssociatedContext == SVGA_ID_INVALID, VERR_NOT_SUPPORTED);
-
-        /* Use a context which created the not shared resource to do the copy. */
-        if (pSrcSurface->idAssociatedContext == SVGA_ID_INVALID)
-        {
-            if (pDXContext->cid != pDstSurface->idAssociatedContext)
-            {
-                /* Get the context which has created the destination resource. */
-                rc = vmsvga3dDXContextFromCid(pThisCC->svga.p3dState, pDstSurface->idAssociatedContext, &pDXContext);
-                AssertRCReturn(rc, rc);
-
-                pDevice = &pDXContext->pBackendDXContext->device;
-                AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-            }
-
-            pDstResource = dxResource(pDstSurface, pDXContext);
-            pSrcResource = dxResource(pSrcSurface, pDXContext);
-            pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
-                                                              pSrcResource, SrcSubresource, &SrcBox);
-        }
-        else if (pDstSurface->idAssociatedContext == SVGA_ID_INVALID)
-        {
-            if (pDXContext->cid != pSrcSurface->idAssociatedContext)
-            {
-                /* Get the context which has created the source surface. */
-                rc = vmsvga3dDXContextFromCid(pThisCC->svga.p3dState, pSrcSurface->idAssociatedContext, &pDXContext);
-                AssertRCReturn(rc, rc);
-
-                pDevice = &pDXContext->pBackendDXContext->device;
-                AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-            }
-
-            pDstResource = dxResource(pDstSurface, pDXContext);
-            pSrcResource = dxResource(pSrcSurface, pDXContext);
-            pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
-                                                              pSrcResource, SrcSubresource, &SrcBox);
-        }
-        else
-        {
-            AssertFailedReturn(VERR_NOT_SUPPORTED);
-        }
-    }
+    pDstResource = dxResource(pThisCC->svga.p3dState, pDstSurface, pDXContext);
+    pSrcResource = dxResource(pThisCC->svga.p3dState, pSrcSurface, pDXContext);
+
+    pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
+                                                      pSrcResource, SrcSubresource, &SrcBox);
+
+    pDstSurface->pBackendSurface->cidDrawing = pDXContext->cid;
     return VINF_SUCCESS;
 }
@@ -4674 +5217 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXUpdateSubResource(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXReadbackSubResource(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXInvalidateSubResource(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXDefineShaderResourceView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId, SVGACOTableDXSRViewEntry const *pEntry)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    RT_NOREF(pBackend);
-
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-
+static int dxDefineShaderResourceView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId, SVGACOTableDXSRViewEntry const *pEntry)
+{
     /* Get corresponding resource for pEntry->sid. Create the surface if does not yet exist. */
     PVMSVGA3DSURFACE pSurface;
@@ -4724 +5231 @@
     }
 
-    HRESULT hr = dxShaderResourceViewCreate(pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papShaderResourceView[shaderResourceViewId]);
+    HRESULT hr = dxShaderResourceViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papShaderResourceView[shaderResourceViewId]);
     if (SUCCEEDED(hr))
         return VINF_SUCCESS;
@@ -4731 +5238 @@
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXDefineShaderResourceView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId, SVGACOTableDXSRViewEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    return dxDefineShaderResourceView(pThisCC, pDXContext, shaderResourceViewId, pEntry);
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXDestroyShaderResourceView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId)
 {
@@ -4741 +5260 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineRenderTargetView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRenderTargetViewId renderTargetViewId, SVGACOTableDXRTViewEntry const *pEntry)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    RT_NOREF(pBackend);
-
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-
+static int dxDefineRenderTargetView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRenderTargetViewId renderTargetViewId, SVGACOTableDXRTViewEntry const *pEntry)
+{
     /* Get corresponding resource for pEntry->sid. Create the surface if does not yet exist. */
     PVMSVGA3DSURFACE pSurface;
@@ -4761 +5274 @@
     }
 
-    HRESULT hr = dxRenderTargetViewCreate(pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papRenderTargetView[renderTargetViewId]);
+    HRESULT hr = dxRenderTargetViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papRenderTargetView[renderTargetViewId]);
     if (SUCCEEDED(hr))
         return VINF_SUCCESS;
+
     return VERR_INVALID_STATE;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDefineRenderTargetView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRenderTargetViewId renderTargetViewId, SVGACOTableDXRTViewEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    return dxDefineRenderTargetView(pThisCC, pDXContext, renderTargetViewId, pEntry);
 }
 
@@ -4778 +5304 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineDepthStencilView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilViewId depthStencilViewId, SVGACOTableDXDSViewEntry const *pEntry)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    RT_NOREF(pBackend);
-
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-
+static int dxDefineDepthStencilView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilViewId depthStencilViewId, SVGACOTableDXDSViewEntry const *pEntry)
+{
     /* Get corresponding resource for pEntry->sid. Create the surface if does not yet exist. */
     PVMSVGA3DSURFACE pSurface;
@@ -4791 +5311 @@
     AssertRCReturn(rc, rc);
 
+    if (   pSurface->pBackendSurface != NULL
+        && pDXContext->cid != pSurface->idAssociatedContext)
+    {
+        /* Supposed to be per context. */
+//AssertFailed(); // test
+        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
+    }
+
     if (pSurface->pBackendSurface == NULL)
     {
@@ -4798 +5326 @@
     }
 
-    HRESULT hr = dxDepthStencilViewCreate(pDevice, pEntry, pSurface->pBackendSurface, &pDXContext->pBackendDXContext->papDepthStencilView[depthStencilViewId]);
+    HRESULT hr = dxDepthStencilViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papDepthStencilView[depthStencilViewId]);
     if (SUCCEEDED(hr))
         return VINF_SUCCESS;
@@ -4804 +5332 @@
 }
 
+static DECLCALLBACK(int) vmsvga3dBackDXDefineDepthStencilView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilViewId depthStencilViewId, SVGACOTableDXDSViewEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    return dxDefineDepthStencilView(pThisCC, pDXContext, depthStencilViewId, pEntry);
+}
+
 
 static DECLCALLBACK(int) vmsvga3dBackDXDestroyDepthStencilView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilViewId depthStencilViewId)
@@ -4815 +5354 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineElementLayout(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dElementLayoutId elementLayoutId, SVGACOTableDXElementLayoutEntry const *pEntry)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
-    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-
-    RT_NOREF(pBackend, elementLayoutId, pEntry);
-
-    /* Not much can be done here because ID3D11Device::CreateInputLayout requires
-     * a pShaderBytecodeWithInputSignature which is not known at this moment.
-     * InputLayout object will be created in SVGA_3D_CMD_DX_SET_INPUT_LAYOUT.
-     */
-
-    DXELEMENTLAYOUT *pDXElementLayout = &pDXContext->pBackendDXContext->paElementLayout[pEntry->elid];
+static int dxDefineElementLayout(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dElementLayoutId elementLayoutId, SVGACOTableDXElementLayoutEntry const *pEntry)
+{
+    DXELEMENTLAYOUT *pDXElementLayout = &pDXContext->pBackendDXContext->paElementLayout[elementLayoutId];
     D3D_RELEASE(pDXElementLayout->pElementLayout);
 
@@ -4860 +5388 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDestroyElementLayout(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXDefineBlendState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
-                                                        SVGA3dBlendStateId blendId, SVGACOTableDXBlendStateEntry const *pEntry)
+static DECLCALLBACK(int) vmsvga3dBackDXDefineElementLayout(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dElementLayoutId elementLayoutId, SVGACOTableDXElementLayoutEntry const *pEntry)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -4878 +5395 @@
 
     RT_NOREF(pBackend);
+
+    /* Not much can be done here because ID3D11Device::CreateInputLayout requires
+     * a pShaderBytecodeWithInputSignature which is not known at this moment.
+     * InputLayout object will be created in SVGA_3D_CMD_DX_SET_INPUT_LAYOUT.
+     */
+
+    Assert(elementLayoutId == pEntry->elid);
+
+    return dxDefineElementLayout(pDXContext, elementLayoutId, pEntry);
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDestroyElementLayout(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+
+    RT_NOREF(pBackend, pDXContext);
+    AssertFailed(); /** @todo Implement */
+    return VERR_NOT_IMPLEMENTED;
+}
+
+
+static int dxDefineBlendState(PVMSVGA3DDXCONTEXT pDXContext,
+                              SVGA3dBlendStateId blendId, SVGACOTableDXBlendStateEntry const *pEntry)
+{
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
     HRESULT hr = dxBlendStateCreate(pDevice, pEntry, &pDXContext->pBackendDXContext->papBlendState[blendId]);
@@ -4885 +5429 @@
 }
 
+static DECLCALLBACK(int) vmsvga3dBackDXDefineBlendState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
+                                                        SVGA3dBlendStateId blendId, SVGACOTableDXBlendStateEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    return dxDefineBlendState(pDXContext, blendId, pEntry);
+}
+
 
 static DECLCALLBACK(int) vmsvga3dBackDXDestroyBlendState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
@@ -4896 +5449 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineDepthStencilState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilStateId depthStencilId, SVGACOTableDXDepthStencilEntry *pEntry)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+static int dxDefineDepthStencilState(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilStateId depthStencilId, SVGACOTableDXDepthStencilEntry const *pEntry)
+{
     DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-
-    RT_NOREF(pBackend);
 
     HRESULT hr = dxDepthStencilStateCreate(pDevice, pEntry, &pDXContext->pBackendDXContext->papDepthStencilState[depthStencilId]);
@@ -4911 +5461 @@
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXDefineDepthStencilState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilStateId depthStencilId, SVGACOTableDXDepthStencilEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    return dxDefineDepthStencilState(pDXContext, depthStencilId, pEntry);
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXDestroyDepthStencilState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
@@ -4921 +5480 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineRasterizerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRasterizerStateId rasterizerId, SVGACOTableDXRasterizerStateEntry const *pEntry)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+static int dxDefineRasterizerState(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRasterizerStateId rasterizerId, SVGACOTableDXRasterizerStateEntry const *pEntry)
+{
     DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-
-    RT_NOREF(pBackend);
 
     HRESULT hr = dxRasterizerStateCreate(pDevice, pEntry, &pDXContext->pBackendDXContext->papRasterizerState[rasterizerId]);
@@ -4936 +5492 @@
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXDefineRasterizerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRasterizerStateId rasterizerId, SVGACOTableDXRasterizerStateEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    return dxDefineRasterizerState(pDXContext, rasterizerId, pEntry);
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXDestroyRasterizerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
@@ -4946 +5511 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineSamplerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dSamplerId samplerId, SVGACOTableDXSamplerEntry const *pEntry)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+static int dxDefineSamplerState(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dSamplerId samplerId, SVGACOTableDXSamplerEntry const *pEntry)
+{
     DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
-
-    RT_NOREF(pBackend);
 
     HRESULT hr = dxSamplerStateCreate(pDevice, pEntry, &pDXContext->pBackendDXContext->papSamplerState[samplerId]);
@@ -4961 +5523 @@
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXDefineSamplerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dSamplerId samplerId, SVGACOTableDXSamplerEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    return dxDefineSamplerState(pDXContext, samplerId, pEntry);
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXDestroySamplerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
@@ -4971 +5542 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
+
+static int dxDefineShader(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, SVGACOTableDXShaderEntry const *pEntry)
+{
+    DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
+    pDXShader->enmShaderType = pEntry->type;
+
+    PVMSVGA3DSHADER pShader = &pDXContext->paShader[shaderId];
+    pShader->u.pvBackendShader = pDXShader;
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDefineShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, SVGACOTableDXShaderEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
     RT_NOREF(pBackend);
 
-    DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[pShader->id];
+    DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
     D3D_RELEASE(pDXShader->pShader);
-    pDXShader->enmShaderType = pShader->type;
-    pShader->u.pvBackendShader = pDXShader;
-    return VINF_SUCCESS;
+
+    return dxDefineShader(pDXContext, shaderId, pEntry);
 }
 
@@ -5006 +5588 @@
 
     DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[pShader->id];
+    Assert(pDXShader->enmShaderType == pShader->type);
+
     if (pDXShader->pvDXBC)
     {
@@ -5055 +5639 @@
 
             HRESULT hr = dxShaderCreate(pDevice, pShader, pDXShader);
-            if (FAILED(hr))
+            if (SUCCEEDED(hr))
+            {
+            }
+            else
                 rc = VERR_INVALID_STATE;
         }
@@ -5096 +5683 @@
 
 
-static int dxCOTableRealloc(void **ppvCOTable, uint32_t *pcCOTable, uint32_t cbEntry, uint32_t cEntries, uint32_t cValidEntries)
+static int dxCOTableRealloc(void **ppvCOTable, uint32_t *pcCOTable, uint32_t cbEntry, uint32_t cEntries)
 {
     if (*pcCOTable != cEntries)
@@ -5105 +5692 @@
             void *pvNew = RTMemRealloc(*ppvCOTable, cEntries * cbEntry);
             AssertReturn(pvNew, VERR_NO_MEMORY);
-            memset((uint8_t *)pvNew + cValidEntries * cbEntry, 0, (cEntries - cValidEntries) * cbEntry);
             *ppvCOTable = pvNew;
         }
@@ -5117 +5703 @@
     }
 
+    if (*ppvCOTable)
+        memset(*ppvCOTable, 0, cEntries * cbEntry);
+
     return VINF_SUCCESS;
 }
 
-static DECLCALLBACK(int) vmsvga3dBackDXSetCOTable(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableType type, uint32_t cEntries, uint32_t cValidEntries)
+static DECLCALLBACK(int) vmsvga3dBackDXSetCOTable(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableType type, uint32_t cValidEntries)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -5129 +5718 @@
     int rc = VINF_SUCCESS;
 
-    /* Allocate paBlendState for example. */
-    /* Keep first cValidEntries. */
+    /*
+     * 1) Release current backend table, if exists;
+     * 2) Reallocate memory for the new backend table;
+     * 3) If cValidEntries is not zero, then re-define corresponding backend table elements.
+     */
     switch (type)
     {
         case SVGA_COTABLE_RTVIEW:
+            /* Clear current entries. */
             if (pBackendDXContext->papRenderTargetView)
+                DX_RELEASE_ARRAY(pBackendDXContext->cRenderTargetView, pBackendDXContext->papRenderTargetView);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papRenderTargetView, &pBackendDXContext->cRenderTargetView,
+                                  sizeof(pBackendDXContext->papRenderTargetView[0]), pDXContext->cot.cRTView);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cRenderTargetView - cValidEntries, &pBackendDXContext->papRenderTargetView[cValidEntries]);
+                SVGACOTableDXRTViewEntry const *pEntry = &pDXContext->cot.paRTView[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineRenderTargetView(pThisCC, pDXContext, i, pEntry);
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papRenderTargetView, &pBackendDXContext->cRenderTargetView,
-                                  sizeof(pBackendDXContext->papRenderTargetView[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_DSVIEW:
             if (pBackendDXContext->papDepthStencilView)
+                DX_RELEASE_ARRAY(pBackendDXContext->cDepthStencilView, pBackendDXContext->papDepthStencilView);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papDepthStencilView, &pBackendDXContext->cDepthStencilView,
+                                  sizeof(pBackendDXContext->papDepthStencilView[0]), pDXContext->cot.cDSView);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cDepthStencilView - cValidEntries, &pBackendDXContext->papDepthStencilView[cValidEntries]);
+                SVGACOTableDXDSViewEntry const *pEntry = &pDXContext->cot.paDSView[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineDepthStencilView(pThisCC, pDXContext, i, pEntry);
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papDepthStencilView, &pBackendDXContext->cDepthStencilView,
-                                  sizeof(pBackendDXContext->papDepthStencilView[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_SRVIEW:
             if (pBackendDXContext->papShaderResourceView)
+                DX_RELEASE_ARRAY(pBackendDXContext->cShaderResourceView, pBackendDXContext->papShaderResourceView);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papShaderResourceView, &pBackendDXContext->cShaderResourceView,
+                                  sizeof(pBackendDXContext->papShaderResourceView[0]), pDXContext->cot.cSRView);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cShaderResourceView - cValidEntries, &pBackendDXContext->papShaderResourceView[cValidEntries]);
+                SVGACOTableDXSRViewEntry const *pEntry = &pDXContext->cot.paSRView[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineShaderResourceView(pThisCC, pDXContext, i, pEntry);
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papShaderResourceView, &pBackendDXContext->cShaderResourceView,
-                                  sizeof(pBackendDXContext->papShaderResourceView[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_ELEMENTLAYOUT:
             if (pBackendDXContext->paElementLayout)
             {
-                /* Clear obsolete entries. */
-                for (uint32_t i = cValidEntries; i < pBackendDXContext->cElementLayout; ++i)
+                for (uint32_t i = 0; i < pBackendDXContext->cElementLayout; ++i)
                     D3D_RELEASE(pBackendDXContext->paElementLayout[i].pElementLayout);
             }
 
             rc = dxCOTableRealloc((void **)&pBackendDXContext->paElementLayout, &pBackendDXContext->cElementLayout,
-                                  sizeof(pBackendDXContext->paElementLayout[0]), cEntries, cValidEntries);
+                                  sizeof(pBackendDXContext->paElementLayout[0]), pDXContext->cot.cElementLayout);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
+            {
+                SVGACOTableDXElementLayoutEntry const *pEntry = &pDXContext->cot.paElementLayout[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineElementLayout(pDXContext, i, pEntry);
+            }
             break;
         case SVGA_COTABLE_BLENDSTATE:
             if (pBackendDXContext->papBlendState)
+                DX_RELEASE_ARRAY(pBackendDXContext->cBlendState, pBackendDXContext->papBlendState);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papBlendState, &pBackendDXContext->cBlendState,
+                                  sizeof(pBackendDXContext->papBlendState[0]), pDXContext->cot.cBlendState);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cBlendState - cValidEntries, &pBackendDXContext->papBlendState[cValidEntries]);
+                SVGACOTableDXBlendStateEntry const *pEntry = &pDXContext->cot.paBlendState[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineBlendState(pDXContext, i, pEntry);
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papBlendState, &pBackendDXContext->cBlendState,
-                                  sizeof(pBackendDXContext->papBlendState[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_DEPTHSTENCIL:
             if (pBackendDXContext->papDepthStencilState)
+                DX_RELEASE_ARRAY(pBackendDXContext->cDepthStencilState, pBackendDXContext->papDepthStencilState);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papDepthStencilState, &pBackendDXContext->cDepthStencilState,
+                                  sizeof(pBackendDXContext->papDepthStencilState[0]), pDXContext->cot.cDepthStencil);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cDepthStencilState - cValidEntries, &pBackendDXContext->papDepthStencilState[cValidEntries]);
+                SVGACOTableDXDepthStencilEntry const *pEntry = &pDXContext->cot.paDepthStencil[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineDepthStencilState(pDXContext, i, pEntry);
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papDepthStencilState, &pBackendDXContext->cDepthStencilState,
-                                  sizeof(pBackendDXContext->papDepthStencilState[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_RASTERIZERSTATE:
             if (pBackendDXContext->papRasterizerState)
+                DX_RELEASE_ARRAY(pBackendDXContext->cRasterizerState, pBackendDXContext->papRasterizerState);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papRasterizerState, &pBackendDXContext->cRasterizerState,
+                                  sizeof(pBackendDXContext->papRasterizerState[0]), pDXContext->cot.cRasterizerState);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cRasterizerState - cValidEntries, &pBackendDXContext->papRasterizerState[cValidEntries]);
+                SVGACOTableDXRasterizerStateEntry const *pEntry = &pDXContext->cot.paRasterizerState[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineRasterizerState(pDXContext, i, pEntry);
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papRasterizerState, &pBackendDXContext->cRasterizerState,
-                                  sizeof(pBackendDXContext->papRasterizerState[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_SAMPLER:
             if (pBackendDXContext->papSamplerState)
+                DX_RELEASE_ARRAY(pBackendDXContext->cSamplerState, pBackendDXContext->papSamplerState);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papSamplerState, &pBackendDXContext->cSamplerState,
+                                  sizeof(pBackendDXContext->papSamplerState[0]), pDXContext->cot.cSampler);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cSamplerState - cValidEntries, &pBackendDXContext->papSamplerState[cValidEntries]);
+                SVGACOTableDXSamplerEntry const *pEntry = &pDXContext->cot.paSampler[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                dxDefineSamplerState(pDXContext, i, pEntry);
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papSamplerState, &pBackendDXContext->cSamplerState,
-                                  sizeof(pBackendDXContext->papSamplerState[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_STREAMOUTPUT:
@@ -5219 +5870 @@
         case SVGA_COTABLE_DXQUERY:
             if (pBackendDXContext->papQuery)
+                DX_RELEASE_ARRAY(pBackendDXContext->cQuery, pBackendDXContext->papQuery);
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->papQuery, &pBackendDXContext->cQuery,
+                                  sizeof(pBackendDXContext->papQuery[0]), pDXContext->cot.cQuery);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
             {
-                /* Clear obsolete entries. */
-                DX_RELEASE_ARRAY(pBackendDXContext->cQuery - cValidEntries, &pBackendDXContext->papQuery[cValidEntries]);
+                SVGACOTableDXQueryEntry const *pEntry = &pDXContext->cot.paQuery[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                AssertFailed(); /** @todo implement */
             }
-
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papQuery, &pBackendDXContext->cQuery,
-                                  sizeof(pBackendDXContext->papQuery[0]), cEntries, cValidEntries);
             break;
         case SVGA_COTABLE_DXSHADER:
             if (pBackendDXContext->paShader)
             {
-                /* Clear obsolete entries. */
-                for (uint32_t i = cValidEntries; i < pBackendDXContext->cShader; ++i)
+                for (uint32_t i = 0; i < pBackendDXContext->cShader; ++i)
                     D3D_RELEASE(pBackendDXContext->paShader[i].pShader);
             }
 
             rc = dxCOTableRealloc((void **)&pBackendDXContext->paShader, &pBackendDXContext->cShader,
-                                  sizeof(pBackendDXContext->paShader[0]), cEntries, cValidEntries);
+                                  sizeof(pBackendDXContext->paShader[0]), pDXContext->cot.cShader);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
+            {
+                SVGACOTableDXShaderEntry const *pEntry = &pDXContext->cot.paShader[i];
+                /** @todo The caller must verify the COTable content using same rules as when a new entry is defined. */
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                /** @todo this should be in the commd DX code (the caller). */
+                PVMSVGA3DSHADER pShader = &pDXContext->paShader[i];
+                pShader->id                = i;
+                pShader->cid               = pDXContext->cid;
+                pShader->type              = pEntry->type;
+                pShader->cbData            = pEntry->sizeInBytes;
+                pShader->pShaderProgram    = NULL;
+                pShader->u.pvBackendShader = NULL;
+
+                dxDefineShader(pDXContext, i, pEntry);
+            }
             break;
         case SVGA_COTABLE_UAVIEW:
@@ -5257 +5934 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXTransferFromBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
 static DECLCALLBACK(int) vmsvga3dBackDXSurfaceCopyAndReadback(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
@@ -5298 +5965 @@
 
 static DECLCALLBACK(int) vmsvga3dBackDXReadbackAllQuery(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXPredTransferFromBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -5858 +6515 @@
                 p->pfnDXPresentBlt                = vmsvga3dBackDXPresentBlt;
                 p->pfnDXGenMips                   = vmsvga3dBackDXGenMips;
-                p->pfnDXUpdateSubResource         = vmsvga3dBackDXUpdateSubResource;
-                p->pfnDXReadbackSubResource       = vmsvga3dBackDXReadbackSubResource;
-                p->pfnDXInvalidateSubResource     = vmsvga3dBackDXInvalidateSubResource;
                 p->pfnDXDefineShaderResourceView  = vmsvga3dBackDXDefineShaderResourceView;
                 p->pfnDXDestroyShaderResourceView = vmsvga3dBackDXDestroyShaderResourceView;
@@ -5885 +6539 @@
                 p->pfnDXSetCOTable                = vmsvga3dBackDXSetCOTable;
                 p->pfnDXBufferCopy                = vmsvga3dBackDXBufferCopy;
-                p->pfnDXTransferFromBuffer        = vmsvga3dBackDXTransferFromBuffer;
                 p->pfnDXSurfaceCopyAndReadback    = vmsvga3dBackDXSurfaceCopyAndReadback;
                 p->pfnDXMoveQuery                 = vmsvga3dBackDXMoveQuery;
                 p->pfnDXBindAllQuery              = vmsvga3dBackDXBindAllQuery;
                 p->pfnDXReadbackAllQuery          = vmsvga3dBackDXReadbackAllQuery;
-                p->pfnDXPredTransferFromBuffer    = vmsvga3dBackDXPredTransferFromBuffer;
                 p->pfnDXMobFence64                = vmsvga3dBackDXMobFence64;
                 p->pfnDXBindAllShader             = vmsvga3dBackDXBindAllShader;
@@ -5955 +6607 @@
             {
                 VMSVGA3DBACKENDFUNCSMAP *p = (VMSVGA3DBACKENDFUNCSMAP *)pvInterfaceFuncs;
-                p->pfnSurfaceMap   = vmsvga3dSurfaceMap;
-                p->pfnSurfaceUnmap = vmsvga3dSurfaceUnmap;
+                p->pfnSurfaceMap   = vmsvga3dBackSurfaceMap;
+                p->pfnSurfaceUnmap = vmsvga3dBackSurfaceUnmap;
             }
         }

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

@@ -2743 +2743 @@
 
                 rc = vmsvga3dSurfaceDefine(pThisCC, sid, surfaceFlags, format, multisampleCount, autogenFilter,
-                                           cMipLevels, &pMipLevelSize[0]);
+                                           cMipLevels, &pMipLevelSize[0], /* fAllocMipLevels = */ true);
                 AssertRC(rc);
 

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

@@ -41 +41 @@
 #include "DevVGA-SVGA-internal.h"
 
+
+static int vmsvga3dSurfaceAllocMipLevels(PVMSVGA3DSURFACE pSurface)
+{
+    /* Allocate buffer to hold the surface data until we can move it into a D3D object */
+    for (uint32_t i = 0; i < pSurface->cLevels * pSurface->cFaces; ++i)
+    {
+        PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
+        AssertReturn(pMipmapLevel->pSurfaceData == NULL, VERR_INVALID_STATE);
+        pMipmapLevel->pSurfaceData = RTMemAllocZ(pMipmapLevel->cbSurface);
+        AssertReturn(pMipmapLevel->pSurfaceData, VERR_NO_MEMORY);
+    }
+    return VINF_SUCCESS;
+}
+
+
+static void vmsvga3dSurfaceFreeMipLevels(PVMSVGA3DSURFACE pSurface)
+{
+    for (uint32_t i = 0; i < pSurface->cLevels * pSurface->cFaces; ++i)
+    {
+        PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
+        RTMemFreeZ(pMipmapLevel->pSurfaceData, pMipmapLevel->cbSurface);
+        pMipmapLevel->pSurfaceData = NULL;
+    }
+}
 
 
@@ -59 +83 @@
 int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, SVGA3dSurface1Flags surfaceFlags, SVGA3dSurfaceFormat format,
                           uint32_t multisampleCount, SVGA3dTextureFilter autogenFilter,
-                          uint32_t numMipLevels, SVGA3dSize const *pMipLevel0Size)
+                          uint32_t numMipLevels, SVGA3dSize const *pMipLevel0Size, bool fAllocMipLevels)
 {
     PVMSVGA3DSURFACE pSurface;
@@ -351 +375 @@
     Assert(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface));
 
-    /* Allocate buffer to hold the surface data until we can move it into a D3D object */
-    for (uint32_t i = 0; i < numMipLevels * pSurface->cFaces; ++i)
-    {
-        PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
-        pMipmapLevel->pSurfaceData = RTMemAllocZ(pMipmapLevel->cbSurface);
-        AssertReturn(pMipmapLevel->pSurfaceData, VERR_NO_MEMORY);
+    if (fAllocMipLevels)
+    {
+        rc = vmsvga3dSurfaceAllocMipLevels(pSurface);
+        AssertRCReturn(rc, rc);
     }
 
@@ -403 +425 @@
     if (pSurface->paMipmapLevels)
     {
-        for (uint32_t i = 0; i < pSurface->cLevels * pSurface->cFaces; ++i)
-            RTMemFreeZ(pSurface->paMipmapLevels[i].pSurfaceData, pSurface->paMipmapLevels[i].cbSurface);
+        vmsvga3dSurfaceFreeMipLevels(pSurface);
         RTMemFree(pSurface->paMipmapLevels);
     }
@@ -552 +573 @@
          * the copy of the data we've got in VMSVGA3DMIMAPLEVEL::pSurfaceData.
          */
-        AssertReturn(pMipLevel->pSurfaceData, VERR_INTERNAL_ERROR);
+        if (!pMipLevel->pSurfaceData)
+        {
+            rc = vmsvga3dSurfaceAllocMipLevels(pSurface);
+            AssertRCReturn(rc, rc);
+        }
     }
     else if (vmsvga3dIsLegacyBackend(pThisCC))
@@ -1105 +1130 @@
     if (face == SVGA_ID_INVALID && mipmap == SVGA_ID_INVALID)
     {
+        /* This is a notification that "All images can be lost", i.e. the backend surface is not needed anymore. */
+        PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+        if (pSvgaR3State->pFuncs3D)
+            pSvgaR3State->pFuncs3D->pfnSurfaceDestroy(pThisCC, pSurface);
+
         for (uint32_t i = 0; i < pSurface->cLevels * pSurface->cFaces; ++i)
         {
@@ -1339 +1369 @@
 }
 
+
+/*
+ *
+ * Map
+ *
+ */
+
+int vmsvga3dSurfaceMap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox,
+                       VMSVGA3D_SURFACE_MAP enmMapType, VMSVGA3D_MAPPED_SURFACE *pMap)
+{
+    PVMSVGA3DSURFACE pSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pImage->sid, &pSurface);
+    AssertRCReturn(rc, rc);
+
+    if (VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
+    {
+        PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+        AssertReturn(pSvgaR3State->pFuncsMap, VERR_NOT_IMPLEMENTED);
+        return pSvgaR3State->pFuncsMap->pfnSurfaceMap(pThisCC, pImage, pBox, enmMapType, pMap);
+    }
+
+    PVMSVGA3DMIPMAPLEVEL pMipLevel;
+    rc = vmsvga3dMipmapLevel(pSurface, pImage->face, pImage->mipmap, &pMipLevel);
+    ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+    if (!pMipLevel->pSurfaceData)
+    {
+        rc = vmsvga3dSurfaceAllocMipLevels(pSurface);
+        AssertRCReturn(rc, rc);
+    }
+
+    SVGA3dBox clipBox;
+    if (pBox)
+    {
+        clipBox = *pBox;
+        vmsvgaR3ClipBox(&pMipLevel->mipmapSize, &clipBox);
+        ASSERT_GUEST_RETURN(clipBox.w && clipBox.h && clipBox.d, VERR_INVALID_PARAMETER);
+    }
+    else
+    {
+        clipBox.x = 0;
+        clipBox.y = 0;
+        clipBox.z = 0;
+        clipBox.w = pMipLevel->mipmapSize.width;
+        clipBox.h = pMipLevel->mipmapSize.height;
+        clipBox.d = pMipLevel->mipmapSize.depth;
+    }
+
+    /// @todo Zero the box?
+    //if (enmMapType == VMSVGA3D_SURFACE_MAP_WRITE_DISCARD)
+    //    RT_BZERO(.);
+
+    pMap->enmMapType   = enmMapType;
+    pMap->box          = clipBox;
+    pMap->cbPixel      = pSurface->cbBlock;
+    pMap->cbRowPitch   = pMipLevel->cbSurfacePitch;
+    pMap->cbDepthPitch = pMipLevel->cbSurfacePlane;
+    pMap->pvData       = (uint8_t *)pMipLevel->pSurfaceData
+                       + pMap->box.x * pMap->cbPixel
+                       + pMap->box.y * pMap->cbRowPitch
+                       + pMap->box.z * pMap->cbDepthPitch;
+
+    return VINF_SUCCESS;
+}
+
+int vmsvga3dSurfaceUnmap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, VMSVGA3D_MAPPED_SURFACE *pMap, bool fWritten)
+{
+    PVMSVGA3DSURFACE pSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pImage->sid, &pSurface);
+    AssertRCReturn(rc, rc);
+
+    if (VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
+    {
+        PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+        AssertReturn(pSvgaR3State->pFuncsMap, VERR_NOT_IMPLEMENTED);
+        return pSvgaR3State->pFuncsMap->pfnSurfaceUnmap(pThisCC, pImage, pMap, fWritten);
+    }
+
+    PVMSVGA3DMIPMAPLEVEL pMipLevel;
+    rc = vmsvga3dMipmapLevel(pSurface, pImage->face, pImage->mipmap, &pMipLevel);
+    ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+    if (   fWritten
+        && (   pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE
+            || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_READ_WRITE
+            || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE_DISCARD))
+    {
+        pMipLevel->fDirty = true;
+        pSurface->fDirty = true;
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+int vmsvga3dCalcSurfaceMipmapAndFace(PVGASTATECC pThisCC, uint32_t sid, uint32_t iSubresource, uint32_t *piMipmap, uint32_t *piFace)
+{
+    PVMSVGA3DSURFACE pSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, sid, &pSurface);
+    AssertRCReturn(rc, rc);
+
+    vmsvga3dCalcMipmapAndFace(pSurface->cLevels, iSubresource, piMipmap, piFace);
+    return VINF_SUCCESS;
+}
+
+
+uint32_t vmsvga3dCalcSubresourceOffset(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage)
+{
+    PVMSVGA3DSURFACE pSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pImage->sid, &pSurface);
+    AssertRCReturn(rc, 0);
+
+    /** @todo Store cbArraySlice in the surface structure. */
+    uint32_t cbArraySlice = 0;
+    for (uint32_t i = 0; i < pSurface->cLevels; ++i)
+    {
+        PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
+        cbArraySlice += pMipLevel->cbSurface;
+    }
+
+    uint32_t offMipLevel = 0;
+    for (uint32_t i = 0; i < pImage->mipmap; ++i)
+    {
+        PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
+        offMipLevel += pMipmapLevel->cbSurface;
+    }
+
+    uint32_t offSubresource = cbArraySlice * pImage->face + offMipLevel;
+    /** @todo Multisample?  */
+    return offSubresource;
+}
+
+
+/*
+ * Calculates memory layout of a surface box for memcpy:
+ */
+int vmsvga3dGetBoxDimensions(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox,
+                             VMSGA3D_BOX_DIMENSIONS *pResult)
+{
+    PVMSVGA3DSURFACE pSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pImage->sid, &pSurface);
+    AssertRCReturn(rc, rc);
+
+    PVMSVGA3DMIPMAPLEVEL pMipLevel;
+    rc = vmsvga3dMipmapLevel(pSurface, pImage->face, pImage->mipmap, &pMipLevel);
+    ASSERT_GUEST_RETURN(RT_SUCCESS(rc), rc);
+
+    /* Clip the box. */
+    SVGA3dBox clipBox;
+    if (pBox)
+    {
+        clipBox = *pBox;
+        vmsvgaR3ClipBox(&pMipLevel->mipmapSize, &clipBox);
+        ASSERT_GUEST_RETURN(clipBox.w && clipBox.h && clipBox.d, VERR_INVALID_PARAMETER);
+    }
+    else
+    {
+        clipBox.x = 0;
+        clipBox.y = 0;
+        clipBox.z = 0;
+        clipBox.w = pMipLevel->mipmapSize.width;
+        clipBox.h = pMipLevel->mipmapSize.height;
+        clipBox.d = pMipLevel->mipmapSize.depth;
+    }
+
+    /** @todo Calculate offSubresource here, when pSurface will have cbArraySlice field. */
+    pResult->offSubresource = vmsvga3dCalcSubresourceOffset(pThisCC, pImage);
+    pResult->offBox   = (clipBox.x / pSurface->cxBlock) * pSurface->cbBlock
+                      + (clipBox.y / pSurface->cyBlock) * pMipLevel->cbSurfacePitch
+                      + clipBox.z * pMipLevel->cbSurfacePlane;
+    pResult->cbRow    = (clipBox.w / pSurface->cxBlock) * pSurface->cbBlock;
+    pResult->cbPitch  = pMipLevel->cbSurfacePitch;
+    pResult->cyBlocks = clipBox.h / pSurface->cyBlock;
+    pResult->cDepth   = clipBox.d;
+
+    return VINF_SUCCESS;
+}
+
+
 /*
  * Whether a legacy 3D backend is used.

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

@@ -78 +78 @@
 int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, SVGA3dSurface1Flags surfaceFlags, SVGA3dSurfaceFormat format,
                           uint32_t multisampleCount, SVGA3dTextureFilter autogenFilter,
-                          uint32_t cMipLevels, SVGA3dSize const *pMipLevel0Size);
+                          uint32_t cMipLevels, SVGA3dSize const *pMipLevel0Size, bool fAllocMipLevels);
 int vmsvga3dSurfaceDestroy(PVGASTATECC pThisCC, uint32_t sid);
 int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
@@ -123 +123 @@
 
 int vmsvga3dSurfaceInvalidate(PVGASTATECC pThisCC, uint32_t sid, uint32_t face, uint32_t mipmap);
+
+int vmsvga3dSurfaceMap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox,
+                           VMSVGA3D_SURFACE_MAP enmMapType, VMSVGA3D_MAPPED_SURFACE *pMap);
+int vmsvga3dSurfaceUnmap(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, VMSVGA3D_MAPPED_SURFACE *pMap, bool fWritten);
+
+uint32_t vmsvga3dCalcSubresourceOffset(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage);
+
+typedef struct VMSGA3D_BOX_DIMENSIONS
+{
+    uint32_t offSubresource; /* Offset of the miplevel. */
+    uint32_t offBox;         /* Offset of the box in the miplevel. */
+    uint32_t cbRow;          /* Bytes per row. */
+    int32_t  cbPitch;        /* Bytes between rows. */
+    uint32_t cyBlocks;       /* Number of rows. */
+    uint32_t cDepth;         /* Number of planes. */
+} VMSGA3D_BOX_DIMENSIONS;
+
+int vmsvga3dGetBoxDimensions(PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox,
+                             VMSGA3D_BOX_DIMENSIONS *pResult);
+
+DECLINLINE(void) vmsvga3dCalcMipmapSize(SVGA3dSize const *pSize0, uint32_t iMipmap, SVGA3dSize *pSize)
+{
+    pSize->width  = RT_MAX(pSize0->width  >> iMipmap, 1);
+    pSize->height = RT_MAX(pSize0->height >> iMipmap, 1);
+    pSize->depth  = RT_MAX(pSize0->depth  >> iMipmap, 1);
+}
+
+DECLINLINE(uint32_t) vmsvga3dCalcSubresource(uint32_t iMipLevel, uint32_t iFace, uint32_t cMipLevels)
+{
+    /* Same as in D3D */
+    return iMipLevel + iFace * cMipLevels;
+}
+
+DECLINLINE(void) vmsvga3dCalcMipmapAndFace(uint32_t cMipLevels, uint32_t iSubresource, uint32_t *piMipmap, uint32_t *piFace)
+{
+    *piFace = iSubresource / cMipLevels;
+    *piMipmap = iSubresource % cMipLevels;
+}
+
+int vmsvga3dCalcSurfaceMipmapAndFace(PVGASTATECC pThisCC, uint32_t sid, uint32_t iSubresource, uint32_t *piMipmap, uint32_t *piFace);
+
 
 /* DevVGA-SVGA3d-shared.h: */
@@ -344 +385 @@
 typedef struct
 {
-    DECLCALLBACKMEMBER(int, pfnSurfaceMap,   (PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox, VMSVGA3D_SURFACE_MAP enmMapType, VMSVGA3D_MAPPED_SURFACE *pMap));
+    DECLCALLBACKMEMBER(int, pfnSurfaceMap,   (PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, SVGA3dBox const *pBox, VMSVGA3D_SURFACE_MAP enmMapType, VMSVGA3D_MAPPED_SURFACE *pMap));
     DECLCALLBACKMEMBER(int, pfnSurfaceUnmap, (PVGASTATECC pThisCC, SVGA3dSurfaceImageId const *pImage, VMSVGA3D_MAPPED_SURFACE *pMap, bool fWritten));
 } VMSVGA3DBACKENDFUNCSMAP;
@@ -364 +405 @@
     DECLCALLBACKMEMBER(int, pfnDXDraw,                      (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t vertexCount, uint32_t startVertexLocation));
     DECLCALLBACKMEMBER(int, pfnDXDrawIndexed,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t indexCount, uint32_t startIndexLocation, int32_t baseVertexLocation));
-    DECLCALLBACKMEMBER(int, pfnDXDrawInstanced,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXDrawIndexedInstanced,      (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
+    DECLCALLBACKMEMBER(int, pfnDXDrawInstanced,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t vertexCountPerInstance, uint32_t instanceCount, uint32_t startVertexLocation, uint32_t startInstanceLocation));
+    DECLCALLBACKMEMBER(int, pfnDXDrawIndexedInstanced,      (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t indexCountPerInstance, uint32_t instanceCount, uint32_t startIndexLocation, int32_t baseVertexLocation, uint32_t startInstanceLocation));
     DECLCALLBACKMEMBER(int, pfnDXDrawAuto,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXSetInputLayout,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dElementLayoutId elementLayoutId));
@@ -392 +433 @@
     DECLCALLBACKMEMBER(int, pfnDXPresentBlt,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXGenMips,                   (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId));
-    DECLCALLBACKMEMBER(int, pfnDXUpdateSubResource,         (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXReadbackSubResource,       (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXInvalidateSubResource,     (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXDefineShaderResourceView,  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId, SVGACOTableDXSRViewEntry const *pEntry));
     DECLCALLBACKMEMBER(int, pfnDXDestroyShaderResourceView, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId));
@@ -405 +443 @@
     DECLCALLBACKMEMBER(int, pfnDXDefineBlendState,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dBlendStateId blendId, SVGACOTableDXBlendStateEntry const *pEntry));
     DECLCALLBACKMEMBER(int, pfnDXDestroyBlendState,         (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXDefineDepthStencilState,   (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilStateId depthStencilId, SVGACOTableDXDepthStencilEntry *pEntry));
+    DECLCALLBACKMEMBER(int, pfnDXDefineDepthStencilState,   (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilStateId depthStencilId, SVGACOTableDXDepthStencilEntry const *pEntry));
     DECLCALLBACKMEMBER(int, pfnDXDestroyDepthStencilState,  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXDefineRasterizerState,     (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRasterizerStateId rasterizerId, SVGACOTableDXRasterizerStateEntry const *pEntry));
@@ -411 +449 @@
     DECLCALLBACKMEMBER(int, pfnDXDefineSamplerState,        (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dSamplerId samplerId, SVGACOTableDXSamplerEntry const *pEntry));
     DECLCALLBACKMEMBER(int, pfnDXDestroySamplerState,       (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXDefineShader,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader));
+    DECLCALLBACKMEMBER(int, pfnDXDefineShader,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, SVGACOTableDXShaderEntry const *pEntry));
     DECLCALLBACKMEMBER(int, pfnDXDestroyShader,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXBindShader,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader, void const *pvShaderBytecode));
@@ -417 +455 @@
     DECLCALLBACKMEMBER(int, pfnDXDestroyStreamOutput,       (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXSetStreamOutput,           (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXSetCOTable,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableType type, uint32_t cEntries, uint32_t cValidEntries));
+    DECLCALLBACKMEMBER(int, pfnDXSetCOTable,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableType type, uint32_t cValidEntries));
     DECLCALLBACKMEMBER(int, pfnDXBufferCopy,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXTransferFromBuffer,        (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXSurfaceCopyAndReadback,    (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXMoveQuery,                 (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXBindAllQuery,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXReadbackAllQuery,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXPredTransferFromBuffer,    (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXMobFence64,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXBindAllShader,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -490 +526 @@
 int vmsvga3dDXDestroyContext(PVGASTATECC pThisCC, uint32_t cid);
 int vmsvga3dDXBindContext(PVGASTATECC pThisCC, uint32_t cid, SVGADXContextMobFormat *pSvgaDXContext);
-int vmsvga3dDXReadbackContext(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXReadbackContext(PVGASTATECC pThisCC, uint32_t idDXContext, SVGADXContextMobFormat *pSvgaDXContext);
 int vmsvga3dDXInvalidateContext(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXSetSingleConstantBuffer(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetSingleConstantBuffer const *pCmd);
@@ -498 +534 @@
 int vmsvga3dDXDraw(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDraw const *pCmd);
 int vmsvga3dDXDrawIndexed(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDrawIndexed const *pCmd);
-int vmsvga3dDXDrawInstanced(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXDrawIndexedInstanced(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXDrawInstanced(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDrawInstanced const *pCmd);
+int vmsvga3dDXDrawIndexedInstanced(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDrawIndexedInstanced const *pCmd);
 int vmsvga3dDXDrawAuto(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXSetInputLayout(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dElementLayoutId elementLayoutId);
@@ -526 +562 @@
 int vmsvga3dDXPresentBlt(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXGenMips(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXGenMips const *pCmd);
-int vmsvga3dDXUpdateSubResource(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXReadbackSubResource(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXInvalidateSubResource(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXDefineShaderResourceView(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDefineShaderResourceView const *pCmd);
 int vmsvga3dDXDestroyShaderResourceView(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDestroyShaderResourceView const *pCmd);
@@ -554 +587 @@
 int vmsvga3dDXReadbackCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXReadbackCOTable const *pCmd);
 int vmsvga3dDXBufferCopy(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXTransferFromBuffer(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXSurfaceCopyAndReadback(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXMoveQuery(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXBindAllQuery(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXReadbackAllQuery(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXPredTransferFromBuffer(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXMobFence64(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXBindAllShader(PVGASTATECC pThisCC, uint32_t idDXContext);

trunk/src/VBox/Devices/Makefile.kmk

@@ -331 +331 @@
        Graphics/DevVGA-SVGA3d-dx-shader.cpp
    if "$(KBUILD_TARGET)" == "win"
+    VBoxDD_DEFS         += VMSVGA3D_DX_BACKEND
     VBoxDD_SOURCES      += \
        Graphics/DevVGA-SVGA3d-win-dx.cpp