Changeset 94063 in vbox for trunk/src/VBox

Timestamp:

Mar 2, 2022 3:41:38 PM (3 years ago)

Author:

vboxsync

Message:

Devices/Graphics: shader resource and render target views should be set before a Draw call; resource view cleanup: bugref:9830

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA3d-dx.cpp (modified) (7 diffs)
• DevVGA-SVGA3d-ogl.cpp (modified) (2 diffs)
• DevVGA-SVGA3d-win-dx.cpp (modified) (114 diffs)
• DevVGA-SVGA3d-win.cpp (modified) (2 diffs)
• DevVGA-SVGA3d.cpp (modified) (1 diff)
• DevVGA-SVGA3d.h (modified) (1 diff)

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

@@ -205 +205 @@
     RT_UNTRUSTED_VALIDATED_FENCE();
 
+    uint32_t const idxShaderState = pCmd->type - SVGA3D_SHADERTYPE_MIN;
+    SVGA3dConstantBufferBinding *pCBB = &pDXContext->svgaDXContext.shaderState[idxShaderState].constantBuffers[pCmd->slot];
+    pCBB->sid           = pCmd->sid;
+    pCBB->offsetInBytes = pCmd->offsetInBytes;
+    pCBB->sizeInBytes   = pCmd->sizeInBytes;
+
     rc = pSvgaR3State->pFuncsDX->pfnDXSetSingleConstantBuffer(pThisCC, pDXContext, pCmd->slot, pCmd->type, pCmd->sid, pCmd->offsetInBytes, pCmd->sizeInBytes);
-    if (RT_SUCCESS(rc))
-    {
-        uint32_t const idxShaderState = pCmd->type - SVGA3D_SHADERTYPE_MIN;
-        SVGA3dConstantBufferBinding *pCBB = &pDXContext->svgaDXContext.shaderState[idxShaderState].constantBuffers[pCmd->slot];
-        pCBB->sid           = pCmd->sid;
-        pCBB->offsetInBytes = pCmd->offsetInBytes;
-        pCBB->sizeInBytes   = pCmd->sizeInBytes;
-    }
     return rc;
 }
@@ -238 +236 @@
                             || paShaderResourceViewId[i] == SVGA3D_INVALID_ID, VERR_INVALID_PARAMETER);
     RT_UNTRUSTED_VALIDATED_FENCE();
+
+    uint32_t const idxShaderState = pCmd->type - SVGA3D_SHADERTYPE_MIN;
+    for (uint32_t i = 0; i < cShaderResourceViewId; ++i)
+    {
+        SVGA3dShaderResourceViewId const shaderResourceViewId = paShaderResourceViewId[i];
+        pDXContext->svgaDXContext.shaderState[idxShaderState].shaderResources[pCmd->startView + i] = shaderResourceViewId;
+    }
 
     rc = pSvgaR3State->pFuncsDX->pfnDXSetShaderResources(pThisCC, pDXContext, pCmd->startView, pCmd->type, cShaderResourceViewId, paShaderResourceViewId);
@@ -517 +522 @@
     AssertRCReturn(rc, rc);
 
+    pDXContext->svgaDXContext.inputAssembly.indexBufferSid = pCmd->sid;
+    pDXContext->svgaDXContext.inputAssembly.indexBufferOffset = pCmd->offset;
+    pDXContext->svgaDXContext.inputAssembly.indexBufferFormat = pCmd->format;
+
     rc = pSvgaR3State->pFuncsDX->pfnDXSetIndexBuffer(pThisCC, pDXContext, pCmd->sid, pCmd->format, pCmd->offset);
-    if (RT_SUCCESS(rc))
-    {
-        pDXContext->svgaDXContext.inputAssembly.indexBufferSid = pCmd->sid;
-        pDXContext->svgaDXContext.inputAssembly.indexBufferOffset = pCmd->offset;
-        pDXContext->svgaDXContext.inputAssembly.indexBufferFormat = pCmd->format;
-    }
     return rc;
 }
@@ -542 +545 @@
     ASSERT_GUEST_RETURN(topology >= SVGA3D_PRIMITIVE_MIN && topology < SVGA3D_PRIMITIVE_MAX, VERR_INVALID_PARAMETER);
 
+    pDXContext->svgaDXContext.inputAssembly.topology = topology;
+
     rc = pSvgaR3State->pFuncsDX->pfnDXSetTopology(pThisCC, pDXContext, topology);
-    if (RT_SUCCESS(rc))
-        pDXContext->svgaDXContext.inputAssembly.topology = topology;
     return rc;
 }
@@ -569 +572 @@
     RT_UNTRUSTED_VALIDATED_FENCE();
 
+    pDXContext->svgaDXContext.renderState.depthStencilViewId = depthStencilViewId;
+    for (uint32_t i = 0; i < cRenderTargetViewId; ++i)
+        pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] = paRenderTargetViewId[i];
+
     rc = pSvgaR3State->pFuncsDX->pfnDXSetRenderTargets(pThisCC, pDXContext, depthStencilViewId, cRenderTargetViewId, paRenderTargetViewId);
-    if (RT_SUCCESS(rc))
-    {
-        pDXContext->svgaDXContext.renderState.depthStencilViewId = depthStencilViewId;
-        for (uint32_t i = 0; i < cRenderTargetViewId; ++i)
-            pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] = paRenderTargetViewId[i];
-    }
     return rc;
 }
@@ -1062 +1063 @@
     RT_ZERO(*pEntry);
 
+    for (uint32_t i = 0; i < SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS; ++i)
+    {
+        if (pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] == renderTargetViewId)
+            pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] = SVGA_ID_INVALID;
+    }
+
     rc = pSvgaR3State->pFuncsDX->pfnDXDestroyRenderTargetView(pThisCC, pDXContext, renderTargetViewId);
-    /// @todo for (uint32_t i = 0; i < SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS; ++i)
-    //{
-    //    if (pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] == renderTargetViewId)
-    //        pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] = SVGA_ID_INVALID;
-    //}
     return rc;
 }
@@ -1700 +1702 @@
     RT_UNTRUSTED_VALIDATED_FENCE();
 
+    pDXContext->svgaDXContext.streamOut.soid = soid;
+
     rc = pSvgaR3State->pFuncsDX->pfnDXSetStreamOutput(pThisCC, pDXContext, soid);
-    if (RT_SUCCESS(rc))
-        pDXContext->svgaDXContext.streamOut.soid = soid;
-
     return rc;
 }

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

@@ -2068 +2068 @@
             break;
     }
+}
+
+
+static DECLCALLBACK(void) vmsvga3dBackSurfaceInvalidateImage(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface, uint32_t uFace, uint32_t uMipmap)
+{
+    RT_NOREF(pThisCC, pSurface, uFace, uMipmap);
 }
 
@@ -7891 +7897 @@
                 p->pfnCreateTexture            = vmsvga3dBackCreateTexture;
                 p->pfnSurfaceDestroy           = vmsvga3dBackSurfaceDestroy;
+                p->pfnSurfaceInvalidateImage   = vmsvga3dBackSurfaceInvalidateImage;
                 p->pfnSurfaceCopy              = vmsvga3dBackSurfaceCopy;
                 p->pfnSurfaceDMACopyBox        = vmsvga3dBackSurfaceDMACopyBox;

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

@@ -76 +76 @@
 } DXDEVICE;
 
+/* Kind of a texture view. */
+typedef enum VMSVGA3DBACKVIEWTYPE
+{
+    VMSVGA3D_VIEWTYPE_NONE           = 0,
+    VMSVGA3D_VIEWTYPE_RENDERTARGET   = 1,
+    VMSVGA3D_VIEWTYPE_DEPTHSTENCIL   = 2,
+    VMSVGA3D_VIEWTYPE_SHADERRESOURCE = 3
+} VMSVGA3DBACKVIEWTYPE;
+
+/* Information about a texture view to track all created views:.
+ * when a surface is invalidated, then all views must deleted;
+ * when a view is deleted, then the view must be unlinked from the surface.
+ */
+typedef struct DXVIEWINFO
+{
+    uint32_t sid;                                      /* Surface which the view was created for. */
+    uint32_t cid;                                      /* DX context which created the view. */
+    uint32_t viewId;                                   /* View id assigned by the guest. */
+    VMSVGA3DBACKVIEWTYPE enmViewType;
+} DXVIEWINFO;
+
+/* Context Object Table element for a texture view. */
+typedef struct DXVIEW
+{
+    uint32_t cid;                                      /* DX context which created the view. */
+    uint32_t sid;                                      /* Surface which the view was created for. */
+    uint32_t viewId;                                   /* View id assigned by the guest. */
+    VMSVGA3DBACKVIEWTYPE enmViewType;
+
+    union
+    {
+        ID3D11View               *pView;               /* The view object. */
+        ID3D11RenderTargetView   *pRenderTargetView;
+        ID3D11DepthStencilView   *pDepthStencilView;
+        ID3D11ShaderResourceView *pShaderResourceView;
+    } u;
+
+    RTLISTNODE nodeSurfaceView;                        /* Views are linked to the surface. */
+} DXVIEW;
+
 /* What kind of resource has been created for the VMSVGA3D surface. */
 typedef enum VMSVGA3DBACKRESTYPE
@@ -82 +122 @@
     VMSVGA3D_RESTYPE_SCREEN_TARGET  = 1,
     VMSVGA3D_RESTYPE_TEXTURE_1D     = 2,
-    VMSVGA3D_RESTYPE_TEXTURE        = 3,
-    VMSVGA3D_RESTYPE_CUBE_TEXTURE   = 4,
+    VMSVGA3D_RESTYPE_TEXTURE_2D     = 3,
+    VMSVGA3D_RESTYPE_TEXTURE_CUBE   = 4,
     VMSVGA3D_RESTYPE_TEXTURE_3D     = 5,
     VMSVGA3D_RESTYPE_BUFFER         = 6,
@@ -95 +135 @@
     {
         ID3D11Resource     *pResource;
+        ID3D11Texture1D    *pTexture1D;
         ID3D11Texture2D    *pTexture2D;
         ID3D11Texture3D    *pTexture3D;
@@ -116 +157 @@
     /** AVL tree containing DXSHAREDTEXTURE structures. */
     AVLU32TREE SharedTextureTree;
+
+    union
+    {
+       struct
+       {
+           /* Render target views, depth stencil views and shader resource views created for this texture. */
+           RTLISTANCHOR listView;                 /* DXVIEW */
+       } Texture;
+    } u2;
 
 } VMSVGA3DBACKENDSURFACE;
@@ -170 +220 @@
 } DXSTREAMOUTPUT;
 
-#define DX_DEFERRED_SET_RENDER_TARGETS
 typedef struct VMSVGA3DBACKENDDXCONTEXT
 {
-    DXDEVICE                   device;                 /* DX device interfaces for this context operations. */
+    DXDEVICE                   dxDevice;               /* DX device interfaces for this context operations. */
 
     /* Arrays for Context-Object Tables. Number of entries depends on COTable size. */
@@ -192 +241 @@
     ID3D11RasterizerState    **papRasterizerState;
     DXELEMENTLAYOUT           *paElementLayout;
-    ID3D11RenderTargetView   **papRenderTargetView;
-    ID3D11DepthStencilView   **papDepthStencilView;
-    ID3D11ShaderResourceView **papShaderResourceView;
+    DXVIEW                    *paRenderTargetView;
+    DXVIEW                    *paDepthStencilView;
+    DXVIEW                    *paShaderResourceView;
     ID3D11Query              **papQuery;
     DXSHADER                  *paShader;
     DXSTREAMOUTPUT            *paStreamOutput;
 
-#ifdef DX_DEFERRED_SET_RENDER_TARGETS
-    struct
-    {
-        ID3D11RenderTargetView *papRenderTargetViews[SVGA3D_MAX_RENDER_TARGETS];
-        uint32_t cRenderTargetViews;
-        ID3D11DepthStencilView *pDepthStencilView;
-    } state;
-#endif
-
     uint32_t                   cSOTarget;              /* How many SO targets are currently set (SetSOTargets) */
 } VMSVGA3DBACKENDDXCONTEXT;
 
+/* Shader disassembler function. Optional. */
 typedef HRESULT FN_D3D_DISASSEMBLE(LPCVOID pSrcData, SIZE_T SrcDataSize, UINT Flags, LPCSTR szComments, ID3D10Blob **ppDisassembly);
 typedef FN_D3D_DISASSEMBLE *PFN_D3D_DISASSEMBLE;
@@ -222 +263 @@
     PFN_D3D_DISASSEMBLE        pfnD3DDisassemble;
 
-    DXDEVICE                   device;                 /* Device for the VMSVGA3D context independent operation. */
+    /** @todo This device will be used for all rendering for "single DX device" mode. */
+    DXDEVICE                   dxDevice;               /* Device for the VMSVGA3D context independent operation. */
 } VMSVGA3DBACKEND;
 
 
+/* Static function prototypes. */
 static int dxDeviceFlush(DXDEVICE *pDevice);
+static int dxDefineShaderResourceView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId, SVGACOTableDXSRViewEntry const *pEntry);
+static int dxDefineRenderTargetView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRenderTargetViewId renderTargetViewId, SVGACOTableDXRTViewEntry const *pEntry);
+static int dxDefineDepthStencilView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilViewId depthStencilViewId, SVGACOTableDXDSViewEntry const *pEntry);
+static int dxSetRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext);
 static DECLCALLBACK(void) vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface);
 
@@ -259 +306 @@
 }
 
+/* This is to workaround issues with X8 formats, because they can't be used in some operations. */
 #define DX_REPLACE_X8_WITH_A8
 static DXGI_FORMAT vmsvgaDXSurfaceFormat2Dxgi(SVGA3dSurfaceFormat format)
@@ -690 +738 @@
     if (dxgiFormat != DXGI_FORMAT_UNKNOWN)
     {
-        ID3D11Device *pDevice = pState->pBackend->device.pDevice;
+        ID3D11Device *pDevice = pState->pBackend->dxDevice.pDevice;
         UINT FormatSupport = 0;
         HRESULT hr = pDevice->CheckFormatSupport(dxgiFormat, &FormatSupport);
@@ -776 +824 @@
             {
                 pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_CORRUPTION, true);
-                pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
-                pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, true);
+//                pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_ERROR, true);
+//                pInfoQueue->SetBreakOnSeverity(D3D11_MESSAGE_SEVERITY_WARNING, true);
 
                 /* No breakpoints for the following messages. */
@@ -847 +895 @@
     if (SUCCEEDED(hr2))
     {
+        /// @todo Use this to see whether all resources have been properly released.
+        //DEBUG_BREAKPOINT_TEST();
         //pDebug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL | (D3D11_RLDO_FLAGS)0x4 /*D3D11_RLDO_IGNORE_INTERNAL*/);
         D3D_RELEASE(pDebug);
@@ -854 +904 @@
     D3D_RELEASE(pDevice->pDevice);
     RT_ZERO(*pDevice);
+}
+
+
+static void dxViewAddToList(PVGASTATECC pThisCC, DXVIEW *pDXView)
+{
+    LogFunc(("cid = %u, sid = %u, viewId = %u, type = %u\n",
+             pDXView->cid, pDXView->sid, pDXView->viewId, pDXView->enmViewType));
+
+    Assert(pDXView->u.pView); /* Only already created views should be added. Guard against mis-use by callers. */
+
+    PVMSVGA3DSURFACE pSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pDXView->sid, &pSurface);
+    AssertRCReturnVoid(rc);
+
+    RTListAppend(&pSurface->pBackendSurface->u2.Texture.listView, &pDXView->nodeSurfaceView);
+}
+
+
+static void dxViewRemoveFromList(DXVIEW *pDXView)
+{
+    LogFunc(("cid = %u, sid = %u, viewId = %u, type = %u\n",
+             pDXView->cid, pDXView->sid, pDXView->viewId, pDXView->enmViewType));
+    /* pView can be NULL, if COT entry is already empty. */
+    if (pDXView->u.pView)
+    {
+        Assert(pDXView->nodeSurfaceView.pNext && pDXView->nodeSurfaceView.pPrev);
+        RTListNodeRemove(&pDXView->nodeSurfaceView);
+    }
+}
+
+
+static int dxViewDestroy(DXVIEW *pDXView)
+{
+    LogFunc(("cid = %u, sid = %u, viewId = %u, type = %u\n",
+             pDXView->cid, pDXView->sid, pDXView->viewId, pDXView->enmViewType));
+    if (pDXView->u.pView)
+    {
+        D3D_RELEASE(pDXView->u.pView);
+        RTListNodeRemove(&pDXView->nodeSurfaceView);
+        RT_ZERO(*pDXView);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+static int dxViewInit(DXVIEW *pDXView, PVMSVGA3DSURFACE pSurface, VMSVGA3DDXCONTEXT *pDXContext, uint32_t viewId, VMSVGA3DBACKVIEWTYPE enmViewType, ID3D11View *pView)
+{
+    pDXView->cid         = pDXContext->cid;
+    pDXView->sid         = pSurface->id;
+    pDXView->viewId      = viewId;
+    pDXView->enmViewType = enmViewType;
+    pDXView->u.pView     = pView;
+    RTListAppend(&pSurface->pBackendSurface->u2.Texture.listView, &pDXView->nodeSurfaceView);
+
+    LogFunc(("cid = %u, sid = %u, viewId = %u, type = %u\n",
+              pDXView->cid, pDXView->sid, pDXView->viewId, pDXView->enmViewType));
+
+DXVIEW *pIter, *pNext;
+RTListForEachSafe(&pSurface->pBackendSurface->u2.Texture.listView, pIter, pNext, DXVIEW, nodeSurfaceView)
+{
+    AssertPtr(pNext);
+    LogFunc(("pIter=%p, pNext=%p\n", pIter, pNext));
+}
+
+    return VINF_SUCCESS;
 }
 
@@ -868 +984 @@
 
 
-DXDEVICE *dxDeviceFromCid(uint32_t cid, PVMSVGA3DSTATE pState)
+static DXDEVICE *dxDeviceFromCid(uint32_t cid, PVMSVGA3DSTATE pState)
 {
     if (cid != DX_CID_BACKEND)
@@ -875 +991 @@
         int rc = vmsvga3dDXContextFromCid(pState, cid, &pDXContext);
         if (RT_SUCCESS(rc))
-            return &pDXContext->pBackendDXContext->device;
+            return &pDXContext->pBackendDXContext->dxDevice;
     }
     else
-        return &pState->pBackend->device;
+        return &pState->pBackend->dxDevice;
 
     AssertFailed();
     return NULL;
+}
+
+
+static DXDEVICE *dxDeviceFromContext(PVMSVGA3DSTATE p3dState, VMSVGA3DDXCONTEXT *pDXContext)
+{
+    if (pDXContext)
+        return &pDXContext->pBackendDXContext->dxDevice;
+
+    return &p3dState->pBackend->dxDevice;
 }
 
@@ -966 +1091 @@
         if (!pSharedTexture)
         {
-            DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+            DXDEVICE *pDevice = dxDeviceFromContext(pState, pDXContext);
             AssertReturn(pDevice->pDevice, NULL);
 
@@ -1010 +1135 @@
 
 
-static uint32_t dxGetShaderResourceViewSid(PVMSVGA3DDXCONTEXT pDXContext, uint32_t shaderResourceViewId)
-{
-    ASSERT_GUEST_RETURN(shaderResourceViewId < pDXContext->cot.cSRView, SVGA_ID_INVALID);
+static SVGACOTableDXSRViewEntry const *dxGetShaderResourceViewEntry(PVMSVGA3DDXCONTEXT pDXContext, uint32_t shaderResourceViewId)
+{
+    ASSERT_GUEST_RETURN(shaderResourceViewId < pDXContext->cot.cSRView, NULL);
 
     SVGACOTableDXSRViewEntry const *pSRViewEntry = &pDXContext->cot.paSRView[shaderResourceViewId];
-    return pSRViewEntry->sid;
+    return pSRViewEntry;
+}
+
+
+static SVGACOTableDXDSViewEntry const *dxGetDepthStencilViewEntry(PVMSVGA3DDXCONTEXT pDXContext, uint32_t depthStencilViewId)
+{
+    ASSERT_GUEST_RETURN(depthStencilViewId < pDXContext->cot.cDSView, NULL);
+
+    SVGACOTableDXDSViewEntry const *pDSViewEntry = &pDXContext->cot.paDSView[depthStencilViewId];
+    return pDSViewEntry;
+}
+
+
+static SVGACOTableDXRTViewEntry const *dxGetRenderTargetViewEntry(PVMSVGA3DDXCONTEXT pDXContext, uint32_t renderTargetViewId)
+{
+    ASSERT_GUEST_RETURN(renderTargetViewId < pDXContext->cot.cRTView, NULL);
+
+    SVGACOTableDXRTViewEntry const *pRTViewEntry = &pDXContext->cot.paRTView[renderTargetViewId];
+    return pRTViewEntry;
 }
 
@@ -1209 +1352 @@
 static HRESULT dxRenderTargetViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXRTViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11RenderTargetView **pp)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
 
     ID3D11Resource *pResource = dxResource(pThisCC->svga.p3dState, pSurface, pDXContext);
@@ -1283 +1426 @@
 static HRESULT dxShaderResourceViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXSRViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11ShaderResourceView **pp)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
 
     ID3D11Resource *pResource = dxResource(pThisCC->svga.p3dState, pSurface, pDXContext);
@@ -1360 +1503 @@
 static HRESULT dxDepthStencilViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXDSViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11DepthStencilView **pp)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
 
     ID3D11Resource *pResource = dxResource(pThisCC->svga.p3dState, pSurface, pDXContext);
@@ -1409 +1552 @@
 
 
-static HRESULT dxShaderCreate(PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader, DXSHADER *pDXShader)
-{
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+static HRESULT dxShaderCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader, DXSHADER *pDXShader)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
 
     HRESULT hr = S_OK;
@@ -1466 +1609 @@
 
 
-static void dxShaderSet(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderType type, DXSHADER *pDXShader)
-{
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+static void dxShaderSet(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderType type, DXSHADER *pDXShader)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
 
     switch (type)
@@ -1563 +1706 @@
     AssertPtrReturn(pBackendSurface, VERR_NO_MEMORY);
     pBackendSurface->cidDrawing = SVGA_ID_INVALID;
+    RTListInit(&pBackendSurface->u2.Texture.listView);
     *ppBackendSurface = pBackendSurface;
     return VINF_SUCCESS;
@@ -1576 +1720 @@
     AssertReturn(pBackend, VERR_INVALID_STATE);
 
-    DXDEVICE *pDXDevice = &pBackend->device;
+    DXDEVICE *pDXDevice = &pBackend->dxDevice;
     AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
@@ -1686 +1830 @@
 
 
+static DXDEVICE *dxSurfaceDevice(PVMSVGA3DSTATE p3dState, PVMSVGA3DSURFACE pSurface, PVMSVGA3DDXCONTEXT pDXContext, UINT *pMiscFlags)
+{
+    if (dxIsSurfaceShareable(pSurface))
+    {
+        *pMiscFlags = D3D11_RESOURCE_MISC_SHARED;
+        return &p3dState->pBackend->dxDevice;
+    }
+
+    *pMiscFlags = 0;
+    return &pDXContext->pBackendDXContext->dxDevice;
+}
+
 static int vmsvga3dBackSurfaceCreateTexture(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
 {
@@ -1695 +1851 @@
 
     UINT MiscFlags;
-    DXDEVICE *pDXDevice;
-    if (dxIsSurfaceShareable(pSurface))
-    {
-        pDXDevice = &pBackend->device;
-        MiscFlags = D3D11_RESOURCE_MISC_SHARED;
-    }
-    else
-    {
-        pDXDevice = &pDXContext->pBackendDXContext->device;
-        MiscFlags = 0;
-    }
+    DXDEVICE *pDXDevice = dxSurfaceDevice(p3dState, pSurface, pDXContext, &MiscFlags);
     AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
@@ -1880 +2026 @@
         if (SUCCEEDED(hr))
         {
-            pBackendSurface->enmResType = VMSVGA3D_RESTYPE_CUBE_TEXTURE;
+            pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE_CUBE;
         }
     }
@@ -2055 +2201 @@
             if (SUCCEEDED(hr))
             {
-                pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE;
+                pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE_2D;
             }
         }
@@ -2093 +2239 @@
 static int vmsvga3dBackSurfaceCreateDepthStencilTexture(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
 {
-    DXDEVICE *pDXDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDXDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
@@ -2120 +2266 @@
     if (pSurface->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
     {
-        AssertFailed(); /** @todo implement */
-        hr = E_FAIL;
+        /*
+         * CubeMap texture.
+         */
+        Assert(pSurface->cFaces == 6);
+        Assert(cWidth == cHeight);
+        Assert(cDepth == 1);
+        Assert(numMipLevels == 1);
+//DEBUG_BREAKPOINT_TEST();
+        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          = 1;
+        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;
+        td.MiscFlags          = D3D11_RESOURCE_MISC_TEXTURECUBE;
+
+        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 | D3D11_CPU_ACCESS_WRITE;
+            td.MiscFlags      = 0;
+            hr = pDXDevice->pDevice->CreateTexture2D(&td, paInitialData, &pBackendSurface->pStagingTexture);
+            Assert(SUCCEEDED(hr));
+        }
+
+        if (SUCCEEDED(hr))
+        {
+            pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE_CUBE;
+        }
     }
     else if (pSurface->surfaceFlags & SVGA3D_SURFACE_1D)
@@ -2141 +2359 @@
              */
             Assert(pSurface->cFaces == 1);
+            Assert(numMipLevels == 1);
 
             D3D11_SUBRESOURCE_DATA *paInitialData = NULL;
@@ -2162 +2381 @@
             td.Width              = cWidth;
             td.Height             = cHeight;
-            Assert(pSurface->cLevels == 1);
             td.MipLevels          = 1;
             td.ArraySize          = 1;
@@ -2200 +2418 @@
             if (SUCCEEDED(hr))
             {
-                pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE;
+                pBackendSurface->enmResType = VMSVGA3D_RESTYPE_TEXTURE_2D;
             }
         }
@@ -2227 +2445 @@
 static int vmsvga3dBackSurfaceCreateBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -2295 +2513 @@
 static int vmsvga3dBackSurfaceCreateSoBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -2344 +2562 @@
 static int vmsvga3dBackSurfaceCreateConstantBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -2443 +2661 @@
 static int vmsvga3dBackSurfaceCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -2603 +2821 @@
     AssertReturn(pBackend, VERR_INVALID_STATE);
 
-    int rc = dxDeviceCreate(pBackend, &pBackend->device);
+    int rc = dxDeviceCreate(pBackend, &pBackend->dxDevice);
     return rc;
 }
 
 
-static DECLCALLBACK(int) vmsvga3dBackTerminate(PVGASTATECC pThisCC)
+static DECLCALLBACK(int) vmsvga3dBackReset(PVGASTATECC pThisCC)
 {
     PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
     AssertReturn(pState, VERR_INVALID_STATE);
 
+    /** @todo This is generic code. Must be moved to in DevVGA-SVGA3d.cpp */
+    /* Destroy all leftover surfaces. */
+    for (uint32_t i = 0; i < pState->cSurfaces; i++)
+    {
+        if (pState->papSurfaces[i]->id != SVGA3D_INVALID_ID)
+            vmsvga3dSurfaceDestroy(pThisCC, pState->papSurfaces[i]->id);
+    }
+
+    /* Destroy all leftover DX contexts. */
+    for (uint32_t i = 0; i < pState->cDXContexts; i++)
+    {
+        if (pState->papDXContexts[i]->cid != SVGA3D_INVALID_ID)
+            vmsvga3dDXDestroyContext(pThisCC, pState->papDXContexts[i]->cid);
+    }
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackTerminate(PVGASTATECC pThisCC)
+{
+    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
+    AssertReturn(pState, VERR_INVALID_STATE);
+
     if (pState->pBackend)
     {
-        /** @todo Clean up backends. */
-
-        dxDeviceDestroy(pState->pBackend, &pState->pBackend->device);
+        /* Clean up backends. For example release resources from surfaces. */
+        vmsvga3dBackReset(pThisCC);
+
+        dxDeviceDestroy(pState->pBackend, &pState->pBackend->dxDevice);
 
         RTMemFree(pState->pBackend);
         pState->pBackend = NULL;
     }
-
-    return VINF_SUCCESS;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackReset(PVGASTATECC pThisCC)
-{
-    PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
-    AssertReturn(pState, VERR_INVALID_STATE);
-
-    /** @todo Cleanup all resources and recreate Device, ImmediateContext etc to be at the same state as after poweron. */
 
     return VINF_SUCCESS;
@@ -2727 +2959 @@
     PVMSVGA3DBACKEND pBackend = pState->pBackend;
 
-    DXDEVICE *pDXDevice = &pBackend->device;
+    DXDEVICE *pDXDevice = &pBackend->dxDevice;
     AssertReturn(pDXDevice->pDevice, VERR_INVALID_STATE);
 
@@ -2957 +3189 @@
             rc = VERR_NOT_SUPPORTED;
     }
-    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE
-             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_CUBE_TEXTURE
+    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
     {
@@ -3151 +3383 @@
         }
     }
-    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE
-             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_CUBE_TEXTURE
+    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE
              || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
     {
@@ -3350 +3582 @@
     if (result == S_OK)
     {
-        pBackend->device.pImmediateContext->CopyResource(pHwScreen->pTexture, pBackendSurface->u.pTexture2D);
-
-        dxDeviceFlush(&pBackend->device);
+        pBackend->dxDevice.pImmediateContext->CopyResource(pHwScreen->pTexture, pBackendSurface->u.pTexture2D);
+
+        dxDeviceFlush(&pBackend->dxDevice);
 
         result = pHwScreen->pDXGIKeyedMutex->ReleaseSync(1);
@@ -3385 +3617 @@
     }
 
-    D3D_FEATURE_LEVEL const FeatureLevel = pState->pBackend->device.FeatureLevel;
+    D3D_FEATURE_LEVEL const FeatureLevel = pState->pBackend->dxDevice.FeatureLevel;
 
     /* Most values are taken from:
@@ -3963 +4195 @@
              pDstSurface ? pDstSurface->idAssociatedContext : SVGA_ID_INVALID));
 
-    //DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    //DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     //AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -3987 +4219 @@
             dxSurfaceWait(pState, pSrcSurface, DX_CID_BACKEND);
 
-            DXDEVICE *pDXDevice = &pBackend->device;
+            DXDEVICE *pDXDevice = &pBackend->dxDevice;
 
             /* Clip the box. */
@@ -4345 +4577 @@
     LogFunc(("sid=%u\n", pSurface->id));
 
+    /* If any views have been created for this resource, then also release them. */
+    DXVIEW *pIter, *pNext;
+    RTListForEachSafe(&pBackendSurface->u2.Texture.listView, pIter, pNext, DXVIEW, nodeSurfaceView)
+    {
+        LogFunc(("pIter=%p, pNext=%p\n", pIter, pNext));
+        dxViewDestroy(pIter);
+    }
+
     if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_SCREEN_TARGET)
     {
@@ -4351 +4591 @@
         D3D_RELEASE(pBackendSurface->u.pTexture2D);
     }
-    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE
-             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_CUBE_TEXTURE)
+    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_CUBE)
     {
         D3D_RELEASE(pBackendSurface->pStagingTexture);
@@ -4377 +4617 @@
     /* No context has created the surface, because the surface does not exist anymore. */
     pSurface->idAssociatedContext = SVGA_ID_INVALID;
+}
+
+
+static DECLCALLBACK(void) vmsvga3dBackSurfaceInvalidateImage(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface, uint32_t uFace, uint32_t uMipmap)
+{
+    RT_NOREF(pThisCC, uFace, uMipmap);
+
+    /* The caller should not use the function for system memory surfaces. */
+    PVMSVGA3DBACKENDSURFACE pBackendSurface = pSurface->pBackendSurface;
+    if (!pBackendSurface)
+        return;
+
+    LogFunc(("sid=%u\n", pSurface->id));
+
+    /* The guest uses this to invalidate a buffer. */
+    if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_BUFFER)
+    {
+        Assert(uFace == 0 && uMipmap == 0); /* The caller ensures this. */
+        vmsvga3dBackSurfaceDestroy(pThisCC, pSurface);
+    }
+    else
+    {
+        /** @todo Delete views that have been created for this mipmap.
+         * For now just delete all views, they will be recte=reated if necessary.
+         */
+        ASSERT_GUEST_FAILED();
+        DXVIEW *pIter, *pNext;
+        RTListForEachSafe(&pBackendSurface->u2.Texture.listView, pIter, pNext, DXVIEW, nodeSurfaceView)
+        {
+            dxViewDestroy(pIter);
+        }
+    }
 }
 
@@ -4519 +4791 @@
 #endif
     }
-    else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE)
+    else if (   pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_2D
+             || pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
     {
         /** @todo This is generic code and should be in DevVGA-SVGA3d.cpp for backends which support Map/Unmap. */
@@ -4530 +4803 @@
         uint32_t const cBlocksX = (pBox->w + pSurface->cxBlock - 1) / pSurface->cxBlock;
         uint32_t const cBlocksY = (pBox->h + pSurface->cyBlock - 1) / pSurface->cyBlock;
-        AssertMsgReturn(cBlocksX && cBlocksY, ("Empty box %dx%d\n", pBox->w, pBox->h), VERR_INTERNAL_ERROR);
+        AssertMsgReturn(cBlocksX && cBlocksY && pBox->d, ("Empty box %dx%dx%d\n", pBox->w, pBox->h, pBox->d), VERR_INTERNAL_ERROR);
 
         /* vmsvgaR3GmrTransfer verifies uGuestOffset.
@@ -4536 +4809 @@
          * to not cause 32 bit overflow when multiplied by cbBlock and cbGuestPitch.
          */
-        uint64_t const uGuestOffset = u32GuestBlockX * pSurface->cbBlock + u32GuestBlockY * cbGuestPitch;
+        uint64_t uGuestOffset = u32GuestBlockX * pSurface->cbBlock + u32GuestBlockY * cbGuestPitch;
         AssertReturn(uGuestOffset < UINT32_MAX, VERR_INVALID_PARAMETER);
+
+        /* 3D texture needs additional processing. */
+        ASSERT_GUEST_RETURN(   pBox->z < D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION
+                            && pBox->d <= D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION
+                            && pBox->d <= D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION - pBox->z,
+                            VERR_INVALID_PARAMETER);
+        ASSERT_GUEST_RETURN(   pBox->srcz < D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION
+                            && pBox->d <= D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION
+                            && pBox->d <= D3D11_REQ_TEXTURE3D_U_V_OR_W_DIMENSION - pBox->srcz,
+                            VERR_INVALID_PARAMETER);
+
+        uGuestOffset += pBox->srcz * pMipLevel->cbSurfacePlane;
 
         SVGA3dSurfaceImageId image;
@@ -4547 +4832 @@
         box.x = pBox->x;
         box.y = pBox->y;
-        box.z = 0;
+        box.z = pBox->z;
         box.w = pBox->w;
         box.h = pBox->h;
-        box.d = 1;
+        box.d = pBox->d;
 
         VMSVGA3D_SURFACE_MAP const enmMap = transfer == SVGA3D_WRITE_HOST_VRAM
@@ -4570 +4855 @@
              * and offset of the first scanline.
              */
-            uint32_t const cbLockedBuf = map.cbRowPitch * cBlocksY;
+            uint32_t cbLockedBuf = map.cbRowPitch * cBlocksY;
+            if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_TEXTURE_3D)
+                cbLockedBuf += map.cbDepthPitch * (pBox->d - 1); /// @todo why map does not compute this for 2D textures
             uint8_t *pu8LockedBuf = (uint8_t *)map.pvData;
-            uint32_t const offLockedBuf = 0;
-
-            rc = vmsvgaR3GmrTransfer(pThis,
-                                     pThisCC,
-                                     transfer,
-                                     pu8LockedBuf,
-                                     cbLockedBuf,
-                                     offLockedBuf,
-                                     map.cbRowPitch,
-                                     GuestPtr,
-                                     (uint32_t)uGuestOffset,
-                                     cbGuestPitch,
-                                     cBlocksX * pSurface->cbBlock,
-                                     cBlocksY);
-            AssertRC(rc);
+            uint32_t offLockedBuf = 0;
+
+            for (uint32_t iPlane = 0; iPlane < pBox->d; ++iPlane)
+            {
+                AssertBreak(uGuestOffset < UINT32_MAX);
+
+                rc = vmsvgaR3GmrTransfer(pThis,
+                                         pThisCC,
+                                         transfer,
+                                         pu8LockedBuf,
+                                         cbLockedBuf,
+                                         offLockedBuf,
+                                         map.cbRowPitch,
+                                         GuestPtr,
+                                         (uint32_t)uGuestOffset,
+                                         cbGuestPitch,
+                                         cBlocksX * pSurface->cbBlock,
+                                         cBlocksY);
+                AssertRC(rc);
+
+                uGuestOffset += pMipLevel->cbSurfacePlane;
+                offLockedBuf += map.cbDepthPitch;
+            }
 
             bool const fWritten = (transfer == SVGA3D_WRITE_HOST_VRAM);
@@ -4681 +4976 @@
     LogFunc(("cid %d\n", pDXContext->cid));
 
-    int rc = dxDeviceCreate(pBackend, &pBackendDXContext->device);
+    int rc = dxDeviceCreate(pBackend, &pBackendDXContext->dxDevice);
     return rc;
 }
@@ -4697 +4992 @@
         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->paRenderTargetView)
+        {
+            for (uint32_t i = 0; i < pBackendDXContext->cRenderTargetView; ++i)
+                D3D_RELEASE(pBackendDXContext->paRenderTargetView[i].u.pRenderTargetView);
+        }
+        if (pBackendDXContext->paDepthStencilView)
+        {
+            for (uint32_t i = 0; i < pBackendDXContext->cDepthStencilView; ++i)
+                D3D_RELEASE(pBackendDXContext->paDepthStencilView[i].u.pDepthStencilView);
+        }
+        if (pBackendDXContext->paShaderResourceView)
+        {
+            for (uint32_t i = 0; i < pBackendDXContext->cShaderResourceView; ++i)
+                D3D_RELEASE(pBackendDXContext->paShaderResourceView[i].u.pShaderResourceView);
+        }
         if (pBackendDXContext->paElementLayout)
         {
@@ -4734 +5038 @@
         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->paRenderTargetView, sizeof(pBackendDXContext->paRenderTargetView[0]) * pBackendDXContext->cRenderTargetView);
+        RTMemFreeZ(pBackendDXContext->paDepthStencilView, sizeof(pBackendDXContext->paDepthStencilView[0]) * pBackendDXContext->cDepthStencilView);
+        RTMemFreeZ(pBackendDXContext->paShaderResourceView, sizeof(pBackendDXContext->paShaderResourceView[0]) * pBackendDXContext->cShaderResourceView);
         RTMemFreeZ(pBackendDXContext->papQuery, sizeof(pBackendDXContext->papQuery[0]) * pBackendDXContext->cQuery);
         RTMemFreeZ(pBackendDXContext->paShader, sizeof(pBackendDXContext->paShader[0]) * pBackendDXContext->cShader);
@@ -4770 +5074 @@
         }
 
-        dxDeviceDestroy(pBackend, &pBackendDXContext->device);
+        dxDeviceDestroy(pBackend, &pBackendDXContext->dxDevice);
 
         RTMemFreeZ(pBackendDXContext, sizeof(*pBackendDXContext));
@@ -4810 +5114 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -4866 +5170 @@
 }
 
-
-static DECLCALLBACK(int) vmsvga3dBackDXSetShaderResources(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t startView, SVGA3dShaderType type, uint32_t cShaderResourceViewId, SVGA3dShaderResourceViewId const *paShaderResourceViewId)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    RT_NOREF(pBackend);
-
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+static int dxSetShaderResources(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderType type)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
+//DEBUG_BREAKPOINT_TEST();
+    AssertReturn(type >= SVGA3D_SHADERTYPE_MIN && type < SVGA3D_SHADERTYPE_MAX, VERR_INVALID_PARAMETER);
     uint32_t const idxShaderState = type - SVGA3D_SHADERTYPE_MIN;
+    uint32_t const *pSRIds = &pDXContext->svgaDXContext.shaderState[idxShaderState].shaderResources[0];
     ID3D11ShaderResourceView *papShaderResourceView[SVGA3D_DX_MAX_SRVIEWS];
-    for (uint32_t i = 0; i < cShaderResourceViewId; ++i)
-    {
-        SVGA3dShaderResourceViewId shaderResourceViewId = paShaderResourceViewId[i];
+    for (uint32_t i = 0; i < SVGA3D_DX_MAX_SRVIEWS; ++i)
+    {
+        SVGA3dShaderResourceViewId shaderResourceViewId = pSRIds[i];
         if (shaderResourceViewId != SVGA3D_INVALID_ID)
         {
             ASSERT_GUEST_RETURN(shaderResourceViewId < pDXContext->pBackendDXContext->cShaderResourceView, VERR_INVALID_PARAMETER);
-            papShaderResourceView[i] = pDXContext->pBackendDXContext->papShaderResourceView[shaderResourceViewId];
+
+            DXVIEW *pDXView = &pDXContext->pBackendDXContext->paShaderResourceView[shaderResourceViewId];
+            Assert(pDXView->u.pShaderResourceView);
+            papShaderResourceView[i] = pDXView->u.pShaderResourceView;
         }
         else
             papShaderResourceView[i] = NULL;
-
-        pDXContext->svgaDXContext.shaderState[idxShaderState].shaderResources[startView + i] = shaderResourceViewId;
-    }
-
-    dxShaderResourceViewSet(pDevice, type, startView, cShaderResourceViewId, papShaderResourceView);
+    }
+
+    dxShaderResourceViewSet(pDevice, type, 0, SVGA3D_DX_MAX_SRVIEWS, papShaderResourceView);
     return VINF_SUCCESS;
 }
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXSetShaderResources(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t startView, SVGA3dShaderType type, uint32_t cShaderResourceViewId, SVGA3dShaderResourceViewId const *paShaderResourceViewId)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    RT_NOREF(startView, type, cShaderResourceViewId, paShaderResourceViewId);
+
+    return VINF_SUCCESS;
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXSetShader(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderType type, PVMSVGA3DSHADER pShader)
 {
@@ -4901 +5219 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -4916 +5234 @@
         pDXShader = NULL;
 
-    dxShaderSet(pDXContext, type, pDXShader);
+    dxShaderSet(pThisCC, pDXContext, type, pDXShader);
     return VINF_SUCCESS;
 }
@@ -4926 +5244 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -4956 +5274 @@
     AssertCompile(RT_ELEMENTS(pDXContext->svgaDXContext.shaderState[0].shaderResources) == SVGA3D_DX_MAX_SRVIEWS);
 
-    for (uint32_t idxShaderState = 0; idxShaderState < SVGA3D_NUM_SHADERTYPE; ++idxShaderState)
-    {
-        for (uint32_t idxSR = 0; idxSR < SVGA3D_NUM_SHADERTYPE; ++idxSR)
+    int rc;
+
+    /* Unbind render target views because they mught be (re-)used as shader resource views. */
+    DXDEVICE *pDXDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    pDXDevice->pImmediateContext->OMSetRenderTargets(0, NULL, NULL);
+
+    /* Make sure that the shader resource views exist. */
+    for (uint32_t idxShaderState = 0; idxShaderState < SVGA3D_NUM_SHADERTYPE_DX10 /** @todo SVGA3D_NUM_SHADERTYPE*/; ++idxShaderState)
+    {
+        for (uint32_t idxSR = 0; idxSR < SVGA3D_DX_MAX_SRVIEWS; ++idxSR)
         {
             SVGA3dShaderResourceViewId const shaderResourceViewId = pDXContext->svgaDXContext.shaderState[idxShaderState].shaderResources[idxSR];
@@ -4965 +5290 @@
                 ASSERT_GUEST_RETURN_VOID(shaderResourceViewId < pDXContext->pBackendDXContext->cShaderResourceView);
 
-                uint32_t const sid = dxGetShaderResourceViewSid(pDXContext, shaderResourceViewId);
+                SVGACOTableDXSRViewEntry const *pSRViewEntry = dxGetShaderResourceViewEntry(pDXContext, shaderResourceViewId);
+                AssertContinue(pSRViewEntry != NULL);
+
+                uint32_t const sid = pSRViewEntry->sid;
 
                 PVMSVGA3DSURFACE pSurface;
-                int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, sid, &pSurface);
+                rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, sid, &pSurface);
                 AssertRCReturnVoid(rc);
 
-                /** @todo The guest might have invalidated the surface. */
-                AssertContinue(pSurface->pBackendSurface);
-
-                /* Wait for the surface to finish drawing. */
-                dxSurfaceWait(pThisCC->svga.p3dState, pSurface, pDXContext->cid);
+                /* The guest might have invalidated the surface in which case pSurface->pBackendSurface is NULL. */
+                /** @todo This is not needed for "single DX device" mode. */
+                if (pSurface->pBackendSurface)
+                {
+                    /* Wait for the surface to finish drawing. */
+                    dxSurfaceWait(pThisCC->svga.p3dState, pSurface, pDXContext->cid);
+                }
+
+                /* If a view has not been created yet, do it now. */
+                if (!pDXContext->pBackendDXContext->paShaderResourceView[shaderResourceViewId].u.pView)
+                {
+//DEBUG_BREAKPOINT_TEST();
+                    LogFunc(("Re-creating SRV: sid=%u srvid = %u\n", sid, shaderResourceViewId));
+                    rc = dxDefineShaderResourceView(pThisCC, pDXContext, shaderResourceViewId, pSRViewEntry);
+                    AssertContinue(RT_SUCCESS(rc));
+                }
             }
         }
-    }
-
-#ifdef DX_DEFERRED_SET_RENDER_TARGETS
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+
+        /* Set shader resources. */
+        rc = dxSetShaderResources(pThisCC, pDXContext, (SVGA3dShaderType)(idxShaderState + SVGA3D_SHADERTYPE_MIN));
+        AssertRC(rc);
+    }
+
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturnVoid(pDevice->pDevice);
 
-    pDevice->pImmediateContext->OMSetRenderTargets(pDXContext->pBackendDXContext->state.cRenderTargetViews,
-                                                   pDXContext->pBackendDXContext->state.papRenderTargetViews,
-                                                   pDXContext->pBackendDXContext->state.pDepthStencilView);
-#endif
+    /** @todo Make sure that the render target views exist. Similar to SRVs. */
+    if (pDXContext->svgaDXContext.renderState.depthStencilViewId != SVGA3D_INVALID_ID)
+    {
+        uint32_t const viewId = pDXContext->svgaDXContext.renderState.depthStencilViewId;
+
+        ASSERT_GUEST_RETURN_VOID(viewId < pDXContext->pBackendDXContext->cDepthStencilView);
+
+        SVGACOTableDXDSViewEntry const *pDSViewEntry = dxGetDepthStencilViewEntry(pDXContext, viewId);
+        AssertReturnVoid(pDSViewEntry != NULL);
+
+        PVMSVGA3DSURFACE pSurface;
+        rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pDSViewEntry->sid, &pSurface);
+        AssertRCReturnVoid(rc);
+
+        /* If a view has not been created yet, do it now. */
+        if (!pDXContext->pBackendDXContext->paDepthStencilView[viewId].u.pView)
+        {
+//DEBUG_BREAKPOINT_TEST();
+            LogFunc(("Re-creating DSV: sid=%u dsvid = %u\n", pDSViewEntry->sid, viewId));
+            rc = dxDefineDepthStencilView(pThisCC, pDXContext, viewId, pDSViewEntry);
+            AssertReturnVoid(RT_SUCCESS(rc));
+        }
+    }
+
+    for (uint32_t i = 0; i < SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS; ++i)
+    {
+        if (pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] != SVGA3D_INVALID_ID)
+        {
+            uint32_t const viewId = pDXContext->svgaDXContext.renderState.renderTargetViewIds[i];
+
+            ASSERT_GUEST_RETURN_VOID(viewId < pDXContext->pBackendDXContext->cRenderTargetView);
+
+            SVGACOTableDXRTViewEntry const *pRTViewEntry = dxGetRenderTargetViewEntry(pDXContext, viewId);
+            AssertReturnVoid(pRTViewEntry != NULL);
+
+            PVMSVGA3DSURFACE pSurface;
+            rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pRTViewEntry->sid, &pSurface);
+            AssertRCReturnVoid(rc);
+
+            /* If a view has not been created yet, do it now. */
+            if (!pDXContext->pBackendDXContext->paRenderTargetView[viewId].u.pView)
+            {
+//DEBUG_BREAKPOINT_TEST();
+                LogFunc(("Re-creating RTV: sid=%u rtvid = %u\n", pRTViewEntry->sid, viewId));
+                rc = dxDefineRenderTargetView(pThisCC, pDXContext, viewId, pRTViewEntry);
+                AssertReturnVoid(RT_SUCCESS(rc));
+            }
+        }
+    }
+
+    /* Set render targets. */
+    rc = dxSetRenderTargets(pThisCC, pDXContext);
+    AssertRC(rc);
 }
 
@@ -4996 +5388 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5246 +5638 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5271 +5663 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5293 +5685 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5327 +5719 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5362 +5754 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5443 +5835 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5553 +5945 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5562 +5954 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXSetRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilViewId depthStencilViewId, uint32_t cRenderTargetViewId, SVGA3dRenderTargetViewId const *paRenderTargetViewId)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    RT_NOREF(pBackend);
-
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+static int dxSetRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+{
+    //pDXContext->svgaDXContext.renderState.depthStencilViewId = depthStencilViewId;
+    //for (uint32_t i = 0; i < cRenderTargetViewId; ++i)
+    //    pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] = paRenderTargetViewId[i];
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
-    ID3D11RenderTargetView *papRenderTargetViews[SVGA3D_MAX_RENDER_TARGETS];
-    RT_ZERO(papRenderTargetViews);
-    for (uint32_t i = 0; i < cRenderTargetViewId; ++i)
-    {
-        SVGA3dRenderTargetViewId const renderTargetViewId = paRenderTargetViewId[i];
+    ID3D11RenderTargetView *apRenderTargetViews[SVGA3D_MAX_RENDER_TARGETS];
+    RT_ZERO(apRenderTargetViews);
+    for (uint32_t i = 0; i < SVGA3D_MAX_RENDER_TARGETS; ++i)
+    {
+        SVGA3dRenderTargetViewId const renderTargetViewId = pDXContext->svgaDXContext.renderState.renderTargetViewIds[i];
         if (renderTargetViewId != SVGA3D_INVALID_ID)
         {
             ASSERT_GUEST_RETURN(renderTargetViewId < pDXContext->pBackendDXContext->cRenderTargetView, VERR_INVALID_PARAMETER);
-            papRenderTargetViews[i] = pDXContext->pBackendDXContext->papRenderTargetView[renderTargetViewId];
+            apRenderTargetViews[i] = pDXContext->pBackendDXContext->paRenderTargetView[renderTargetViewId].u.pRenderTargetView;
         }
     }
 
-    ID3D11DepthStencilView *pDepthStencilView;
+    ID3D11DepthStencilView *pDepthStencilView = NULL;
+    SVGA3dDepthStencilViewId const depthStencilViewId = pDXContext->svgaDXContext.renderState.depthStencilViewId;
     if (depthStencilViewId != SVGA_ID_INVALID)
-        pDepthStencilView = pDXContext->pBackendDXContext->papDepthStencilView[depthStencilViewId];
-    else
-        pDepthStencilView = NULL;
-
-#ifdef DX_DEFERRED_SET_RENDER_TARGETS
-    memcpy(pDXContext->pBackendDXContext->state.papRenderTargetViews, papRenderTargetViews, sizeof(papRenderTargetViews));
-    pDXContext->pBackendDXContext->state.cRenderTargetViews = cRenderTargetViewId;
-    pDXContext->pBackendDXContext->state.pDepthStencilView = pDepthStencilView;
-    pDevice->pImmediateContext->OMSetRenderTargets(0, NULL, NULL);
-#else
-    pDevice->pImmediateContext->OMSetRenderTargets(cRenderTargetViewId, papRenderTargetViews, pDepthStencilView);
-#endif
+        pDepthStencilView = pDXContext->pBackendDXContext->paDepthStencilView[depthStencilViewId].u.pDepthStencilView;
+
+    pDevice->pImmediateContext->OMSetRenderTargets(SVGA3D_MAX_RENDER_TARGETS,
+                                                   apRenderTargetViews,
+                                                   pDepthStencilView);
     return VINF_SUCCESS;
 }
 
 
+static DECLCALLBACK(int) vmsvga3dBackDXSetRenderTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilViewId depthStencilViewId, uint32_t cRenderTargetViewId, SVGA3dRenderTargetViewId const *paRenderTargetViewId)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    RT_NOREF(depthStencilViewId, cRenderTargetViewId, paRenderTargetViewId);
+
+    return VINF_SUCCESS;
+}
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXSetBlendState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dBlendStateId blendId, float const blendFactor[4], uint32_t sampleMask)
 {
@@ -5605 +6006 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5627 +6028 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5643 +6044 @@
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5738 +6139 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5795 +6196 @@
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5813 +6214 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5829 +6230 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
-    ID3D11RenderTargetView *pRenderTargetView = pDXContext->pBackendDXContext->papRenderTargetView[renderTargetViewId];
-    AssertReturn(pRenderTargetView, VERR_INVALID_STATE);
-    pDevice->pImmediateContext->ClearRenderTargetView(pRenderTargetView, pRGBA->value);
+    DXVIEW *pDXView = &pDXContext->pBackendDXContext->paRenderTargetView[renderTargetViewId];
+    if (!pDXView->u.pRenderTargetView)
+    {
+//DEBUG_BREAKPOINT_TEST();
+        /* (Re-)create the render target view, because a creation of a view is deferred until a draw or a clear call. */
+        SVGACOTableDXRTViewEntry const *pEntry = &pDXContext->cot.paRTView[renderTargetViewId];
+        int rc = dxDefineRenderTargetView(pThisCC, pDXContext, renderTargetViewId, pEntry);
+        AssertRCReturn(rc, rc);
+    }
+    pDevice->pImmediateContext->ClearRenderTargetView(pDXView->u.pRenderTargetView, pRGBA->value);
     return VINF_SUCCESS;
 }
@@ -5844 +6252 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
-    ID3D11DepthStencilView *pDepthStencilView = pDXContext->pBackendDXContext->papDepthStencilView[depthStencilViewId];
-    AssertReturn(pDepthStencilView, VERR_INVALID_STATE);
-    pDevice->pImmediateContext->ClearDepthStencilView(pDepthStencilView, flags, depth, stencil);
+    DXVIEW *pDXView = &pDXContext->pBackendDXContext->paDepthStencilView[depthStencilViewId];
+    if (!pDXView->u.pDepthStencilView)
+    {
+//DEBUG_BREAKPOINT_TEST();
+        /* (Re-)create the depth stencil view, because a creation of a view is deferred until a draw or a clear call. */
+        SVGACOTableDXDSViewEntry const *pEntry = &pDXContext->cot.paDSView[depthStencilViewId];
+        int rc = dxDefineDepthStencilView(pThisCC, pDXContext, depthStencilViewId, pEntry);
+        AssertRCReturn(rc, rc);
+    }
+    pDevice->pImmediateContext->ClearDepthStencilView(pDXView->u.pDepthStencilView, flags, depth, stencil);
     return VINF_SUCCESS;
 }
@@ -5859 +6274 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -5964 +6379 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
-    ID3D11ShaderResourceView *pShaderResourceView = pDXContext->pBackendDXContext->papShaderResourceView[shaderResourceViewId];
+    ID3D11ShaderResourceView *pShaderResourceView = pDXContext->pBackendDXContext->paShaderResourceView[shaderResourceViewId].u.pShaderResourceView;
     AssertReturn(pShaderResourceView, VERR_INVALID_STATE);
 
-    uint32_t const sid = dxGetShaderResourceViewSid(pDXContext, shaderResourceViewId);
+    SVGACOTableDXSRViewEntry const *pSRViewEntry = dxGetShaderResourceViewEntry(pDXContext, shaderResourceViewId);
+    AssertReturn(pSRViewEntry, VERR_INVALID_STATE);
+
+    uint32_t const sid = pSRViewEntry->sid;
 
     PVMSVGA3DSURFACE pSurface;
@@ -5991 +6409 @@
     AssertRCReturn(rc, rc);
 
+    ID3D11ShaderResourceView *pShaderResourceView;
+    DXVIEW *pView = &pDXContext->pBackendDXContext->paShaderResourceView[shaderResourceViewId];
+    Assert(pView->u.pView == NULL);
+
     if (pSurface->pBackendSurface == NULL)
     {
@@ -5998 +6420 @@
     }
 
-    HRESULT hr = dxShaderResourceViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papShaderResourceView[shaderResourceViewId]);
-    if (SUCCEEDED(hr))
-        return VINF_SUCCESS;
-    return VERR_INVALID_STATE;
+    HRESULT hr = dxShaderResourceViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pShaderResourceView);
+    AssertReturn(SUCCEEDED(hr), VERR_INVALID_STATE);
+
+    return dxViewInit(pView, pSurface, pDXContext, shaderResourceViewId, VMSVGA3D_VIEWTYPE_SHADERRESOURCE, pShaderResourceView);
 }
 
@@ -6010 +6432 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6022 +6444 @@
     RT_NOREF(pBackend);
 
-    D3D_RELEASE(pDXContext->pBackendDXContext->papShaderResourceView[shaderResourceViewId]);
-    return VINF_SUCCESS;
+    return dxViewDestroy(&pDXContext->pBackendDXContext->paShaderResourceView[shaderResourceViewId]);
 }
 
@@ -6034 +6455 @@
     AssertRCReturn(rc, rc);
 
+    DXVIEW *pView = &pDXContext->pBackendDXContext->paRenderTargetView[renderTargetViewId];
+    Assert(pView->u.pView == NULL);
+
     if (pSurface->pBackendSurface == NULL)
     {
@@ -6041 +6465 @@
     }
 
-    HRESULT hr = dxRenderTargetViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papRenderTargetView[renderTargetViewId]);
-    if (SUCCEEDED(hr))
-        return VINF_SUCCESS;
-
-    return VERR_INVALID_STATE;
+    ID3D11RenderTargetView *pRenderTargetView;
+    HRESULT hr = dxRenderTargetViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pRenderTargetView);
+    AssertReturn(SUCCEEDED(hr), VERR_INVALID_STATE);
+
+    return dxViewInit(pView, pSurface, pDXContext, renderTargetViewId, VMSVGA3D_VIEWTYPE_RENDERTARGET, pRenderTargetView);
 }
 
@@ -6054 +6478 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6066 +6490 @@
     RT_NOREF(pBackend);
 
-    D3D_RELEASE(pDXContext->pBackendDXContext->papRenderTargetView[renderTargetViewId]);
-    return VINF_SUCCESS;
+    return dxViewDestroy(&pDXContext->pBackendDXContext->paRenderTargetView[renderTargetViewId]);
 }
 
@@ -6078 +6501 @@
     AssertRCReturn(rc, rc);
 
+    DXVIEW *pView = &pDXContext->pBackendDXContext->paDepthStencilView[depthStencilViewId];
+    Assert(pView->u.pView == NULL);
+
     if (   pSurface->pBackendSurface != NULL
         && pDXContext->cid != pSurface->idAssociatedContext)
@@ -6092 +6518 @@
     }
 
-    HRESULT hr = dxDepthStencilViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pDXContext->pBackendDXContext->papDepthStencilView[depthStencilViewId]);
-    if (SUCCEEDED(hr))
-        return VINF_SUCCESS;
-    return VERR_INVALID_STATE;
+    ID3D11DepthStencilView *pDepthStencilView;
+    HRESULT hr = dxDepthStencilViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pDepthStencilView);
+    AssertReturn(SUCCEEDED(hr), VERR_INVALID_STATE);
+
+    return dxViewInit(pView, pSurface, pDXContext, depthStencilViewId, VMSVGA3D_VIEWTYPE_DEPTHSTENCIL, pDepthStencilView);
 }
 
@@ -6103 +6530 @@
     RT_NOREF(pBackend);
 
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6115 +6542 @@
     RT_NOREF(pBackend);
 
-    D3D_RELEASE(pDXContext->pBackendDXContext->papDepthStencilView[depthStencilViewId]);
-    return VINF_SUCCESS;
+    return dxViewDestroy(&pDXContext->pBackendDXContext->paDepthStencilView[depthStencilViewId]);
 }
 
@@ -6157 +6583 @@
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6183 +6609 @@
 
 
-static int dxDefineBlendState(PVMSVGA3DDXCONTEXT pDXContext,
+static int dxDefineBlendState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext,
                               SVGA3dBlendStateId blendId, SVGACOTableDXBlendStateEntry const *pEntry)
 {
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6201 +6627 @@
     RT_NOREF(pBackend);
 
-    return dxDefineBlendState(pDXContext, blendId, pEntry);
+    return dxDefineBlendState(pThisCC, pDXContext, blendId, pEntry);
 }
 
@@ -6215 +6641 @@
 
 
-static int dxDefineDepthStencilState(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilStateId depthStencilId, SVGACOTableDXDepthStencilEntry const *pEntry)
-{
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+static int dxDefineDepthStencilState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dDepthStencilStateId depthStencilId, SVGACOTableDXDepthStencilEntry const *pEntry)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6232 +6658 @@
     RT_NOREF(pBackend);
 
-    return dxDefineDepthStencilState(pDXContext, depthStencilId, pEntry);
+    return dxDefineDepthStencilState(pThisCC, pDXContext, depthStencilId, pEntry);
 }
 
@@ -6246 +6672 @@
 
 
-static int dxDefineRasterizerState(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRasterizerStateId rasterizerId, SVGACOTableDXRasterizerStateEntry const *pEntry)
-{
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+static int dxDefineRasterizerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dRasterizerStateId rasterizerId, SVGACOTableDXRasterizerStateEntry const *pEntry)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6263 +6689 @@
     RT_NOREF(pBackend);
 
-    return dxDefineRasterizerState(pDXContext, rasterizerId, pEntry);
+    return dxDefineRasterizerState(pThisCC, pDXContext, rasterizerId, pEntry);
 }
 
@@ -6277 +6703 @@
 
 
-static int dxDefineSamplerState(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dSamplerId samplerId, SVGACOTableDXSamplerEntry const *pEntry)
-{
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+static int dxDefineSamplerState(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dSamplerId samplerId, SVGACOTableDXSamplerEntry const *pEntry)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6294 +6720 @@
     RT_NOREF(pBackend);
 
-    return dxDefineSamplerState(pDXContext, samplerId, pEntry);
+    return dxDefineSamplerState(pThisCC, pDXContext, samplerId, pEntry);
 }
 
@@ -6366 +6792 @@
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
@@ -6403 +6829 @@
 #endif
 
-            HRESULT hr = dxShaderCreate(pDXContext, pShader, pDXShader);
+            HRESULT hr = dxShaderCreate(pThisCC, pDXContext, pShader, pDXShader);
             if (SUCCEEDED(hr))
             {
@@ -6500 +6926 @@
         case SVGA_COTABLE_RTVIEW:
             /* Clear current entries. */
-            if (pBackendDXContext->papRenderTargetView)
+            if (pBackendDXContext->paRenderTargetView)
             {
-                for (uint32_t i = cValidEntries; i < pBackendDXContext->cRenderTargetView; ++i)
-                    D3D_RELEASE(pBackendDXContext->papRenderTargetView[i]);
+                for (uint32_t i = 0; i < pBackendDXContext->cRenderTargetView; ++i)
+                {
+                    DXVIEW *pDXView = &pBackendDXContext->paRenderTargetView[i];
+                    if (i < cValidEntries)
+                        dxViewRemoveFromList(pDXView); /* Remove from list because DXVIEW array will be reallocated. */
+                    else
+                        dxViewDestroy(pDXView);
+                }
             }
 
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papRenderTargetView, &pBackendDXContext->cRenderTargetView,
-                                  sizeof(pBackendDXContext->papRenderTargetView[0]), pDXContext->cot.cRTView, cValidEntries);
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->paRenderTargetView, &pBackendDXContext->cRenderTargetView,
+                                  sizeof(pBackendDXContext->paRenderTargetView[0]), pDXContext->cot.cRTView, cValidEntries);
             AssertRCBreak(rc);
 
@@ -6516 +6948 @@
                     continue; /* Skip uninitialized entry. */
 
-                dxDefineRenderTargetView(pThisCC, pDXContext, i, pEntry);
+                DXVIEW *pDXView = &pBackendDXContext->paRenderTargetView[i];
+                /** @todo Verify that the pEntry content still corresponds to the view. */
+                if (pDXView->u.pView)
+                    dxViewAddToList(pThisCC, pDXView);
             }
             break;
         case SVGA_COTABLE_DSVIEW:
-            if (pBackendDXContext->papDepthStencilView)
+            if (pBackendDXContext->paDepthStencilView)
             {
-                for (uint32_t i = cValidEntries; i < pBackendDXContext->cDepthStencilView; ++i)
-                    D3D_RELEASE(pBackendDXContext->papDepthStencilView[i]);
+                for (uint32_t i = 0; i < pBackendDXContext->cDepthStencilView; ++i)
+                {
+                    DXVIEW *pDXView = &pBackendDXContext->paDepthStencilView[i];
+                    if (i < cValidEntries)
+                        dxViewRemoveFromList(pDXView); /* Remove from list because DXVIEW array will be reallocated. */
+                    else
+                        dxViewDestroy(pDXView);
+                }
             }
 
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papDepthStencilView, &pBackendDXContext->cDepthStencilView,
-                                  sizeof(pBackendDXContext->papDepthStencilView[0]), pDXContext->cot.cDSView, cValidEntries);
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->paDepthStencilView, &pBackendDXContext->cDepthStencilView,
+                                  sizeof(pBackendDXContext->paDepthStencilView[0]), pDXContext->cot.cDSView, cValidEntries);
             AssertRCBreak(rc);
 
@@ -6536 +6977 @@
                     continue; /* Skip uninitialized entry. */
 
-                dxDefineDepthStencilView(pThisCC, pDXContext, i, pEntry);
+                DXVIEW *pDXView = &pBackendDXContext->paDepthStencilView[i];
+                /** @todo Verify that the pEntry content still corresponds to the view. */
+                if (pDXView->u.pView)
+                    dxViewAddToList(pThisCC, pDXView);
             }
             break;
         case SVGA_COTABLE_SRVIEW:
-            if (pBackendDXContext->papShaderResourceView)
+            if (pBackendDXContext->paShaderResourceView)
             {
-                for (uint32_t i = cValidEntries; i < pBackendDXContext->cShaderResourceView; ++i)
-                    D3D_RELEASE(pBackendDXContext->papShaderResourceView[i]);
+                for (uint32_t i = 0; i < pBackendDXContext->cShaderResourceView; ++i)
+                {
+                    DXVIEW *pDXView = &pBackendDXContext->paShaderResourceView[i];
+                    if (i < cValidEntries)
+                        dxViewRemoveFromList(pDXView); /* Remove from list because DXVIEW array will be reallocated. */
+                    else
+                        dxViewDestroy(pDXView);
+                }
             }
 
-            rc = dxCOTableRealloc((void **)&pBackendDXContext->papShaderResourceView, &pBackendDXContext->cShaderResourceView,
-                                  sizeof(pBackendDXContext->papShaderResourceView[0]), pDXContext->cot.cSRView, cValidEntries);
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->paShaderResourceView, &pBackendDXContext->cShaderResourceView,
+                                  sizeof(pBackendDXContext->paShaderResourceView[0]), pDXContext->cot.cSRView, cValidEntries);
             AssertRCBreak(rc);
 
@@ -6556 +7006 @@
                     continue; /* Skip uninitialized entry. */
 
-                dxDefineShaderResourceView(pThisCC, pDXContext, i, pEntry);
+                DXVIEW *pDXView = &pBackendDXContext->paShaderResourceView[i];
+                /** @todo Verify that the pEntry content still corresponds to the view. */
+                if (pDXView->u.pView)
+                    dxViewAddToList(pThisCC, pDXView);
             }
             break;
@@ -6596 +7049 @@
                     continue; /* Skip uninitialized entry. */
 
-                dxDefineBlendState(pDXContext, i, pEntry);
+                dxDefineBlendState(pThisCC, pDXContext, i, pEntry);
             }
             break;
@@ -6616 +7069 @@
                     continue; /* Skip uninitialized entry. */
 
-                dxDefineDepthStencilState(pDXContext, i, pEntry);
+                dxDefineDepthStencilState(pThisCC, pDXContext, i, pEntry);
             }
             break;
@@ -6636 +7089 @@
                     continue; /* Skip uninitialized entry. */
 
-                dxDefineRasterizerState(pDXContext, i, pEntry);
+                dxDefineRasterizerState(pThisCC, pDXContext, i, pEntry);
             }
             break;
@@ -6656 +7109 @@
                     continue; /* Skip uninitialized entry. */
 
-                dxDefineSamplerState(pDXContext, i, pEntry);
+                dxDefineSamplerState(pThisCC, pDXContext, i, pEntry);
             }
             break;
@@ -7465 +7918 @@
                 p->pfnCreateTexture            = vmsvga3dBackCreateTexture;
                 p->pfnSurfaceDestroy           = vmsvga3dBackSurfaceDestroy;
+                p->pfnSurfaceInvalidateImage   = vmsvga3dBackSurfaceInvalidateImage;
                 p->pfnSurfaceCopy              = vmsvga3dBackSurfaceCopy;
                 p->pfnSurfaceDMACopyBox        = vmsvga3dBackSurfaceDMACopyBox;

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

@@ -1171 +1171 @@
 
 
+static DECLCALLBACK(void) vmsvga3dBackSurfaceInvalidateImage(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface, uint32_t uFace, uint32_t uMipmap)
+{
+    RT_NOREF(pThisCC, pSurface, uFace, uMipmap);
+}
+
+
 /*
  * Release all shared surface objects.
@@ -6385 +6391 @@
                 p->pfnCreateTexture            = vmsvga3dBackCreateTexture;
                 p->pfnSurfaceDestroy           = vmsvga3dBackSurfaceDestroy;
+                p->pfnSurfaceInvalidateImage   = vmsvga3dBackSurfaceInvalidateImage;
                 p->pfnSurfaceCopy              = vmsvga3dBackSurfaceCopy;
                 p->pfnSurfaceDMACopyBox        = vmsvga3dBackSurfaceDMACopyBox;

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

@@ -1148 +1148 @@
         AssertRCReturn(rc, rc);
 
+        /* Invalidate views, etc. */
+        PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+        if (pSvgaR3State->pFuncs3D)
+            pSvgaR3State->pFuncs3D->pfnSurfaceInvalidateImage(pThisCC, pSurface, face, mipmap);
+
         pMipmapLevel->fDirty = true;
     }

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

@@ -321 +321 @@
     DECLCALLBACKMEMBER(int,  pfnCreateTexture,            (PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext, PVMSVGA3DSURFACE pSurface));
     DECLCALLBACKMEMBER(void, pfnSurfaceDestroy,           (PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface));
+    DECLCALLBACKMEMBER(void, pfnSurfaceInvalidateImage,   (PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface, uint32_t uFace, uint32_t uMipmap));
     DECLCALLBACKMEMBER(int,  pfnSurfaceCopy,              (PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src, uint32_t cCopyBoxes, SVGA3dCopyBox *pBox));
     DECLCALLBACKMEMBER(int,  pfnSurfaceDMACopyBox,        (PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,