Changeset 95008 in vbox

Timestamp:

May 13, 2022 4:20:40 PM (3 years ago)

Author:

vboxsync

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

151437

Message:

Devices/Graphics: 64 bit surface flags and increased save state version; unordered access views; new commands: bugref:9830

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA-cmd.cpp (modified) (12 diffs)
• DevVGA-SVGA3d-dx.cpp (modified) (14 diffs)
• DevVGA-SVGA3d-info.cpp (modified) (1 diff)
• DevVGA-SVGA3d-internal.h (modified) (3 diffs)
• DevVGA-SVGA3d-ogl.cpp (modified) (17 diffs)
• DevVGA-SVGA3d-savedstate.cpp (modified) (4 diffs)
• DevVGA-SVGA3d-win-dx.cpp (modified) (60 diffs)
• DevVGA-SVGA3d-win.cpp (modified) (16 diffs)
• DevVGA-SVGA3d.cpp (modified) (5 diffs)
• DevVGA-SVGA3d.h (modified) (7 diffs)
• DevVGASavedState.h (modified) (1 diff)

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

@@ -1951 +1951 @@
     entry.arraySize = pCmd->arraySize;
     // entry.mobPitch = 0;
-    // ...
+    // entry.mobPitch = 0;
+    // entry.surface2Flags = 0;
+    // entry.multisamplePattern = 0;
+    // entry.qualityLevel = 0;
+    // entry.bufferByteStride = 0;
+    // entry.minLOD = 0;
 
     int rc = vmsvgaR3OTableWrite(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
@@ -3624 +3629 @@
 
 /* SVGA_3D_CMD_DEFINE_GB_SURFACE_V3 1239 */
-static int vmsvga3dCmdDefineGBSurface_v3(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDefineGBSurface_v3 const *pCmd, uint32_t cbCmd)
+static int vmsvga3dCmdDefineGBSurface_v3(PVGASTATECC pThisCC, SVGA3dCmdDefineGBSurface_v3 const *pCmd)
 {
 #ifdef VMSVGA3D_DX
     DEBUG_BREAKPOINT_TEST();
     PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDefineGBSurface_v3(pThisCC, idDXContext);
+
+    /* Update the entry in the pSvgaR3State->pGboOTableSurface. */
+    SVGAOTableSurfaceEntry entry;
+    RT_ZERO(entry);
+    entry.format = pCmd->format;
+    entry.surface1Flags = (uint32_t)(pCmd->surfaceFlags);
+    entry.numMipLevels = pCmd->numMipLevels;
+    entry.multisampleCount = pCmd->multisampleCount;
+    entry.autogenFilter = pCmd->autogenFilter;
+    entry.size = pCmd->size;
+    entry.mobid = SVGA_ID_INVALID;
+    entry.arraySize = pCmd->arraySize;
+    // entry.mobPitch = 0;
+    // entry.mobPitch = 0;
+    entry.surface2Flags = (uint32_t)(pCmd->surfaceFlags >> UINT64_C(32));
+    // entry.multisamplePattern = 0;
+    // entry.qualityLevel = 0;
+    // entry.bufferByteStride = 0;
+    // entry.minLOD = 0;
+
+    int rc = vmsvgaR3OTableWrite(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                                 pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entry, sizeof(entry));
+    if (RT_SUCCESS(rc))
+    {
+        /* Create the host surface. */
+        /** @todo SVGAOTableSurfaceEntry as input parameter? */
+        vmsvga3dSurfaceDefine(pThisCC, pCmd->sid, pCmd->surfaceFlags, pCmd->format,
+                              pCmd->multisampleCount, pCmd->autogenFilter,
+                              pCmd->numMipLevels, &pCmd->size, pCmd->arraySize, /* fAllocMipLevels = */ false);
+    }
+    return rc;
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -3717 +3751 @@
 {
 #ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXDefineUAView(pThisCC, idDXContext);
+    //DEBUG_BREAKPOINT_TEST();
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXDefineUAView(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -3733 +3766 @@
 #ifdef VMSVGA3D_DX
     DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXDestroyUAView(pThisCC, idDXContext);
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXDestroyUAView(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -3748 +3780 @@
 #ifdef VMSVGA3D_DX
     DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXClearUAViewUint(pThisCC, idDXContext);
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXClearUAViewUint(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -3763 +3794 @@
 #ifdef VMSVGA3D_DX
     DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXClearUAViewFloat(pThisCC, idDXContext);
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXClearUAViewFloat(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -3792 +3822 @@
 {
 #ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXSetUAViews(pThisCC, idDXContext);
+    //DEBUG_BREAKPOINT_TEST();
+    SVGA3dUAViewId const *paUAViewId = (SVGA3dUAViewId *)&pCmd[1];
+    uint32_t const cUAViewId = (cbCmd - sizeof(*pCmd)) / sizeof(SVGA3dUAViewId);
+    return vmsvga3dDXSetUAViews(pThisCC, idDXContext, pCmd, cUAViewId, paUAViewId);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -3837 +3867 @@
 {
 #ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXDispatch(pThisCC, idDXContext);
+    //DEBUG_BREAKPOINT_TEST();
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXDispatch(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -4014 +4043 @@
 
 /* SVGA_3D_CMD_DEFINE_GB_SURFACE_V4 1267 */
-static int vmsvga3dCmdDefineGBSurface_v4(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDefineGBSurface_v4 const *pCmd, uint32_t cbCmd)
-{
-#ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDefineGBSurface_v4(pThisCC, idDXContext);
+static int vmsvga3dCmdDefineGBSurface_v4(PVGASTATECC pThisCC, SVGA3dCmdDefineGBSurface_v4 const *pCmd)
+{
+#ifdef VMSVGA3D_DX
+    //DEBUG_BREAKPOINT_TEST();
+    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
+
+    /* Update the entry in the pSvgaR3State->pGboOTableSurface. */
+    SVGAOTableSurfaceEntry entry;
+    RT_ZERO(entry);
+    entry.format = pCmd->format;
+    entry.surface1Flags = (uint32_t)(pCmd->surfaceFlags);
+    entry.numMipLevels = pCmd->numMipLevels;
+    entry.multisampleCount = pCmd->multisampleCount;
+    entry.autogenFilter = pCmd->autogenFilter;
+    entry.size = pCmd->size;
+    entry.mobid = SVGA_ID_INVALID;
+    entry.arraySize = pCmd->arraySize;
+    // entry.mobPitch = 0;
+    // entry.mobPitch = 0;
+    entry.surface2Flags = (uint32_t)(pCmd->surfaceFlags >> UINT64_C(32));
+    // entry.multisamplePattern = 0;
+    // entry.qualityLevel = 0;
+    entry.bufferByteStride = pCmd->bufferByteStride;
+    // entry.minLOD = 0;
+
+    int rc = vmsvgaR3OTableWrite(pSvgaR3State, &pSvgaR3State->aGboOTables[SVGA_OTABLE_SURFACE],
+                                 pCmd->sid, SVGA3D_OTABLE_SURFACE_ENTRY_SIZE, &entry, sizeof(entry));
+    if (RT_SUCCESS(rc))
+    {
+        /* Create the host surface. */
+        /** @todo SVGAOTableSurfaceEntry as input parameter? */
+        vmsvga3dSurfaceDefine(pThisCC, pCmd->sid, pCmd->surfaceFlags, pCmd->format,
+                              pCmd->multisampleCount, pCmd->autogenFilter,
+                              pCmd->numMipLevels, &pCmd->size, pCmd->arraySize, /* fAllocMipLevels = */ false);
+    }
+    return rc;
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -4032 +4090 @@
 {
 #ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXSetCSUAViews(pThisCC, idDXContext);
+    //DEBUG_BREAKPOINT_TEST();
+    SVGA3dUAViewId const *paUAViewId = (SVGA3dUAViewId *)&pCmd[1];
+    uint32_t const cUAViewId = (cbCmd - sizeof(*pCmd)) / sizeof(SVGA3dUAViewId);
+    return vmsvga3dDXSetCSUAViews(pThisCC, idDXContext, pCmd, cUAViewId, paUAViewId);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);
@@ -5791 +5849 @@
         SVGA3dCmdDefineGBSurface_v3 *pCmd = (SVGA3dCmdDefineGBSurface_v3 *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDefineGBSurface_v3(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDefineGBSurface_v3(pThisCC, pCmd);
         break;
     }
@@ -6011 +6069 @@
         SVGA3dCmdDefineGBSurface_v4 *pCmd = (SVGA3dCmdDefineGBSurface_v4 *)pvCmd;
         VMSVGAFIFO_CHECK_3D_CMD_MIN_SIZE_BREAK(sizeof(*pCmd));
-        rcParse = vmsvga3dCmdDefineGBSurface_v4(pThisCC, idDXContext, pCmd, cbCmd);
+        rcParse = vmsvga3dCmdDefineGBSurface_v4(pThisCC, pCmd);
         break;
     }

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

@@ -883 +883 @@
         pDXContext->svgaDXContext.renderState.renderTargetViewIds[i] = paRenderTargetViewId[i];
 
+    /* Remember how many render target slots must be set. */
+    pDXContext->cRenderTargets = RT_MAX(pDXContext->cRenderTargets, cRenderTargetViewId);
+
     rc = pSvgaR3State->pFuncsDX->pfnDXSetRenderTargets(pThisCC, pDXContext, depthStencilViewId, cRenderTargetViewId, paRenderTargetViewId);
     return rc;
@@ -2009 +2012 @@
          */
         uint32_t cbSignaturesAvail = pEntry->sizeInBytes - cToken * 4; /* How many bytes for signatures are available. */
-        if (cbSignaturesAvail > sizeof(SVGA3dDXSignatureHeader))
+        if (cbSignaturesAvail >= sizeof(SVGA3dDXSignatureHeader))
         {
             cbSignaturesAvail -= sizeof(SVGA3dDXSignatureHeader);
@@ -2696 +2699 @@
 
 
-int vmsvga3dDefineGBSurface_v3(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDefineGBSurface_v3, 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->pfnDefineGBSurface_v3(pThisCC, pDXContext);
-    return rc;
-}
-
-
 int vmsvga3dDXResolveCopy(PVGASTATECC pThisCC, uint32_t idDXContext)
 {
@@ -2798 +2784 @@
 
 
-int vmsvga3dDXDefineUAView(PVGASTATECC pThisCC, uint32_t idDXContext)
+int vmsvga3dDXDefineUAView(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDefineUAView const *pCmd)
 {
     int rc;
@@ -2810 +2796 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXDefineUAView(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXDestroyUAView(PVGASTATECC pThisCC, uint32_t idDXContext)
+    SVGA3dUAViewId const uaViewId = pCmd->uaViewId;
+
+    ASSERT_GUEST_RETURN(pDXContext->cot.paUAView, VERR_INVALID_STATE);
+    ASSERT_GUEST_RETURN(uaViewId < pDXContext->cot.cUAView, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    SVGACOTableDXUAViewEntry *pEntry = &pDXContext->cot.paUAView[uaViewId];
+    pEntry->sid               = pCmd->sid;
+    pEntry->format            = pCmd->format;
+    pEntry->resourceDimension = pCmd->resourceDimension;
+    pEntry->desc              = pCmd->desc;
+    pEntry->structureCount    = 0;
+
+    rc = pSvgaR3State->pFuncsDX->pfnDXDefineUAView(pThisCC, pDXContext, uaViewId, pEntry);
+    return rc;
+}
+
+
+int vmsvga3dDXDestroyUAView(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDestroyUAView const *pCmd)
 {
     int rc;
@@ -2827 +2826 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXDestroyUAView(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXClearUAViewUint(PVGASTATECC pThisCC, uint32_t idDXContext)
+    SVGA3dUAViewId const uaViewId = pCmd->uaViewId;
+
+    ASSERT_GUEST_RETURN(pDXContext->cot.paUAView, VERR_INVALID_STATE);
+    ASSERT_GUEST_RETURN(uaViewId < pDXContext->cot.cUAView, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    SVGACOTableDXUAViewEntry *pEntry = &pDXContext->cot.paUAView[uaViewId];
+    RT_ZERO(*pEntry);
+
+    rc = pSvgaR3State->pFuncsDX->pfnDXDestroyUAView(pThisCC, pDXContext, uaViewId);
+    return rc;
+}
+
+
+int vmsvga3dDXClearUAViewUint(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXClearUAViewUint const *pCmd)
 {
     int rc;
@@ -2844 +2852 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXClearUAViewUint(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXClearUAViewFloat(PVGASTATECC pThisCC, uint32_t idDXContext)
+    SVGA3dUAViewId const uaViewId = pCmd->uaViewId;
+
+    ASSERT_GUEST_RETURN(pDXContext->cot.paUAView, VERR_INVALID_STATE);
+    ASSERT_GUEST_RETURN(uaViewId < pDXContext->cot.cUAView, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    rc = pSvgaR3State->pFuncsDX->pfnDXClearUAViewUint(pThisCC, pDXContext, uaViewId, pCmd->value.value);
+    return rc;
+}
+
+
+int vmsvga3dDXClearUAViewFloat(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXClearUAViewFloat const *pCmd)
 {
     int rc;
@@ -2861 +2875 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXClearUAViewFloat(pThisCC, pDXContext);
+    SVGA3dUAViewId const uaViewId = pCmd->uaViewId;
+
+    ASSERT_GUEST_RETURN(pDXContext->cot.paUAView, VERR_INVALID_STATE);
+    ASSERT_GUEST_RETURN(uaViewId < pDXContext->cot.cUAView, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    rc = pSvgaR3State->pFuncsDX->pfnDXClearUAViewFloat(pThisCC, pDXContext, uaViewId, pCmd->value.value);
     return rc;
 }
@@ -2883 +2903 @@
 
 
-int vmsvga3dDXSetUAViews(PVGASTATECC pThisCC, uint32_t idDXContext)
+int vmsvga3dDXSetUAViews(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetUAViews const *pCmd, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId)
 {
     int rc;
@@ -2895 +2915 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXSetUAViews(pThisCC, pDXContext);
+    ASSERT_GUEST_RETURN(pCmd->uavSpliceIndex < SVGA3D_DX11_1_MAX_UAVIEWS, VERR_INVALID_PARAMETER);
+    ASSERT_GUEST_RETURN(cUAViewId <= SVGA3D_DX11_1_MAX_UAVIEWS - pCmd->uavSpliceIndex, VERR_INVALID_PARAMETER);
+    for (uint32_t i = 0; i < cUAViewId; ++i)
+        ASSERT_GUEST_RETURN(   paUAViewId[i] < pDXContext->cot.cUAView
+                            || paUAViewId[i] == SVGA3D_INVALID_ID, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    for (uint32_t i = 0; i < cUAViewId; ++i)
+    {
+        SVGA3dUAViewId const uaViewId = paUAViewId[i];
+        pDXContext->svgaDXContext.uaViewIds[pCmd->uavSpliceIndex + i] = uaViewId;
+    }
+    pDXContext->svgaDXContext.uavSpliceIndex = pCmd->uavSpliceIndex;
+
+    rc = pSvgaR3State->pFuncsDX->pfnDXSetUAViews(pThisCC, pDXContext, pCmd->uavSpliceIndex, cUAViewId, paUAViewId);
     return rc;
 }
@@ -2934 +2968 @@
 
 
-int vmsvga3dDXDispatch(PVGASTATECC pThisCC, uint32_t idDXContext)
+int vmsvga3dDXDispatch(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDispatch const *pCmd)
 {
     int rc;
@@ -2946 +2980 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXDispatch(pThisCC, pDXContext);
+    rc = pSvgaR3State->pFuncsDX->pfnDXDispatch(pThisCC, pDXContext, pCmd->threadGroupCountX, pCmd->threadGroupCountY, pCmd->threadGroupCountZ);
     return rc;
 }
@@ -3138 +3172 @@
 
 
-int vmsvga3dDefineGBSurface_v4(PVGASTATECC pThisCC, uint32_t idDXContext)
-{
-    int rc;
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    AssertReturn(pSvgaR3State->pFuncsDX && pSvgaR3State->pFuncsDX->pfnDefineGBSurface_v4, 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->pfnDefineGBSurface_v4(pThisCC, pDXContext);
-    return rc;
-}
-
-
-int vmsvga3dDXSetCSUAViews(PVGASTATECC pThisCC, uint32_t idDXContext)
+int vmsvga3dDXSetCSUAViews(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetCSUAViews const *pCmd, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId)
 {
     int rc;
@@ -3167 +3184 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXSetCSUAViews(pThisCC, pDXContext);
+    ASSERT_GUEST_RETURN(pCmd->startIndex < SVGA3D_DX11_1_MAX_UAVIEWS, VERR_INVALID_PARAMETER);
+    ASSERT_GUEST_RETURN(cUAViewId <= SVGA3D_DX11_1_MAX_UAVIEWS - pCmd->startIndex, VERR_INVALID_PARAMETER);
+    for (uint32_t i = 0; i < cUAViewId; ++i)
+        ASSERT_GUEST_RETURN(   paUAViewId[i] < pDXContext->cot.cUAView
+                            || paUAViewId[i] == SVGA3D_INVALID_ID, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    for (uint32_t i = 0; i < cUAViewId; ++i)
+    {
+        SVGA3dUAViewId const uaViewId = paUAViewId[i];
+        pDXContext->svgaDXContext.csuaViewIds[pCmd->startIndex + i] = uaViewId;
+    }
+
+    rc = pSvgaR3State->pFuncsDX->pfnDXSetCSUAViews(pThisCC, pDXContext, pCmd->startIndex, cUAViewId, paUAViewId);
     return rc;
 }

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

@@ -1781 +1781 @@
     pHlp->pfnPrintf(pHlp, "Format:                  %s\n",
                     vmsvgaFormatEnumValueEx(szTmp, sizeof(szTmp), NULL, (int)pSurface->format, false, &g_SVGA3dSurfaceFormat2String));
-    pHlp->pfnPrintf(pHlp, "Flags:                   %#x", pSurface->surfaceFlags);
-    vmsvga3dInfoU32Flags(pHlp, pSurface->surfaceFlags, "SVGA3D_SURFACE_", g_aSvga3DSurfaceFlags, RT_ELEMENTS(g_aSvga3DSurfaceFlags));
+    pHlp->pfnPrintf(pHlp, "Flags:                   0x%RX64", pSurface->f.surfaceFlags);
+    vmsvga3dInfoU32Flags(pHlp, pSurface->f.s.surface1Flags, "SVGA3D_SURFACE_", g_aSvga3DSurfaceFlags, RT_ELEMENTS(g_aSvga3DSurfaceFlags));
     pHlp->pfnPrintf(pHlp, "\n");
     if (pSurface->cFaces != 0)

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

@@ -556 +556 @@
     VMSVGA3D_SURFACE_DESC   surfaceDesc;
 
-    SVGA3dSurface1Flags     surfaceFlags; /** @todo SVGA3dSurfaceAllFlags as an union. */
+    union
+    {
+        struct
+        {
+            SVGA3dSurface1Flags surface1Flags;
+            SVGA3dSurface2Flags surface2Flags;
+        } s;
+        SVGA3dSurfaceAllFlags surfaceFlags;
+    } f;
     SVGA3dSurfaceFormat     format;
 #ifdef VMSVGA3D_OPENGL
@@ -644 +652 @@
     SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, id),
     SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, idAssociatedContext),
-    SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, surfaceFlags),
+    SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, f.s.surface1Flags),
+    SSMFIELD_ENTRY_VER(             VMSVGA3DSURFACE, f.s.surface2Flags, VGA_SAVEDSTATE_VERSION_VMSVGA_DX_SFLAGS),
     SSMFIELD_ENTRY(                 VMSVGA3DSURFACE, format),
 # ifdef VMSVGA3D_OPENGL
@@ -967 +976 @@
     /** . */
     uint32_t                  u32Reserved;
+    /** . */
+    uint32_t                  cRenderTargets;
     /** Backend specific data. */
     PVMSVGA3DBACKENDDXCONTEXT pBackendDXContext;

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

@@ -2095 +2095 @@
             AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface),
                       ("hint=%#x, type=%d\n",
-                       (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK), pSurface->enmOGLResType));
+                       (pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK), pSurface->enmOGLResType));
             break;
     }
@@ -2146 +2146 @@
         if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurfaceDst))
         {
-            LogFunc(("dest sid=%u type=0x%x format=%d -> create texture\n", dest.sid, pSurfaceDst->surfaceFlags, pSurfaceDst->format));
+            LogFunc(("dest sid=%u type=0x%x format=%d -> create texture\n", dest.sid, pSurfaceDst->f.s.surface1Flags, pSurfaceDst->format));
             rc = vmsvga3dBackCreateTexture(pThisCC, pContext, pContext->id, pSurfaceDst);
             AssertRCReturn(rc, rc);
@@ -2435 +2435 @@
     GLenum binding;
     GLenum target;
-    if (pSurface->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
+    if (pSurface->f.s.surface1Flags & SVGA3D_SURFACE_CUBEMAP)
     {
         Assert(pSurface->cFaces == 6);
@@ -2687 +2687 @@
     VMSVGA3D_CHECK_LAST_ERROR(pState, pContext);
 
-    pSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_TEXTURE;
+    pSurface->f.s.surface1Flags |= SVGA3D_SURFACE_HINT_TEXTURE;
     pSurface->targetGL = target;
     pSurface->bindingGL = binding;
@@ -2721 +2721 @@
     RT_NOREF(pThis);
 
-    AssertReturn(   RT_BOOL(pSrcSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
-                 == RT_BOOL(pDstSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL), VERR_NOT_IMPLEMENTED);
+    AssertReturn(   RT_BOOL(pSrcSurface->f.s.surface1Flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
+                 == RT_BOOL(pDstSurface->f.s.surface1Flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL), VERR_NOT_IMPLEMENTED);
 
     GLenum glAttachment = GL_COLOR_ATTACHMENT0;
     GLbitfield glMask = GL_COLOR_BUFFER_BIT;
-    if (pDstSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
+    if (pDstSurface->f.s.surface1Flags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
     {
         /** @todo Need GL_DEPTH_STENCIL_ATTACHMENT for depth/stencil formats? */
@@ -3170 +3170 @@
 #endif
                 Log(("Lock %s memory for rectangle (%d,%d)(%d,%d)\n",
-                     (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_VERTEXBUFFER ? "vertex" :
-                       (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_INDEXBUFFER ? "index" : "buffer",
+                     (pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_VERTEXBUFFER ? "vertex" :
+                       (pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK) == SVGA3D_SURFACE_HINT_INDEXBUFFER ? "index" : "buffer",
                      pBox->x, pBox->y, pBox->x + pBox->w, pBox->y + pBox->h));
 
@@ -3230 +3230 @@
     {
         /* Unknown surface type; turn it into a texture. */
-        LogFunc(("unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
+        LogFunc(("unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->f.s.surface1Flags, pSurface->format));
         rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
         AssertRCReturn(rc, rc);
@@ -3944 +3944 @@
     if (!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
     {
-        LogFunc(("src sid=%u flags=0x%x format=%d -> create texture\n", srcImage.sid, pSurface->surfaceFlags, pSurface->format));
+        LogFunc(("src sid=%u flags=0x%x format=%d -> create texture\n", srcImage.sid, pSurface->f.s.surface1Flags, pSurface->format));
         rc = vmsvga3dBackCreateTexture(pThisCC, &pState->SharedCtx, VMSVGA3D_SHARED_CTX_ID, pSurface);
         AssertRCReturn(rc, rc);
@@ -5376 +5376 @@
         {
             LogFunc(("create depth texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n",
-                     target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
+                     target.sid, pRenderTarget->f.s.surface1Flags, pRenderTarget->format));
             rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
             AssertRCReturn(rc, rc);
@@ -5384 +5384 @@
         Assert(!pRenderTarget->fDirty);
 
-        pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
+        pRenderTarget->f.s.surface1Flags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
 
         pState->ext.glFramebufferTexture2D(GL_FRAMEBUFFER,
@@ -5394 +5394 @@
         if (pRenderTarget->oglId.texture == OPENGL_INVALID_ID)
         {
-            Log(("vmsvga3dSetRenderTarget: create renderbuffer to be used as render target; surface id=%x type=%d format=%d\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->internalFormatGL));
+            Log(("vmsvga3dSetRenderTarget: create renderbuffer to be used as render target; surface id=%x type=%d format=%d\n", target.sid, pRenderTarget->f.s.surface1Flags, pRenderTarget->internalFormatGL));
             pContext = &pState->SharedCtx;
             VMSVGA3D_SET_CURRENT_CONTEXT(pState, pContext);
@@ -5423 +5423 @@
         AssertReturn(pRenderTarget->oglId.texture != OPENGL_INVALID_ID, VERR_INVALID_PARAMETER);
 
-        pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
+        pRenderTarget->f.s.surface1Flags |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
 
         pState->ext.glFramebufferRenderbuffer(GL_FRAMEBUFFER,
@@ -5444 +5444 @@
         if (pRenderTarget->oglId.texture == OPENGL_INVALID_ID)
         {
-            Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
+            Log(("vmsvga3dSetRenderTarget: create texture to be used as render target; surface id=%x type=%d format=%d -> create texture\n", target.sid, pRenderTarget->f.s.surface1Flags, pRenderTarget->format));
             rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
             AssertRCReturn(rc, rc);
@@ -5452 +5452 @@
         Assert(!pRenderTarget->fDirty);
 
-        pRenderTarget->surfaceFlags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
+        pRenderTarget->f.s.surface1Flags |= SVGA3D_SURFACE_HINT_RENDERTARGET;
 
         GLenum textarget;
-        if (pRenderTarget->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
+        if (pRenderTarget->f.s.surface1Flags & SVGA3D_SURFACE_CUBEMAP)
             textarget = vmsvga3dCubemapFaceFromIndex(target.face);
         else
@@ -6846 +6846 @@
         pVertexSurface->fDirty = false;
 
-        pVertexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
+        pVertexSurface->f.s.surface1Flags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
 
         pState->ext.glBindBuffer(GL_ARRAY_BUFFER, OPENGL_INVALID_ID);
@@ -7240 +7240 @@
                 pIndexSurface->fDirty = false;
 
-                pIndexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
+                pIndexSurface->f.s.surface1Flags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
 
                 pState->ext.glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, OPENGL_INVALID_ID);
@@ -7822 +7822 @@
      * wast memory on them).
      */
-    uint32_t const fSwitchFlags = pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
+    uint32_t const fSwitchFlags = pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
     if (   fSwitchFlags != SVGA3D_SURFACE_HINT_DEPTHSTENCIL
         && fSwitchFlags != (SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE))

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

@@ -195 +195 @@
         pSurface->id                       = surfacePreMipLevels.id;
         pSurface->idAssociatedContext      = surfacePreMipLevels.idAssociatedContext;
-        pSurface->surfaceFlags             = surfacePreMipLevels.surfaceFlags;
+        pSurface->f.s.surface1Flags        = surfacePreMipLevels.surfaceFlags;
+        pSurface->f.s.surface2Flags        = 0;
         pSurface->format                   = surfacePreMipLevels.format;
 #ifdef VMSVGA3D_OPENGL
@@ -673 +674 @@
                 }
 
-                rc = vmsvga3dSurfaceDefine(pThisCC, sid, surface.surfaceFlags, surface.format, surface.multiSampleCount,
+                rc = vmsvga3dSurfaceDefine(pThisCC, sid, surface.f.surfaceFlags, surface.format, surface.multiSampleCount,
                                            surface.autogenFilter, surface.cLevels, &pMipmapLevelSize[0], /* arraySize = */ 0, /* fAllocMipLevels = */ true);
                 AssertRCReturn(rc, rc);
@@ -991 +992 @@
                         case VMSVGA3D_D3DRESTYPE_TEXTURE:
                         {
-                            if (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
+                            if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_HINT_DEPTHSTENCIL)
                             {
                                /** @todo unable to easily fetch depth surface data in d3d 9 */
@@ -999 +1000 @@
 
                             fTexture = (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE);
-                            fRenderTargetTexture = fTexture && (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET);
+                            fRenderTargetTexture = fTexture && (pSurface->f.surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET);
 
                             D3DLOCKED_RECT LockedRect;

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

@@ -88 +88 @@
     VMSVGA3D_VIEWTYPE_RENDERTARGET   = 1,
     VMSVGA3D_VIEWTYPE_DEPTHSTENCIL   = 2,
-    VMSVGA3D_VIEWTYPE_SHADERRESOURCE = 3
+    VMSVGA3D_VIEWTYPE_SHADERRESOURCE = 3,
+    VMSVGA3D_VIEWTYPE_UNORDEREDACCESS = 4
 } VMSVGA3DBACKVIEWTYPE;
 
@@ -117 +118 @@
         ID3D11DepthStencilView   *pDepthStencilView;
         ID3D11ShaderResourceView *pShaderResourceView;
+        ID3D11UnorderedAccessView *pUnorderedAccessView;
     } u;
 
@@ -260 +262 @@
     uint32_t                   cShader;                /* paShader */
     uint32_t                   cStreamOutput;          /* paStreamOutput */
+    uint32_t                   cUnorderedAccessView;   /* paUnorderedAccessView */
     ID3D11BlendState         **papBlendState;
     ID3D11DepthStencilState  **papDepthStencilState;
@@ -271 +274 @@
     DXSHADER                  *paShader;
     DXSTREAMOUTPUT            *paStreamOutput;
+    DXVIEW                    *paUnorderedAccessView;
 
     uint32_t                   cSOTarget;              /* How many SO targets are currently set (SetSOTargets) */
@@ -298 +302 @@
 static int dxDeviceFlush(DXDEVICE *pDevice);
 static int dxDefineShaderResourceView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderResourceViewId shaderResourceViewId, SVGACOTableDXSRViewEntry const *pEntry);
+static int dxDefineUnorderedAccessView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, SVGACOTableDXUAViewEntry 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 int dxSetCSUnorderedAccessViews(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext);
 static DECLCALLBACK(void) vmsvga3dBackSurfaceDestroy(PVGASTATECC pThisCC, PVMSVGA3DSURFACE pSurface);
 static int dxDestroyShader(DXSHADER *pDXShader);
@@ -507 +513 @@
 
         case SVGA3D_B4G4R4A4_UNORM:             return DXGI_FORMAT_;
-        case SVGA3D_BC6H_TYPELESS:              return DXGI_FORMAT_;
-        case SVGA3D_BC6H_UF16:                  return DXGI_FORMAT_;
-        case SVGA3D_BC6H_SF16:                  return DXGI_FORMAT_;
-        case SVGA3D_BC7_TYPELESS:               return DXGI_FORMAT_;
-        case SVGA3D_BC7_UNORM:                  return DXGI_FORMAT_;
-        case SVGA3D_BC7_UNORM_SRGB:             return DXGI_FORMAT_;
+        case SVGA3D_BC6H_TYPELESS:              return DXGI_FORMAT_BC6H_TYPELESS;
+        case SVGA3D_BC6H_UF16:                  return DXGI_FORMAT_BC6H_UF16;
+        case SVGA3D_BC6H_SF16:                  return DXGI_FORMAT_BC6H_SF16;
+        case SVGA3D_BC7_TYPELESS:               return DXGI_FORMAT_BC7_TYPELESS;
+        case SVGA3D_BC7_UNORM:                  return DXGI_FORMAT_BC7_UNORM;
+        case SVGA3D_BC7_UNORM_SRGB:             return DXGI_FORMAT_BC7_UNORM_SRGB;
         case SVGA3D_AYUV:                       return DXGI_FORMAT_;
 
@@ -1027 +1033 @@
 {
     /* It is not expected that volume textures will be shared between contexts. */
-    if (pSurface->surfaceFlags & SVGA3D_SURFACE_VOLUME)
+    if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_VOLUME)
         return false;
 
-    return pSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET
-        || pSurface->surfaceFlags & SVGA3D_SURFACE_BIND_RENDER_TARGET;
+    return (pSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET)
+        || (pSurface->f.surfaceFlags & SVGA3D_SURFACE_BIND_RENDER_TARGET);
 }
 
@@ -1201 +1207 @@
     SVGACOTableDXSRViewEntry const *pSRViewEntry = &pDXContext->cot.paSRView[shaderResourceViewId];
     return pSRViewEntry;
+}
+
+
+static SVGACOTableDXUAViewEntry const *dxGetUnorderedAccessViewEntry(PVMSVGA3DDXCONTEXT pDXContext, uint32_t uaViewId)
+{
+    ASSERT_GUEST_RETURN(uaViewId < pDXContext->cot.cUAView, NULL);
+
+    SVGACOTableDXUAViewEntry const *pUAViewEntry = &pDXContext->cot.paUAView[uaViewId];
+    return pUAViewEntry;
 }
 
@@ -1464 +1479 @@
     RT_ZERO(desc);
     desc.Format = vmsvgaDXSurfaceFormat2Dxgi(pEntry->format);
-    AssertReturn(desc.Format != DXGI_FORMAT_UNKNOWN, E_FAIL);
+    AssertReturn(desc.Format != DXGI_FORMAT_UNKNOWN || pEntry->format == SVGA3D_BUFFER, E_FAIL);
     switch (pEntry->resourceDimension)
     {
@@ -1538 +1553 @@
     RT_ZERO(desc);
     desc.Format = vmsvgaDXSurfaceFormat2Dxgi(pEntry->format);
-    AssertReturn(desc.Format != DXGI_FORMAT_UNKNOWN, E_FAIL);
+    AssertReturn(desc.Format != DXGI_FORMAT_UNKNOWN || pEntry->format == SVGA3D_BUFFER, E_FAIL);
 
     switch (pEntry->resourceDimension)
@@ -1617 +1632 @@
 
 
+static HRESULT dxUnorderedAccessViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXUAViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11UnorderedAccessView **pp)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+
+    ID3D11Resource *pResource = dxResource(pThisCC->svga.p3dState, pSurface, pDXContext);
+
+    D3D11_UNORDERED_ACCESS_VIEW_DESC desc;
+    RT_ZERO(desc);
+    desc.Format = vmsvgaDXSurfaceFormat2Dxgi(pEntry->format);
+    AssertReturn(desc.Format != DXGI_FORMAT_UNKNOWN || pEntry->format == SVGA3D_BUFFER, E_FAIL);
+
+    switch (pEntry->resourceDimension)
+    {
+        case SVGA3D_RESOURCE_BUFFER:
+            desc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;
+            desc.Buffer.FirstElement = pEntry->desc.buffer.firstElement;
+            desc.Buffer.NumElements = pEntry->desc.buffer.numElements;
+            desc.Buffer.Flags = pEntry->desc.buffer.flags;
+            break;
+        case SVGA3D_RESOURCE_TEXTURE1D:
+            if (pSurface->surfaceDesc.numArrayElements <= 1)
+            {
+                desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE1D;
+                desc.Texture1D.MipSlice = pEntry->desc.tex.mipSlice;
+            }
+            else
+            {
+                desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE1DARRAY;
+                desc.Texture1DArray.MipSlice = pEntry->desc.tex.mipSlice;
+                desc.Texture1DArray.FirstArraySlice = pEntry->desc.tex.firstArraySlice;
+                desc.Texture1DArray.ArraySize = pEntry->desc.tex.arraySize;
+            }
+            break;
+        case SVGA3D_RESOURCE_TEXTURE2D:
+            if (pSurface->surfaceDesc.numArrayElements <= 1)
+            {
+                desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
+                desc.Texture2D.MipSlice = pEntry->desc.tex.mipSlice;
+            }
+            else
+            {
+                desc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2DARRAY;
+                desc.Texture2DArray.MipSlice = pEntry->desc.tex.mipSlice;
+                desc.Texture2DArray.FirstArraySlice = pEntry->desc.tex.firstArraySlice;
+                desc.Texture2DArray.ArraySize = pEntry->desc.tex.arraySize;
+            }
+            break;
+        case SVGA3D_RESOURCE_TEXTURE3D:
+            desc.Texture3D.MipSlice = pEntry->desc.tex3D.mipSlice;
+            desc.Texture3D.FirstWSlice = pEntry->desc.tex3D.firstW;
+            desc.Texture3D.WSize = pEntry->desc.tex3D.wSize;
+            break;
+        default:
+            ASSERT_GUEST_FAILED_RETURN(E_INVALIDARG);
+    }
+
+    HRESULT hr = pDevice->pDevice->CreateUnorderedAccessView(pResource, &desc, pp);
+    Assert(SUCCEEDED(hr));
+    return hr;
+}
+
+
 static HRESULT dxDepthStencilViewCreate(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableDXDSViewEntry const *pEntry, VMSVGA3DSURFACE *pSurface, ID3D11DepthStencilView **pp)
 {
@@ -1626 +1703 @@
     RT_ZERO(desc);
     desc.Format = vmsvgaDXSurfaceFormat2Dxgi(pEntry->format);
-    AssertReturn(desc.Format != DXGI_FORMAT_UNKNOWN, E_FAIL);
+    AssertReturn(desc.Format != DXGI_FORMAT_UNKNOWN || pEntry->format == SVGA3D_BUFFER, E_FAIL);
     desc.Flags = pEntry->flags;
     switch (pEntry->resourceDimension)
@@ -1723 +1800 @@
         }
         case SVGA3D_SHADERTYPE_HS:
+            hr = pDevice->pDevice->CreateHullShader(pDXShader->pvDXBC, pDXShader->cbDXBC, NULL, &pDXShader->pHullShader);
+            Assert(SUCCEEDED(hr));
+            break;
         case SVGA3D_SHADERTYPE_DS:
+            hr = pDevice->pDevice->CreateDomainShader(pDXShader->pvDXBC, pDXShader->cbDXBC, NULL, &pDXShader->pDomainShader);
+            Assert(SUCCEEDED(hr));
+            break;
         case SVGA3D_SHADERTYPE_CS:
+            hr = pDevice->pDevice->CreateComputeShader(pDXShader->pvDXBC, pDXShader->cbDXBC, NULL, &pDXShader->pComputeShader);
+            Assert(SUCCEEDED(hr));
+            break;
         default:
             ASSERT_GUEST_FAILED_RETURN(E_INVALIDARG);
@@ -1751 +1837 @@
         } break;
         case SVGA3D_SHADERTYPE_HS:
+            pDevice->pImmediateContext->HSSetShader(pDXShader ? pDXShader->pHullShader : NULL, NULL, 0);
+            break;
         case SVGA3D_SHADERTYPE_DS:
+            pDevice->pImmediateContext->DSSetShader(pDXShader ? pDXShader->pDomainShader : NULL, NULL, 0);
+            break;
         case SVGA3D_SHADERTYPE_CS:
+            pDevice->pImmediateContext->CSSetShader(pDXShader ? pDXShader->pComputeShader : NULL, NULL, 0);
+            break;
         default:
             ASSERT_GUEST_FAILED_RETURN_VOID();
@@ -1773 +1865 @@
             break;
         case SVGA3D_SHADERTYPE_HS:
+            pDevice->pImmediateContext->HSSetConstantBuffers(slot, 1, &pConstantBuffer);
+            break;
         case SVGA3D_SHADERTYPE_DS:
+            pDevice->pImmediateContext->DSSetConstantBuffers(slot, 1, &pConstantBuffer);
+            break;
         case SVGA3D_SHADERTYPE_CS:
+            pDevice->pImmediateContext->CSSetConstantBuffers(slot, 1, &pConstantBuffer);
+            break;
         default:
             ASSERT_GUEST_FAILED_RETURN_VOID();
@@ -1823 +1921 @@
             break;
         case SVGA3D_SHADERTYPE_HS:
+            pDevice->pImmediateContext->HSSetShaderResources(startView, cShaderResourceView, papShaderResourceView);
+            break;
         case SVGA3D_SHADERTYPE_DS:
+            pDevice->pImmediateContext->DSSetShaderResources(startView, cShaderResourceView, papShaderResourceView);
+            break;
         case SVGA3D_SHADERTYPE_CS:
+            pDevice->pImmediateContext->CSSetShaderResources(startView, cShaderResourceView, papShaderResourceView);
+            break;
         default:
             ASSERT_GUEST_FAILED_RETURN_VOID();
     }
+}
+
+
+static void dxCSUnorderedAccessViewSet(DXDEVICE *pDevice, uint32_t startView, uint32_t cView, ID3D11UnorderedAccessView * const *papUnorderedAccessView, UINT *pUAVInitialCounts)
+{
+    pDevice->pImmediateContext->CSSetUnorderedAccessViews(startView, cView, papUnorderedAccessView, pUAVInitialCounts);
 }
 
@@ -1874 +1984 @@
 
     /* Surface must have SCREEN_TARGET flag. */
-    ASSERT_GUEST_RETURN(RT_BOOL(pSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET), VERR_INVALID_PARAMETER);
+    ASSERT_GUEST_RETURN(RT_BOOL(pSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET), VERR_INVALID_PARAMETER);
 
     if (VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface))
@@ -2040 +2150 @@
 
     HRESULT hr = S_OK;
-    if (pSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET)
+    if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET)
     {
         /*
@@ -2091 +2201 @@
         }
     }
-    else if (pSurface->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
+    else if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
     {
         Assert(pSurface->cFaces == 6);
@@ -2108 +2218 @@
         td.SampleDesc.Quality = 0;
         td.Usage              = D3D11_USAGE_DEFAULT;
-        td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
+        td.BindFlags          = dxBindFlags(pSurface->f.surfaceFlags);
         td.CPUAccessFlags     = 0; /** @todo */
         td.MiscFlags          = MiscFlags | D3D11_RESOURCE_MISC_TEXTURECUBE; /** @todo */
@@ -2149 +2259 @@
         }
     }
-    else if (pSurface->surfaceFlags & SVGA3D_SURFACE_1D)
+    else if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_1D)
     {
         /*
@@ -2163 +2273 @@
         td.Format             = dxgiFormat;
         td.Usage              = D3D11_USAGE_DEFAULT;
-        td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
+        td.BindFlags          = dxBindFlags(pSurface->f.surfaceFlags);
         td.CPUAccessFlags     = 0;
         td.MiscFlags          = MiscFlags; /** @todo */
@@ -2206 +2316 @@
     else
     {
-        if (pSurface->surfaceFlags & SVGA3D_SURFACE_VOLUME)
+        if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_VOLUME)
         {
             /*
@@ -2222 +2332 @@
             td.Format             = dxgiFormat;
             td.Usage              = D3D11_USAGE_DEFAULT;
-            td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
+            td.BindFlags          = dxBindFlags(pSurface->f.surfaceFlags);
             td.CPUAccessFlags     = 0; /** @todo */
             td.MiscFlags          = MiscFlags; /** @todo */
@@ -2280 +2390 @@
             td.SampleDesc.Quality = 0;
             td.Usage              = D3D11_USAGE_DEFAULT;
-            td.BindFlags          = dxBindFlags(pSurface->surfaceFlags);
+            td.BindFlags          = dxBindFlags(pSurface->f.surfaceFlags);
             td.CPUAccessFlags     = 0; /** @todo */
             td.MiscFlags          = MiscFlags; /** @todo */
@@ -2360 +2470 @@
 
     /* Buffers should be created as such. */
-    AssertReturn(RT_BOOL(pSurface->surfaceFlags & (  SVGA3D_SURFACE_HINT_INDEXBUFFER
-                                                   | SVGA3D_SURFACE_HINT_VERTEXBUFFER
-                                                   | SVGA3D_SURFACE_BIND_VERTEX_BUFFER
-                                                   | SVGA3D_SURFACE_BIND_INDEX_BUFFER
+    AssertReturn(RT_BOOL(pSurface->f.surfaceFlags & (  SVGA3D_SURFACE_HINT_INDEXBUFFER
+                                                     | SVGA3D_SURFACE_HINT_VERTEXBUFFER
+                                                     | SVGA3D_SURFACE_BIND_VERTEX_BUFFER
+                                                     | SVGA3D_SURFACE_BIND_INDEX_BUFFER
                         )), VERR_INVALID_PARAMETER);
 
@@ -2427 +2537 @@
 
     /* Buffers should be created as such. */
-    AssertReturn(RT_BOOL(pSurface->surfaceFlags & SVGA3D_SURFACE_BIND_STREAM_OUTPUT), VERR_INVALID_PARAMETER);
+    AssertReturn(RT_BOOL(pSurface->f.surfaceFlags & SVGA3D_SURFACE_BIND_STREAM_OUTPUT), VERR_INVALID_PARAMETER);
 
     if (pSurface->pBackendSurface != NULL)
@@ -2443 +2553 @@
     bd.ByteWidth           = pSurface->paMipmapLevels[0].cbSurface;
     bd.Usage               = D3D11_USAGE_DEFAULT;
-    bd.BindFlags           = dxBindFlags(pSurface->surfaceFlags); // D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_STREAM_OUTPUT;
+    bd.BindFlags           = dxBindFlags(pSurface->f.surfaceFlags); // D3D11_BIND_VERTEX_BUFFER | D3D11_BIND_STREAM_OUTPUT;
     bd.CPUAccessFlags      = 0; /// @todo ? D3D11_CPU_ACCESS_READ;
     bd.MiscFlags           = 0;
@@ -2473 +2583 @@
 
     /* Buffers should be created as such. */
-    AssertReturn(RT_BOOL(pSurface->surfaceFlags & ( SVGA3D_SURFACE_BIND_CONSTANT_BUFFER)), VERR_INVALID_PARAMETER);
+    AssertReturn(RT_BOOL(pSurface->f.surfaceFlags & ( SVGA3D_SURFACE_BIND_CONSTANT_BUFFER)), VERR_INVALID_PARAMETER);
 
     if (pSurface->pBackendSurface != NULL)
@@ -2535 +2645 @@
 
 
-static int vmsvga3dBackSurfaceCreateResource(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface)
+static int vmsvga3dBackSurfaceCreateResource(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSURFACE pSurface, UINT MiscFlags = 0)
 {
     DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
@@ -2577 +2687 @@
         bd.ByteWidth = pMipLevel->cbSurface;
 
-        if (pSurface->surfaceFlags & (SVGA3D_SURFACE_STAGING_UPLOAD | SVGA3D_SURFACE_STAGING_DOWNLOAD))
+        if (pSurface->f.surfaceFlags & (SVGA3D_SURFACE_STAGING_UPLOAD | SVGA3D_SURFACE_STAGING_DOWNLOAD))
             bd.Usage = D3D11_USAGE_STAGING;
-        else if (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_DYNAMIC)
+        else if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_HINT_DYNAMIC)
             bd.Usage = D3D11_USAGE_DYNAMIC;
-        else if (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_STATIC)
+        else if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_HINT_STATIC)
             bd.Usage = D3D11_USAGE_IMMUTABLE;
-        else if (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_INDIRECT_UPDATE)
+        else if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_HINT_INDIRECT_UPDATE)
             bd.Usage = D3D11_USAGE_DEFAULT;
 
-        bd.BindFlags = dxBindFlags(pSurface->surfaceFlags);
+        bd.BindFlags = dxBindFlags(pSurface->f.surfaceFlags);
 
         if (bd.Usage == D3D11_USAGE_STAGING)
@@ -2592 +2702 @@
         else if (bd.Usage == D3D11_USAGE_DYNAMIC)
             bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
+
+        bd.MiscFlags |= MiscFlags;
 
         hr = pDevice->pDevice->CreateBuffer(&bd, pInitialData, &pBackendSurface->u.pBuffer);
@@ -5187 +5299 @@
 
     /*
-     * Render targets
+     * Compute shader unordered access views
+     */
+
+    for (uint32_t idxUA = 0; idxUA < SVGA3D_DX11_1_MAX_UAVIEWS; ++idxUA)
+    {
+        SVGA3dUAViewId const uaViewId = pDXContext->svgaDXContext.csuaViewIds[idxUA];
+        if (uaViewId != SVGA3D_INVALID_ID)
+        {
+//DEBUG_BREAKPOINT_TEST();
+            ASSERT_GUEST_RETURN_VOID(uaViewId < pDXContext->pBackendDXContext->cUnorderedAccessView);
+
+            SVGACOTableDXUAViewEntry const *pUAViewEntry = dxGetUnorderedAccessViewEntry(pDXContext, uaViewId);
+            AssertContinue(pUAViewEntry != NULL);
+
+            uint32_t const sid = pUAViewEntry->sid;
+
+            PVMSVGA3DSURFACE pSurface;
+            rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, sid, &pSurface);
+            AssertRCReturnVoid(rc);
+
+            /* 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->paUnorderedAccessView[uaViewId].u.pView)
+            {
+                LogFunc(("Re-creating UAV: sid=%u uaid = %u\n", sid, uaViewId));
+                rc = dxDefineUnorderedAccessView(pThisCC, pDXContext, uaViewId, pUAViewEntry);
+                AssertContinue(RT_SUCCESS(rc));
+            }
+
+            LogFunc(("uav[%d] sid = %u, uaid = %u\n", idxUA, sid, uaViewId));
+        }
+    }
+
+    /* Set views. */
+    rc = dxSetCSUnorderedAccessViews(pThisCC, pDXContext);
+    AssertRC(rc);
+
+    /*
+     * Render targets and unordered access views.
      */
 
@@ -5240 +5397 @@
                 AssertReturnVoid(RT_SUCCESS(rc));
             }
+        }
+    }
+
+    for (uint32_t idxUA = 0; idxUA < SVGA3D_DX11_1_MAX_UAVIEWS; ++idxUA)
+    {
+        SVGA3dUAViewId const uaViewId = pDXContext->svgaDXContext.uaViewIds[idxUA];
+        if (uaViewId != SVGA3D_INVALID_ID)
+        {
+//DEBUG_BREAKPOINT_TEST();
+            ASSERT_GUEST_RETURN_VOID(uaViewId < pDXContext->pBackendDXContext->cUnorderedAccessView);
+
+            SVGACOTableDXUAViewEntry const *pUAViewEntry = dxGetUnorderedAccessViewEntry(pDXContext, uaViewId);
+            AssertContinue(pUAViewEntry != NULL);
+
+            uint32_t const sid = pUAViewEntry->sid;
+
+            PVMSVGA3DSURFACE pSurface;
+            rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, sid, &pSurface);
+            AssertRCReturnVoid(rc);
+
+            /* 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->paUnorderedAccessView[uaViewId].u.pView)
+            {
+                LogFunc(("Re-creating UAV: sid=%u uaid = %u\n", sid, uaViewId));
+                rc = dxDefineUnorderedAccessView(pThisCC, pDXContext, uaViewId, pUAViewEntry);
+                AssertContinue(RT_SUCCESS(rc));
+            }
+
+            LogFunc(("uav[%d] sid = %u, uaid = %u\n", idxUA, sid, uaViewId));
         }
     }
@@ -5918 +6112 @@
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
+    UINT UAVStartSlot = 0;
+    UINT NumUAVs = 0;
+    ID3D11UnorderedAccessView *apUnorderedAccessViews[SVGA3D_DX11_1_MAX_UAVIEWS];
+    UINT aUAVInitialCounts[SVGA3D_DX11_1_MAX_UAVIEWS];
+    for (uint32_t idxUA = 0; idxUA < SVGA3D_DX11_1_MAX_UAVIEWS; ++idxUA)
+    {
+        SVGA3dUAViewId const uaViewId = pDXContext->svgaDXContext.uaViewIds[idxUA];
+        if (uaViewId != SVGA3D_INVALID_ID)
+        {
+            if (NumUAVs == 0)
+                UAVStartSlot = idxUA;
+            NumUAVs = idxUA - UAVStartSlot + 1;
+            apUnorderedAccessViews[idxUA] = pDXContext->pBackendDXContext->paUnorderedAccessView[uaViewId].u.pUnorderedAccessView;
+        }
+        else
+            apUnorderedAccessViews[idxUA] =  NULL;
+
+        /** @todo */
+        aUAVInitialCounts[idxUA] = (UINT)-1;
+    }
+
     ID3D11RenderTargetView *apRenderTargetViews[SVGA3D_MAX_RENDER_TARGETS];
     RT_ZERO(apRenderTargetViews);
-    for (uint32_t i = 0; i < SVGA3D_MAX_RENDER_TARGETS; ++i)
+    for (uint32_t i = 0; i < pDXContext->cRenderTargets; ++i)
     {
         SVGA3dRenderTargetViewId const renderTargetViewId = pDXContext->svgaDXContext.renderState.renderTargetViewIds[i];
@@ -5935 +6150 @@
         pDepthStencilView = pDXContext->pBackendDXContext->paDepthStencilView[depthStencilViewId].u.pDepthStencilView;
 
-    pDevice->pImmediateContext->OMSetRenderTargets(SVGA3D_MAX_RENDER_TARGETS,
+    pDevice->pImmediateContext->OMSetRenderTargets(pDXContext->cRenderTargets,
                                                    apRenderTargetViews,
                                                    pDepthStencilView);
+//    Assert(NumUAVs == 0);
+    if (NumUAVs != 0)
+        pDevice->pImmediateContext->OMSetRenderTargetsAndUnorderedAccessViews(D3D11_KEEP_RENDER_TARGETS_AND_DEPTH_STENCIL,
+                                                       NULL,
+                                                       NULL,
+                                                       pDXContext->svgaDXContext.uavSpliceIndex,
+                                                       NumUAVs,
+                                                       apUnorderedAccessViews,
+                                                       aUAVInitialCounts);
     return VINF_SUCCESS;
 }
@@ -6456 +6680 @@
     LogFunc(("cid %d: src cid %d%s -> dst cid %d%s\n",
              pDXContext->cid, pSrcSurface->idAssociatedContext,
-             (pSrcSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET) ? " st" : "",
+             (pSrcSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET) ? " st" : "",
              pDstSurface->idAssociatedContext,
-             (pDstSurface->surfaceFlags & SVGA3D_SURFACE_SCREENTARGET) ? " st" : ""));
+             (pDstSurface->f.surfaceFlags & SVGA3D_SURFACE_SCREENTARGET) ? " st" : ""));
 
     /* Clip the box. */
@@ -7334 +7558 @@
             break;
         case SVGA_COTABLE_UAVIEW:
-            AssertFailed(); /** @todo Implement */
+            if (pBackendDXContext->paUnorderedAccessView)
+            {
+                for (uint32_t i = 0; i < pBackendDXContext->cUnorderedAccessView; ++i)
+                {
+                    DXVIEW *pDXView = &pBackendDXContext->paUnorderedAccessView[i];
+                    if (i < cValidEntries)
+                        dxViewRemoveFromList(pDXView); /* Remove from list because DXVIEW array will be reallocated. */
+                    else
+                        dxViewDestroy(pDXView);
+                }
+            }
+
+            rc = dxCOTableRealloc((void **)&pBackendDXContext->paUnorderedAccessView, &pBackendDXContext->cUnorderedAccessView,
+                                  sizeof(pBackendDXContext->paUnorderedAccessView[0]), pDXContext->cot.cUAView, cValidEntries);
+            AssertRCBreak(rc);
+
+            for (uint32_t i = 0; i < cValidEntries; ++i)
+            {
+                SVGACOTableDXUAViewEntry const *pEntry = &pDXContext->cot.paUAView[i];
+                if (ASMMemFirstNonZero(pEntry, sizeof(*pEntry)) == NULL)
+                    continue; /* Skip uninitialized entry. */
+
+                /* Define views which were not defined yet in backend. */
+                DXVIEW *pDXView = &pBackendDXContext->paUnorderedAccessView[i];
+                /** @todo Verify that the pEntry content still corresponds to the view. */
+                if (pDXView->u.pView)
+                    dxViewAddToList(pThisCC, pDXView);
+                else if (pDXView->enmViewType == VMSVGA3D_VIEWTYPE_NONE)
+                    dxDefineUnorderedAccessView(pThisCC, pDXContext, i, pEntry);
+            }
             break;
         case SVGA_COTABLE_MAX: break; /* Compiler warning */
@@ -7512 +7765 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDefineGBSurface_v3(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXResolveCopy(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7522 +7775 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXResolveCopy(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXPredResolveCopy(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7532 +7785 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXPredResolveCopy(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXPredConvertRegion(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7542 +7795 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXPredConvertRegion(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXPredConvert(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7552 +7805 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXPredConvert(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackWholeSurfaceCopy(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7562 +7815 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackWholeSurfaceCopy(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static int dxDefineUnorderedAccessView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, SVGACOTableDXUAViewEntry const *pEntry)
+{
+    /* Get corresponding resource for pEntry->sid. Create the surface if does not yet exist. */
+    PVMSVGA3DSURFACE pSurface;
+    int rc = vmsvga3dSurfaceFromSid(pThisCC->svga.p3dState, pEntry->sid, &pSurface);
+    AssertRCReturn(rc, rc);
+
+    ID3D11UnorderedAccessView *pUnorderedAccessView;
+    DXVIEW *pView = &pDXContext->pBackendDXContext->paUnorderedAccessView[uaViewId];
+    Assert(pView->u.pView == NULL);
+
+    if (pSurface->pBackendSurface == NULL)
+    {
+        /* Create the actual texture or buffer. */
+        /** @todo One function to create all resources from surfaces. */
+        if (pSurface->format != SVGA3D_BUFFER)
+            rc = vmsvga3dBackSurfaceCreateTexture(pThisCC, pDXContext, pSurface);
+        else
+        {
+            UINT MiscFlags = 0;
+            if (   pEntry->resourceDimension == SVGA3D_RESOURCE_BUFFER
+                && (pEntry->desc.buffer.flags & (SVGA3D_UABUFFER_APPEND | SVGA3D_UABUFFER_COUNTER)))
+                MiscFlags |= D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;
+
+            rc = vmsvga3dBackSurfaceCreateResource(pThisCC, pDXContext, pSurface, MiscFlags);
+        }
+
+        AssertRCReturn(rc, rc);
+    }
+
+    HRESULT hr = dxUnorderedAccessViewCreate(pThisCC, pDXContext, pEntry, pSurface, &pUnorderedAccessView);
+    AssertReturn(SUCCEEDED(hr), VERR_INVALID_STATE);
+
+    return dxViewInit(pView, pSurface, pDXContext, uaViewId, VMSVGA3D_VIEWTYPE_UNORDEREDACCESS, pUnorderedAccessView);
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDefineUAView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, SVGACOTableDXUAViewEntry const *pEntry)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    /** @todo Probably not necessary because UAVs are defined in setupPipeline. */
+    return dxDefineUnorderedAccessView(pThisCC, pDXContext, uaViewId, pEntry);
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDestroyUAView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    return dxViewDestroy(&pDXContext->pBackendDXContext->paUnorderedAccessView[uaViewId]);
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXClearUAViewUint(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, uint32_t const aValues[4])
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    DXVIEW *pDXView = &pDXContext->pBackendDXContext->paUnorderedAccessView[uaViewId];
+    if (!pDXView->u.pUnorderedAccessView)
+    {
+        /* (Re-)create the view, because a creation of a view is deferred until a draw or a clear call. */
+        SVGACOTableDXUAViewEntry const *pEntry = &pDXContext->cot.paUAView[uaViewId];
+        int rc = dxDefineUnorderedAccessView(pThisCC, pDXContext, uaViewId, pEntry);
+        AssertRCReturn(rc, rc);
+    }
+    pDevice->pImmediateContext->ClearUnorderedAccessViewUint(pDXView->u.pUnorderedAccessView, aValues);
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXClearUAViewFloat(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, float const aValues[4])
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    DXVIEW *pDXView = &pDXContext->pBackendDXContext->paUnorderedAccessView[uaViewId];
+    if (!pDXView->u.pUnorderedAccessView)
+    {
+        /* (Re-)create the view, because a creation of a view is deferred until a draw or a clear call. */
+        SVGACOTableDXUAViewEntry const *pEntry = &pDXContext->cot.paUAView[uaViewId];
+        int rc = dxDefineUnorderedAccessView(pThisCC, pDXContext, uaViewId, pEntry);
+        AssertRCReturn(rc, rc);
+    }
+    pDevice->pImmediateContext->ClearUnorderedAccessViewFloat(pDXView->u.pUnorderedAccessView, aValues);
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXCopyStructureCount(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7572 +7926 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDefineUAView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXSetUAViews(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t uavSpliceIndex, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    RT_NOREF(uavSpliceIndex, cUAViewId, paUAViewId);
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDrawIndexedInstancedIndirect(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7582 +7950 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDestroyUAView(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXDrawInstancedIndirect(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7592 +7960 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXClearUAViewUint(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXDispatch(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    pDevice->pImmediateContext->Dispatch(threadGroupCountX, threadGroupCountY, threadGroupCountZ);
+
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXDispatchIndirect(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7602 +7984 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXClearUAViewFloat(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackWriteZeroSurface(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7612 +7994 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXCopyStructureCount(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackHintZeroSurface(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7622 +8004 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXSetUAViews(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXTransferToBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7632 +8014 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDrawIndexedInstancedIndirect(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackDXSetStructureCount(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7642 +8024 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDrawInstancedIndirect(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackLogicOpsBitBlt(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7652 +8034 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDispatch(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackLogicOpsTransBlt(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7662 +8044 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXDispatchIndirect(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackLogicOpsStretchBlt(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7672 +8054 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackWriteZeroSurface(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackLogicOpsColorFill(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7682 +8064 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackHintZeroSurface(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackLogicOpsAlphaBlend(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7692 +8074 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXTransferToBuffer(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+static DECLCALLBACK(int) vmsvga3dBackLogicOpsClearTypeBlend(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -7702 +8084 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXSetStructureCount(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackLogicOpsBitBlt(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackLogicOpsTransBlt(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackLogicOpsStretchBlt(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackLogicOpsColorFill(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackLogicOpsAlphaBlend(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackLogicOpsClearTypeBlend(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDefineGBSurface_v4(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
-}
-
-
-static DECLCALLBACK(int) vmsvga3dBackDXSetCSUAViews(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
+static int dxSetCSUnorderedAccessViews(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
+{
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+//DEBUG_BREAKPOINT_TEST();
+    uint32_t const *pUAIds = &pDXContext->svgaDXContext.csuaViewIds[0];
+    ID3D11UnorderedAccessView *papUnorderedAccessView[SVGA3D_DX11_1_MAX_UAVIEWS];
+    UINT aUAVInitialCounts[SVGA3D_DX11_1_MAX_UAVIEWS];
+    for (uint32_t i = 0; i < SVGA3D_DX11_1_MAX_UAVIEWS; ++i)
+    {
+        SVGA3dUAViewId const uaViewId = pUAIds[i];
+        if (uaViewId != SVGA3D_INVALID_ID)
+        {
+            ASSERT_GUEST_RETURN(uaViewId < pDXContext->pBackendDXContext->cUnorderedAccessView, VERR_INVALID_PARAMETER);
+
+            DXVIEW *pDXView = &pDXContext->pBackendDXContext->paUnorderedAccessView[uaViewId];
+            Assert(pDXView->u.pUnorderedAccessView);
+            papUnorderedAccessView[i] = pDXView->u.pUnorderedAccessView;
+        }
+        else
+            papUnorderedAccessView[i] = NULL;
+
+        aUAVInitialCounts[i] = (UINT)-1; /** @todo */
+    }
+
+    dxCSUnorderedAccessViewSet(pDevice, 0, SVGA3D_DX11_1_MAX_UAVIEWS, papUnorderedAccessView, aUAVInitialCounts);
+    return VINF_SUCCESS;
+}
+
+
+static DECLCALLBACK(int) vmsvga3dBackDXSetCSUAViews(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t startIndex, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend);
+
+    DXDEVICE *pDevice = dxDeviceFromContext(pThisCC->svga.p3dState, pDXContext);
+    AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+    RT_NOREF(startIndex, cUAViewId, paUAViewId);
+
+    return VINF_SUCCESS;
 }
 
@@ -8057 +8394 @@
                 p->pfnDXGrowCOTable               = vmsvga3dBackDXGrowCOTable;
                 p->pfnIntraSurfaceCopy            = vmsvga3dBackIntraSurfaceCopy;
-                p->pfnDefineGBSurface_v3          = vmsvga3dBackDefineGBSurface_v3;
                 p->pfnDXResolveCopy               = vmsvga3dBackDXResolveCopy;
                 p->pfnDXPredResolveCopy           = vmsvga3dBackDXPredResolveCopy;
@@ -8083 +8419 @@
                 p->pfnLogicOpsAlphaBlend          = vmsvga3dBackLogicOpsAlphaBlend;
                 p->pfnLogicOpsClearTypeBlend      = vmsvga3dBackLogicOpsClearTypeBlend;
-                p->pfnDefineGBSurface_v4          = vmsvga3dBackDefineGBSurface_v4;
                 p->pfnDXSetCSUAViews              = vmsvga3dBackDXSetCSUAViews;
                 p->pfnDXSetMinLOD                 = vmsvga3dBackDXSetMinLOD;

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

@@ -1163 +1163 @@
     default:
         AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface),
-                  ("surfaceFlags=0x%x\n", (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)));
+                  ("surfaceFlags=0x%x\n", (pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)));
         break;
     }
@@ -1528 +1528 @@
     if (   pSurfaceSrc->u.pSurface
         && !pSurfaceDest->u.pSurface
-        && RT_BOOL(pSurfaceDest->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE))
+        && RT_BOOL(pSurfaceDest->f.surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE))
     {
         /* Create the destination texture in the same context as the source texture. */
@@ -1538 +1538 @@
         AssertReturn(pContextSrc->pDevice, VERR_INTERNAL_ERROR);
 
-        LogFunc(("sid=%u type=%x format=%d -> create dest texture\n", sidDest, pSurfaceDest->surfaceFlags, pSurfaceDest->format));
+        LogFunc(("sid=%u type=%x format=%d -> create dest texture\n", sidDest, pSurfaceDest->f.s.surface1Flags, pSurfaceDest->format));
         rc = vmsvga3dBackCreateTexture(pThisCC, pContextSrc, cidSrc, pSurfaceDest);
         AssertRCReturn(rc, rc);
@@ -1881 +1881 @@
      * Create D3D texture object.
      */
-    if (pSurface->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
+    if (pSurface->f.surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
     {
         Assert(pSurface->cFaces == 6);
@@ -2259 +2259 @@
     Assert(pSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_NONE);
 
-    pSurface->surfaceFlags       |= SVGA3D_SURFACE_HINT_TEXTURE;
+    pSurface->f.surfaceFlags       |= SVGA3D_SURFACE_HINT_TEXTURE;
     pSurface->idAssociatedContext = idAssociatedContext;
     return VINF_SUCCESS;
@@ -2406 +2406 @@
             {
                 /** @todo inefficient for VRAM buffers!! */
-                if (RT_BOOL(pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET))
+                if (RT_BOOL(pSurface->f.surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET))
                 {
                     /* Copy the texture mipmap level to the bounce texture. */
@@ -2530 +2530 @@
     else
     {
-        AssertMsgFailed(("Unsupported surface flags 0x%08X, type %d\n", pSurface->surfaceFlags, pSurface->enmD3DResType));
+        AssertMsgFailed(("Unsupported surface flags 0x%08X, type %d\n", pSurface->f.s.surface1Flags, pSurface->enmD3DResType));
     }
 
@@ -2563 +2563 @@
 
         /* Unknown surface type; turn it into a texture. */
-        LogFunc(("unknown src surface sid=%u type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
+        LogFunc(("unknown src surface sid=%u type=%d format=%d -> create texture\n", sid, pSurface->f.s.surface1Flags, pSurface->format));
         rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pSurface);
         AssertRCReturn(rc, rc);
@@ -2720 +2720 @@
                 LogFunc(("Remove all dependencies for surface sid=%u\n", sid));
 
-                uint32_t const              surfaceFlags     = pSurface->surfaceFlags;
+                SVGA3dSurfaceAllFlags const surfaceFlags     = pSurface->f.surfaceFlags;
                 SVGA3dSurfaceFormat const   format           = pSurface->format;
                 uint32_t const              multisampleCount = pSurface->multiSampleCount;
@@ -4107 +4107 @@
 
         pRenderTarget->fUsageD3D            |= D3DUSAGE_DEPTHSTENCIL;
-        pRenderTarget->surfaceFlags         |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
+        pRenderTarget->f.surfaceFlags       |= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
 
         if (pRenderTarget->fStencilAsTexture)
@@ -4144 +4144 @@
         vmsvga3dSurfaceFlush(pRenderTarget);
 
-        if (pRenderTarget->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE)
+        if (pRenderTarget->f.surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE)
         {
             fTexture = true;
@@ -4151 +4151 @@
             if (!pRenderTarget->u.pTexture)
             {
-                LogFunc(("Create texture to be used as render target; sid=%u type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
+                LogFunc(("Create texture to be used as render target; sid=%u type=%d format=%d -> create texture\n", target.sid, pRenderTarget->f.s.surface1Flags, pRenderTarget->format));
                 rc = vmsvga3dBackCreateTexture(pThisCC, pContext, cid, pRenderTarget);
                 AssertRCReturn(rc, rc);
@@ -4209 +4209 @@
 
         pRenderTarget->fUsageD3D            |= D3DUSAGE_RENDERTARGET;
-        pRenderTarget->surfaceFlags         |= SVGA3D_SURFACE_HINT_RENDERTARGET;
+        pRenderTarget->f.surfaceFlags       |= SVGA3D_SURFACE_HINT_RENDERTARGET;
 
         hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pSurface);
@@ -5006 +5006 @@
         pVertexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER;
         pVertexSurface->idAssociatedContext = pContext->id;
-        pVertexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
+        pVertexSurface->f.surfaceFlags |= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
         fSync = true;
     }
@@ -5062 +5062 @@
         pIndexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_INDEX_BUFFER;
         pIndexSurface->idAssociatedContext = pContext->id;
-        pIndexSurface->surfaceFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
+        pIndexSurface->f.surfaceFlags |= SVGA3D_SURFACE_HINT_INDEXBUFFER;
         fSync = true;
     }
@@ -6203 +6203 @@
      * wast memory on them).
      */
-    uint32_t const fSwitchFlags = pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
+    uint32_t const fSwitchFlags = pSurface->f.s.surface1Flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK;
     if (   fSwitchFlags != SVGA3D_SURFACE_HINT_DEPTHSTENCIL
         && fSwitchFlags != (SVGA3D_SURFACE_HINT_DEPTHSTENCIL | SVGA3D_SURFACE_HINT_TEXTURE))

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

@@ -83 +83 @@
  * @param   fAllocMipLevels     .
  */
-int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, SVGA3dSurface1Flags surfaceFlags, SVGA3dSurfaceFormat format,
+int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, SVGA3dSurfaceAllFlags surfaceFlags, SVGA3dSurfaceFormat format,
                           uint32_t multisampleCount, SVGA3dTextureFilter autogenFilter,
                           uint32_t numMipLevels, SVGA3dSize const *pMipLevel0Size, uint32_t arraySize, bool fAllocMipLevels)
@@ -214 +214 @@
     }
 
-    pSurface->surfaceFlags      = surfaceFlags;
+    pSurface->f.surfaceFlags    = surfaceFlags;
     pSurface->format            = format;
     /* cFaces is 6 for a cubemaps and 1 otherwise. */
@@ -518 +518 @@
     {
         /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
-        LogFunc(("unknown src sid=%u type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->surfaceFlags, pSrcSurface->format));
+        LogFunc(("unknown src sid=%u type=%d format=%d -> create texture\n", sidSrc, pSrcSurface->f.s.surface1Flags, pSrcSurface->format));
         rc = pSvgaR3State->pFuncs3D->pfnCreateTexture(pThisCC, pContext, pContext->id, pSrcSurface);
         AssertRCReturn(rc, rc);
@@ -526 +526 @@
     {
         /* Unknown surface type; turn it into a texture, which can be used for other purposes too. */
-        LogFunc(("unknown dest sid=%u type=%d format=%d -> create texture\n", sidDst, pDstSurface->surfaceFlags, pDstSurface->format));
+        LogFunc(("unknown dest sid=%u type=%d format=%d -> create texture\n", sidDst, pDstSurface->f.s.surface1Flags, pDstSurface->format));
         rc = pSvgaR3State->pFuncs3D->pfnCreateTexture(pThisCC, pContext, pContext->id, pDstSurface);
         AssertRCReturn(rc, rc);
@@ -573 +573 @@
 
     LogFunc(("%sguestptr gmr=%x offset=%x pitch=%x host sid=%u face=%d mipmap=%d transfer=%s cCopyBoxes=%d\n",
-             (pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE) ? "TEXTURE " : "",
+             (pSurface->f.surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE) ? "TEXTURE " : "",
              guest.ptr.gmrId, guest.ptr.offset, guest.pitch,
              host.sid, host.face, host.mipmap, (transfer == SVGA3D_WRITE_HOST_VRAM) ? "READ" : "WRITE", cCopyBoxes));

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

@@ -97 +97 @@
 int vmsvga3dQueryCaps(PVGASTATECC pThisCC, SVGA3dDevCapIndex idx3dCaps, uint32_t *pu32Val);
 
-int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, SVGA3dSurface1Flags surfaceFlags, SVGA3dSurfaceFormat format,
+int vmsvga3dSurfaceDefine(PVGASTATECC pThisCC, uint32_t sid, SVGA3dSurfaceAllFlags surfaceFlags, SVGA3dSurfaceFormat format,
                           uint32_t multisampleCount, SVGA3dTextureFilter autogenFilter,
                           uint32_t cMipLevels, SVGA3dSize const *pMipLevel0Size, uint32_t arraySize, bool fAllocMipLevels);
@@ -499 +499 @@
     DECLCALLBACKMEMBER(int, pfnDXGrowCOTable,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnIntraSurfaceCopy,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDefineGBSurface_v3,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXResolveCopy,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXPredResolveCopy,           (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -505 +504 @@
     DECLCALLBACKMEMBER(int, pfnDXPredConvert,               (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnWholeSurfaceCopy,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXDefineUAView,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXDestroyUAView,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXClearUAViewUint,           (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXClearUAViewFloat,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
+    DECLCALLBACKMEMBER(int, pfnDXDefineUAView,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, SVGACOTableDXUAViewEntry const *pEntry));
+    DECLCALLBACKMEMBER(int, pfnDXDestroyUAView,             (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId));
+    DECLCALLBACKMEMBER(int, pfnDXClearUAViewUint,           (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, uint32_t const aValues[4]));
+    DECLCALLBACKMEMBER(int, pfnDXClearUAViewFloat,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dUAViewId uaViewId, float const aValues[4]));
     DECLCALLBACKMEMBER(int, pfnDXCopyStructureCount,        (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXSetUAViews,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
+    DECLCALLBACKMEMBER(int, pfnDXSetUAViews,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t uavSpliceIndex, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId));
     DECLCALLBACKMEMBER(int, pfnDXDrawIndexedInstancedIndirect, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXDrawInstancedIndirect,     (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXDispatch,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
+    DECLCALLBACKMEMBER(int, pfnDXDispatch,                  (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t threadGroupCountX, uint32_t threadGroupCountY, uint32_t threadGroupCountZ));
     DECLCALLBACKMEMBER(int, pfnDXDispatchIndirect,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnWriteZeroSurface,            (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -525 +524 @@
     DECLCALLBACKMEMBER(int, pfnLogicOpsAlphaBlend,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnLogicOpsClearTypeBlend,      (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDefineGBSurface_v4,          (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
-    DECLCALLBACKMEMBER(int, pfnDXSetCSUAViews,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
+    DECLCALLBACKMEMBER(int, pfnDXSetCSUAViews,              (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t startIndex, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId));
     DECLCALLBACKMEMBER(int, pfnDXSetMinLOD,                 (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
     DECLCALLBACKMEMBER(int, pfnDXDefineStreamOutputWithMob, (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -629 +627 @@
 int vmsvga3dDXGrowCOTable(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dIntraSurfaceCopy(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDefineGBSurface_v3(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXResolveCopy(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXPredResolveCopy(PVGASTATECC pThisCC, uint32_t idDXContext);
@@ -635 +632 @@
 int vmsvga3dDXPredConvert(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dWholeSurfaceCopy(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXDefineUAView(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXDestroyUAView(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXClearUAViewUint(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXClearUAViewFloat(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXDefineUAView(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDefineUAView const *pCmd);
+int vmsvga3dDXDestroyUAView(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDestroyUAView const *pCmd);
+int vmsvga3dDXClearUAViewUint(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXClearUAViewUint const *pCmd);
+int vmsvga3dDXClearUAViewFloat(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXClearUAViewFloat const *pCmd);
 int vmsvga3dDXCopyStructureCount(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXSetUAViews(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXSetUAViews(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetUAViews const *pCmd, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId);
 int vmsvga3dDXDrawIndexedInstancedIndirect(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXDrawInstancedIndirect(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXDispatch(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXDispatch(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDispatch const *pCmd);
 int vmsvga3dDXDispatchIndirect(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dWriteZeroSurface(PVGASTATECC pThisCC, uint32_t idDXContext);
@@ -655 +652 @@
 int vmsvga3dLogicOpsAlphaBlend(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dLogicOpsClearTypeBlend(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDefineGBSurface_v4(PVGASTATECC pThisCC, uint32_t idDXContext);
-int vmsvga3dDXSetCSUAViews(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXSetCSUAViews(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetCSUAViews const *pCmd, uint32_t cUAViewId, SVGA3dUAViewId const *paUAViewId);
 int vmsvga3dDXSetMinLOD(PVGASTATECC pThisCC, uint32_t idDXContext);
 int vmsvga3dDXDefineStreamOutputWithMob(PVGASTATECC pThisCC, uint32_t idDXContext);

trunk/src/VBox/Devices/Graphics/DevVGASavedState.h

@@ -47 +47 @@
     } while (0)
 
-#define VGA_SAVEDSTATE_VERSION                   25
+#define VGA_SAVEDSTATE_VERSION                   26
+#define VGA_SAVEDSTATE_VERSION_VMSVGA_DX_SFLAGS  26 /* SVGA3dSurfaceAllFlags. */
 #define VGA_SAVEDSTATE_VERSION_VMSVGA_DX_CMDBUF  25 /* Command buffers capability is not tied to VGPU10 setting. */
 #define VGA_SAVEDSTATE_VERSION_VMSVGA_DX         24 /* VGPU10. */