Changeset 91441 in vbox

Timestamp:

Sep 28, 2021 5:37:53 PM (3 years ago)

Author:

vboxsync

Message:

Devices/Graphics: staging buffer for transfers; stream output: bugref:9830

Location:

trunk/src/VBox/Devices/Graphics

Files:

• DevVGA-SVGA-cmd.cpp (modified) (2 diffs)
• DevVGA-SVGA3d-dx-shader.cpp (modified) (2 diffs)
• DevVGA-SVGA3d-dx-shader.h (modified) (1 diff)
• DevVGA-SVGA3d-dx.cpp (modified) (3 diffs)
• DevVGA-SVGA3d-win-dx.cpp (modified) (40 diffs)
• DevVGA-SVGA3d.h (modified) (2 diffs)

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

@@ -3075 +3075 @@
 {
 #ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
+    //DEBUG_BREAKPOINT_TEST();
     RT_NOREF(cbCmd);
     return vmsvga3dDXDefineStreamOutput(pThisCC, idDXContext, pCmd);
@@ -3103 +3103 @@
 {
 #ifdef VMSVGA3D_DX
-    DEBUG_BREAKPOINT_TEST();
-    PVMSVGAR3STATE const pSvgaR3State = pThisCC->svga.pSvgaR3State;
-    RT_NOREF(pSvgaR3State, pCmd, cbCmd);
-    return vmsvga3dDXSetStreamOutput(pThisCC, idDXContext);
+    //DEBUG_BREAKPOINT_TEST();
+    RT_NOREF(cbCmd);
+    return vmsvga3dDXSetStreamOutput(pThisCC, idDXContext, pCmd);
 #else
     RT_NOREF(pThisCC, idDXContext, pCmd, cbCmd);

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

@@ -1617 +1617 @@
                 case VGPU10_OPCODE_DCL_OUTPUT:
                 case VGPU10_OPCODE_DCL_OUTPUT_SIV:
+                case VGPU10_OPCODE_DCL_OUTPUT_SGV:
                     ASSERT_GUEST_RETURN(pInfo->cOutputSignature < RT_ELEMENTS(pInfo->aOutputSignature), VERR_INVALID_PARAMETER);
                     pSignatureEntry = &pInfo->aOutputSignature[pInfo->cOutputSignature++];
@@ -1943 +1944 @@
 
 
+static char const *dxbcGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister, uint32_t u32BlobType,
+                                             uint32_t cSignature, SVGA3dDXSignatureEntry const *paSignature)
+{
+    for (uint32_t i = 0; i < cSignature; ++i)
+    {
+        SVGA3dDXSignatureEntry const *p = &paSignature[i];
+        if (p->registerIndex == idxRegister)
+        {
+            AssertReturn(p->semanticName < SVGADX_SIGNATURE_SEMANTIC_NAME_MAX, NULL);
+            VGPUSemanticInfo const *pSemanticInfo = dxbcSemanticInfo(pInfo, p->semanticName, u32BlobType);
+            return pSemanticInfo->pszName;
+        }
+    }
+    return NULL;
+}
+
+char const *DXShaderGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister)
+{
+    return dxbcGetOutputSemanticName(pInfo, idxRegister, DXBC_BLOB_TYPE_OSGN, pInfo->cOutputSignature, &pInfo->aOutputSignature[0]);
+}
+
+
 #ifdef DXBC_STANDALONE_TEST
 static int dxbcCreateFromBytecode(void const *pvShaderCode, uint32_t cbShaderCode, void **ppvDXBC, uint32_t *pcbDXBC)

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

@@ -48 +48 @@
 int DXShaderParse(void const *pvCode, uint32_t cbCode, DXShaderInfo *pInfo);
 int DXShaderCreateDXBC(DXShaderInfo const *pInfo, void const *pvShader, uint32_t cbShader, void **ppvDXBC, uint32_t *pcbDXBC);
+char const *DXShaderGetOutputSemanticName(DXShaderInfo const *pInfo, uint32_t idxRegister);
 
 #endif /* !VBOX_INCLUDED_SRC_Graphics_DevVGA_SVGA3d_dx_shader_h */

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

@@ -1581 +1581 @@
     memcpy(pEntry->decl, pCmd->decl, sizeof(pEntry->decl));
     memcpy(pEntry->streamOutputStrideInBytes, pCmd->streamOutputStrideInBytes, sizeof(pEntry->streamOutputStrideInBytes));
-    pEntry->rasterizedStream = pCmd->rasterizedStream;
-    pEntry->numOutputStreamStrides;
+    pEntry->rasterizedStream = 0; // Apparently invalid in this command: pCmd->rasterizedStream;
+    pEntry->numOutputStreamStrides = 0;
     pEntry->mobid = SVGA_ID_INVALID;
     pEntry->offsetInBytes = 0;
@@ -1623 +1623 @@
 
 
-int vmsvga3dDXSetStreamOutput(PVGASTATECC pThisCC, uint32_t idDXContext)
+int vmsvga3dDXSetStreamOutput(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetStreamOutput const *pCmd)
 {
     int rc;
@@ -1635 +1635 @@
     AssertRCReturn(rc, rc);
 
-    rc = pSvgaR3State->pFuncsDX->pfnDXSetStreamOutput(pThisCC, pDXContext);
+    SVGA3dStreamOutputId const soid = pCmd->soid;
+
+    ASSERT_GUEST_RETURN(pDXContext->cot.paStreamOutput, VERR_INVALID_STATE);
+    ASSERT_GUEST_RETURN(   soid == SVGA_ID_INVALID
+                        || soid < pDXContext->cot.cStreamOutput, VERR_INVALID_PARAMETER);
+    RT_UNTRUSTED_VALIDATED_FENCE();
+
+    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-win-dx.cpp

@@ -59 +59 @@
     IDXGIFactory               *pDxgiFactory;          /* DXGI Factory. */
     D3D_FEATURE_LEVEL           FeatureLevel;
+
+    /* Staging buffer for transfer to surface buffers. */
+    ID3D11Buffer              *pStagingBuffer;         /* The staging buffer resource. */
+    uint32_t                   cbStagingBuffer;        /* Current size of the staging buffer resource. */
 } DXDEVICE;
 
@@ -145 +149 @@
     void                       *pvDXBC;
     uint32_t                    cbDXBC;
+
+    uint32_t                    soid;               /* Stream output declarations for geometry shaders. */
 } DXSHADER;
 
 typedef struct DXSTREAMOUTPUT
 {
-    ID3D11Buffer *pSOBuffer;
+    UINT                       cDeclarationEntry;
+    D3D11_SO_DECLARATION_ENTRY aDeclarationEntry[SVGA3D_MAX_STREAMOUT_DECLS];
 } DXSTREAMOUTPUT;
 
+#define DX_DEFERRED_SET_RENDER_TARGETS
 typedef struct VMSVGA3DBACKENDDXCONTEXT
 {
@@ -179 +187 @@
     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;
 
@@ -744 +763 @@
                     D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_NOT_SET,     /* U. */
                     D3D11_MESSAGE_ID_DEVICE_DRAW_SAMPLER_MISMATCH,    /* U. */
+                    D3D11_MESSAGE_ID_CREATEINPUTLAYOUT_EMPTY_LAYOUT,  /* P. */
                 };
 
@@ -784 +804 @@
 {
     RT_NOREF(pBackend);
+
+    D3D_RELEASE(pDevice->pStagingBuffer);
+
     if (pDevice->pImmediateContext)
         pDevice->pImmediateContext->ClearState();
@@ -952 +975 @@
 }
 
+
 static int dxDefineStreamOutput(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid, SVGACOTableDXStreamOutputEntry const *pEntry)
 {
-    RT_NOREF(pDXContext, soid, pEntry);
+    DXSTREAMOUTPUT *pDXStreamOutput = &pDXContext->pBackendDXContext->paStreamOutput[soid];
+
+    /* Make D3D11_SO_DECLARATION_ENTRY array from SVGA3dStreamOutputDeclarationEntry. */
+    pDXStreamOutput->cDeclarationEntry = pEntry->numOutputStreamEntries;
+    for (uint32_t i = 0; i < pDXStreamOutput->cDeclarationEntry; ++i)
+    {
+        D3D11_SO_DECLARATION_ENTRY *pDst = &pDXStreamOutput->aDeclarationEntry[i];
+        SVGA3dStreamOutputDeclarationEntry const *pSrc = &pEntry->decl[i];
+
+        uint32_t const registerMask = pSrc->registerMask & 0xF;
+        unsigned const iFirstBit = ASMBitFirstSetU32(registerMask);
+        unsigned const iLastBit = ASMBitLastSetU32(registerMask);
+
+        pDst->Stream         = pSrc->stream;
+        pDst->SemanticName   = NULL; /* Will be taken from the shader output declaration. */
+        pDst->SemanticIndex  = 0;
+        pDst->StartComponent = iFirstBit > 0 ? iFirstBit - 1 : 0;
+        pDst->ComponentCount = iFirstBit > 0 ? iLastBit - (iFirstBit - 1) : 0;
+        pDst->OutputSlot     = pSrc->outputSlot;
+    }
+
     return VINF_SUCCESS;
 }
@@ -960 +1004 @@
 static void dxDestroyStreamOutput(DXSTREAMOUTPUT *pDXStreamOutput)
 {
-    D3D_RELEASE(pDXStreamOutput->pSOBuffer);
+    RT_NOREF(pDXStreamOutput);
 }
 
@@ -1296 +1340 @@
 
 
-static HRESULT dxShaderCreate(DXDEVICE *pDevice, PVMSVGA3DSHADER pShader, DXSHADER *pDXShader)
-{
+static HRESULT dxShaderCreate(PVMSVGA3DDXCONTEXT pDXContext, PVMSVGA3DSHADER pShader, DXSHADER *pDXShader)
+{
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+
     HRESULT hr = S_OK;
 
@@ -1311 +1357 @@
             break;
         case SVGA3D_SHADERTYPE_GS:
-            hr = pDevice->pDevice->CreateGeometryShader(pDXShader->pvDXBC, pDXShader->cbDXBC, NULL, &pDXShader->pGeometryShader);
+        {
+            SVGA3dStreamOutputId const soid = pDXContext->svgaDXContext.streamOut.soid;
+            if (soid == SVGA_ID_INVALID)
+                hr = pDevice->pDevice->CreateGeometryShader(pDXShader->pvDXBC, pDXShader->cbDXBC, NULL, &pDXShader->pGeometryShader);
+            else
+            {
+                ASSERT_GUEST_RETURN(soid < pDXContext->pBackendDXContext->cStreamOutput, E_INVALIDARG);
+
+                SVGACOTableDXStreamOutputEntry const *pEntry = &pDXContext->cot.paStreamOutput[soid];
+                DXSTREAMOUTPUT *pDXStreamOutput = &pDXContext->pBackendDXContext->paStreamOutput[soid];
+                uint32_t const cSOTarget = pDXContext->pBackendDXContext->cSOTarget;
+
+                for (uint32_t i = 0; i < pDXStreamOutput->cDeclarationEntry; ++i)
+                {
+                    D3D11_SO_DECLARATION_ENTRY *p = &pDXStreamOutput->aDeclarationEntry[i];
+                    SVGA3dStreamOutputDeclarationEntry const *decl = &pEntry->decl[i];
+                    p->SemanticName = DXShaderGetOutputSemanticName(&pShader->shaderInfo, decl->registerIndex);
+                }
+
+                hr = pDevice->pDevice->CreateGeometryShaderWithStreamOutput(pDXShader->pvDXBC, pDXShader->cbDXBC,
+                    pDXStreamOutput->aDeclarationEntry, pDXStreamOutput->cDeclarationEntry,
+                    pEntry->streamOutputStrideInBytes, cSOTarget, pEntry->rasterizedStream,
+                    /*pClassLinkage=*/ NULL, &pDXShader->pGeometryShader);
+                if (SUCCEEDED(hr))
+                    pDXShader->soid = soid;
+            }
             Assert(SUCCEEDED(hr));
             break;
+        }
         case SVGA3D_SHADERTYPE_HS:
         case SVGA3D_SHADERTYPE_DS:
@@ -1325 +1397 @@
 
 
-static void dxShaderSet(DXDEVICE *pDevice, SVGA3dShaderType type, DXSHADER *pDXShader)
-{
+static void dxShaderSet(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderType type, DXSHADER *pDXShader)
+{
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+
     switch (type)
     {
@@ -1336 +1410 @@
             break;
         case SVGA3D_SHADERTYPE_GS:
+        {
+            Assert(!pDXShader || (pDXShader->soid == pDXContext->svgaDXContext.streamOut.soid));
             pDevice->pImmediateContext->GSSetShader(pDXShader ? pDXShader->pGeometryShader : NULL, NULL, 0);
-            break;
+        } break;
         case SVGA3D_SHADERTYPE_HS:
         case SVGA3D_SHADERTYPE_DS:
@@ -2052 +2128 @@
                                                    | SVGA3D_SURFACE_BIND_VERTEX_BUFFER
                                                    | SVGA3D_SURFACE_BIND_INDEX_BUFFER
-                                                   /// @todo only for constant buffers| SVGA3D_SURFACE_BIND_CONSTANT_BUFFER
-                                                   //| SVGA3D_SURFACE_BIND_STREAM_OUTPUT
                         )), VERR_INVALID_PARAMETER);
 
@@ -2062 +2136 @@
     }
 
+    PVMSVGA3DMIPMAPLEVEL pMipLevel;
+    int rc = vmsvga3dMipmapLevel(pSurface, 0, 0, &pMipLevel);
+    AssertRCReturn(rc, rc);
+
     PVMSVGA3DBACKENDSURFACE pBackendSurface;
-    int rc = dxBackendSurfaceAlloc(&pBackendSurface);
+    rc = dxBackendSurfaceAlloc(&pBackendSurface);
     AssertRCReturn(rc, rc);
+
+    /* Upload the current data, if any. */
+    D3D11_SUBRESOURCE_DATA *pInitialData = NULL;
+    D3D11_SUBRESOURCE_DATA initialData;
+    if (pMipLevel->pSurfaceData)
+    {
+        initialData.pSysMem          = pMipLevel->pSurfaceData;
+        initialData.SysMemPitch      = pMipLevel->cbSurface;
+        initialData.SysMemSlicePitch = pMipLevel->cbSurface;
+
+        pInitialData = &initialData;
+
+        pMipLevel->fDirty = false;
+        pSurface->fDirty = false;
+    }
 
     D3D11_BUFFER_DESC bd;
     RT_ZERO(bd);
-    bd.ByteWidth = pSurface->paMipmapLevels[0].cbSurface;
-    bd.Usage = D3D11_USAGE_DYNAMIC;
-    bd.BindFlags           = D3D11_BIND_VERTEX_BUFFER
-                           | D3D11_BIND_INDEX_BUFFER
-                           //| D3D11_BIND_CONSTANT_BUFFER
-                           //| D3D11_BIND_STREAM_OUTPUT
-                           ;
-    bd.CPUAccessFlags      = D3D11_CPU_ACCESS_WRITE;
-    bd.MiscFlags           = 0;
-    bd.StructureByteStride = 0;
-
-    HRESULT hr = pDevice->pDevice->CreateBuffer(&bd, 0, &pBackendSurface->u.pBuffer);
+    bd.ByteWidth = pMipLevel->cbSurface;
+    bd.Usage     = D3D11_USAGE_DEFAULT;
+    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER
+                 | D3D11_BIND_INDEX_BUFFER;
+
+    HRESULT hr = pDevice->pDevice->CreateBuffer(&bd, pInitialData, &pBackendSurface->u.pBuffer);
     if (SUCCEEDED(hr))
     {
@@ -2089 +2176 @@
         pSurface->pBackendSurface = pBackendSurface;
         pSurface->idAssociatedContext = pDXContext->cid;
-        pSurface->fDirty = true;
         return VINF_SUCCESS;
     }
@@ -2311 +2397 @@
     RTMemFree(pBackendSurface);
     return VERR_NO_MEMORY;
+}
+
+
+static int dxStagingBufferRealloc(DXDEVICE *pDXDevice, uint32_t cbRequiredSize)
+{
+    AssertReturn(cbRequiredSize < SVGA3D_MAX_SURFACE_MEM_SIZE, VERR_INVALID_PARAMETER);
+
+    if (RT_LIKELY(cbRequiredSize <= pDXDevice->cbStagingBuffer))
+        return VINF_SUCCESS;
+
+    D3D_RELEASE(pDXDevice->pStagingBuffer);
+
+    uint32_t const cbAlloc = RT_ALIGN_32(cbRequiredSize, _64K);
+
+    D3D11_SUBRESOURCE_DATA *pInitialData = NULL;
+    D3D11_BUFFER_DESC bd;
+    RT_ZERO(bd);
+    bd.ByteWidth           = cbAlloc;
+    bd.Usage               = D3D11_USAGE_STAGING;
+    //bd.BindFlags         = 0; /* No bind flags are allowed for staging resources. */
+    bd.CPUAccessFlags      = D3D11_CPU_ACCESS_WRITE | D3D11_CPU_ACCESS_READ;
+
+    int rc = VINF_SUCCESS;
+    ID3D11Buffer *pBuffer;
+    HRESULT hr = pDXDevice->pDevice->CreateBuffer(&bd, pInitialData, &pBuffer);
+    if (SUCCEEDED(hr))
+    {
+        pDXDevice->pStagingBuffer = pBuffer;
+        pDXDevice->cbStagingBuffer = cbAlloc;
+    }
+    else
+    {
+        pDXDevice->cbStagingBuffer = 0;
+        rc = VERR_NO_MEMORY;
+    }
+
+    return rc;
 }
 
@@ -2659 +2782 @@
         clipBox.d = pMipLevel->mipmapSize.depth;
     }
-
-/// @todo Hack. Need Staging buffer ro CopyResource data to the actual buffer
-if (enmMapType == VMSVGA3D_SURFACE_MAP_WRITE && pBackendSurface->enmResType == VMSVGA3D_RESTYPE_BUFFER)
-    enmMapType = VMSVGA3D_SURFACE_MAP_WRITE_DISCARD;
 
     D3D11_MAP d3d11MapType;
@@ -2801 +2920 @@
     else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_BUFFER)
     {
-        UINT const Subresource = 0; /* Buffers have only one subresource. */
-        HRESULT hr = pDevice->pImmediateContext->Map(pSurface->pBackendSurface->u.pBuffer, Subresource,
-                                                     d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
-        if (SUCCEEDED(hr))
+        /* Map the staging buffer. */
+        rc = dxStagingBufferRealloc(pDevice, pMipLevel->cbSurface);
+        if (RT_SUCCESS(rc))
         {
-            pMap->enmMapType   = enmMapType;
-            pMap->box          = clipBox;
-            pMap->cbPixel      = pSurface->cbBlock;
-            pMap->cbRowPitch   = mappedResource.RowPitch;
-            pMap->cbDepthPitch = mappedResource.DepthPitch;
-            pMap->pvData       = (uint8_t *)mappedResource.pData
-                               + pMap->box.x * pMap->cbPixel
-                               + pMap->box.y * pMap->cbRowPitch
-                               + pMap->box.z * pMap->cbDepthPitch;
+            if (enmMapType == VMSVGA3D_SURFACE_MAP_READ)
+            {
+                /* Copy from the buffer to the staging buffer. */
+                ID3D11Resource *pDstResource = pDevice->pStagingBuffer;
+                UINT DstSubresource = 0;
+                UINT DstX = clipBox.x;
+                UINT DstY = clipBox.y;
+                UINT DstZ = clipBox.z;
+                ID3D11Resource *pSrcResource = pBackendSurface->u.pResource;
+                UINT SrcSubresource = 0;
+                D3D11_BOX SrcBox;
+                SrcBox.left   = clipBox.x;
+                SrcBox.top    = clipBox.y;
+                SrcBox.front  = clipBox.z;
+                SrcBox.right  = clipBox.w;
+                SrcBox.bottom = clipBox.h;
+                SrcBox.back   = clipBox.d;
+                pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
+                                                                  pSrcResource, SrcSubresource, &SrcBox);
+            }
+
+            UINT const Subresource = 0; /* Buffers have only one subresource. */
+            HRESULT hr = pDevice->pImmediateContext->Map(pDevice->pStagingBuffer, Subresource,
+                                                         d3d11MapType, /* MapFlags =  */ 0, &mappedResource);
+            if (SUCCEEDED(hr))
+            {
+                pMap->enmMapType   = enmMapType;
+                pMap->box          = clipBox;
+                pMap->cbPixel      = pSurface->cbBlock;
+                pMap->cbRowPitch   = mappedResource.RowPitch;
+                pMap->cbDepthPitch = mappedResource.DepthPitch;
+                pMap->pvData       = (uint8_t *)mappedResource.pData
+                                   + pMap->box.x * pMap->cbPixel
+                                   + pMap->box.y * pMap->cbRowPitch
+                                   + pMap->box.z * pMap->cbDepthPitch;
+            }
+            else
+                rc = VERR_NOT_SUPPORTED;
         }
-        else
-            rc = VERR_NOT_SUPPORTED;
     }
     else
@@ -2878 +3023 @@
             UINT DstY = pMap->box.y;
             UINT DstZ = pMap->box.z;
-            ID3D11Resource *pSrcResource = pBackendSurface->pDynamicTexture;
+            ID3D11Resource *pSrcResource = pMappedTexture;
             UINT SrcSubresource = Subresource;
             D3D11_BOX SrcBox;
@@ -2962 +3107 @@
     else if (pBackendSurface->enmResType == VMSVGA3D_RESTYPE_BUFFER)
     {
+        /* Unmap the staging buffer. */
         UINT const Subresource = 0; /* Buffers have only one subresource. */
-        pDevice->pImmediateContext->Unmap(pBackendSurface->u.pBuffer, Subresource);
+        pDevice->pImmediateContext->Unmap(pDevice->pStagingBuffer, Subresource);
+
+        /* Copy from the staging buffer to the actual buffer */
+        if (   fWritten
+            && (   pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE
+                || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_READ_WRITE
+                || pMap->enmMapType == VMSVGA3D_SURFACE_MAP_WRITE_DISCARD))
+        {
+            ID3D11Resource *pDstResource = pBackendSurface->u.pResource;
+            UINT DstSubresource = 0;
+            UINT DstX = (pMap->box.x / pSurface->cxBlock) * pSurface->cxBlock;
+            UINT DstY = (pMap->box.y / pSurface->cyBlock) * pSurface->cyBlock;
+            UINT DstZ = pMap->box.z;
+            ID3D11Resource *pSrcResource = pDevice->pStagingBuffer;
+            UINT SrcSubresource = 0;
+            D3D11_BOX SrcBox;
+
+            uint32_t const cxBlocks = (pMap->box.w + pSurface->cxBlock - 1) / pSurface->cxBlock;
+            uint32_t const cyBlocks = (pMap->box.h + pSurface->cyBlock - 1) / pSurface->cyBlock;
+
+            SrcBox.left   = DstX;
+            SrcBox.top    = DstY;
+            SrcBox.front  = DstZ;
+            SrcBox.right  = DstX + cxBlocks * pSurface->cxBlock;
+            SrcBox.bottom = DstY + cyBlocks * pSurface->cyBlock;
+            SrcBox.back   = DstZ + pMap->box.d;
+
+            pDevice->pImmediateContext->CopySubresourceRegion(pDstResource, DstSubresource, DstX, DstY, DstZ,
+                                                              pSrcResource, SrcSubresource, &SrcBox);
+        }
     }
     else
@@ -4630 +4805 @@
         pDXShader = NULL;
 
-    dxShaderSet(pDevice, type, pDXShader);
+    dxShaderSet(pDXContext, type, pDXShader);
     return VINF_SUCCESS;
 }
@@ -4664 +4839 @@
 
 
+#ifdef DX_DEFERRED_SET_RENDER_TARGETS
+static void dxSetupPipeline(PVMSVGA3DDXCONTEXT pDXContext)
+{
+    DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
+    AssertReturnVoid(pDevice->pDevice);
+
+    pDevice->pImmediateContext->OMSetRenderTargets(pDXContext->pBackendDXContext->state.cRenderTargetViews,
+                                                   pDXContext->pBackendDXContext->state.papRenderTargetViews,
+                                                   pDXContext->pBackendDXContext->state.pDepthStencilView);
+}
+#endif
+
+
 static DECLCALLBACK(int) vmsvga3dBackDXDraw(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t vertexCount, uint32_t startVertexLocation)
 {
@@ -4671 +4859 @@
     DXDEVICE *pDevice = &pDXContext->pBackendDXContext->device;
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
+
+#ifdef DX_DEFERRED_SET_RENDER_TARGETS
+    dxSetupPipeline(pDXContext);
+#endif
 
     if (pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN)
@@ -4754 +4946 @@
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
+#ifdef DX_DEFERRED_SET_RENDER_TARGETS
+    dxSetupPipeline(pDXContext);
+#endif
+
     Assert(pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN);
 
@@ -4774 +4970 @@
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
+#ifdef DX_DEFERRED_SET_RENDER_TARGETS
+    dxSetupPipeline(pDXContext);
+#endif
+
     Assert(pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN);
 
@@ -4794 +4994 @@
     AssertReturn(pDevice->pDevice, VERR_INVALID_STATE);
 
+#ifdef DX_DEFERRED_SET_RENDER_TARGETS
+    dxSetupPipeline(pDXContext);
+#endif
+
     Assert(pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN);
 
@@ -4809 +5013 @@
     Assert(pDXContext->svgaDXContext.inputAssembly.topology != SVGA3D_PRIMITIVE_TRIANGLEFAN);
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+
+#ifdef DX_DEFERRED_SET_RENDER_TARGETS
+    dxSetupPipeline(pDXContext);
+#endif
 
     RT_NOREF(pBackend, pDXContext);
@@ -4882 +5090 @@
             if (pSurface->pBackendSurface == NULL)
             {
-                /* Create the resource. */
+                /* Create the resource and initialize it with the current surface data. */
                 rc = vmsvga3dBackSurfaceCreateBuffer(pThisCC, pDXContext, pSurface);
                 AssertRCReturn(rc, rc);
             }
-
+#if 0
             if (pSurface->fDirty)
             {
@@ -4906 +5114 @@
                 AssertRCReturn(rc, rc);
             }
+#endif
 
             Assert(pSurface->pBackendSurface->u.pBuffer);
@@ -4951 +5160 @@
         if (pSurface->pBackendSurface == NULL)
         {
-            /* Create the resource. */
+            /* Create the resource and initialize it with the current surface data. */
             rc = vmsvga3dBackSurfaceCreateBuffer(pThisCC, pDXContext, pSurface);
             AssertRCReturn(rc, rc);
         }
-
+#if 0
         if (pSurface->fDirty)
         {
@@ -4975 +5184 @@
             AssertRCReturn(rc, rc);
         }
-
+#endif
         pResource = pSurface->pBackendSurface->u.pBuffer;
         enmDxgiFormat = vmsvgaDXSurfaceFormat2Dxgi(format);
@@ -5064 +5273 @@
 
     ID3D11RenderTargetView *papRenderTargetViews[SVGA3D_MAX_RENDER_TARGETS];
+    RT_ZERO(papRenderTargetViews);
     for (uint32_t i = 0; i < cRenderTargetViewId; ++i)
     {
@@ -5072 +5282 @@
             papRenderTargetViews[i] = pDXContext->pBackendDXContext->papRenderTargetView[renderTargetViewId];
         }
-        else
-            papRenderTargetViews[i] = NULL;
     }
 
@@ -5082 +5290 @@
         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
     return VINF_SUCCESS;
 }
@@ -5217 +5432 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXSetSOTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t cSoTarget, SVGA3dSoTarget const *paSoTarget)
+static DECLCALLBACK(int) vmsvga3dBackDXSetSOTargets(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, uint32_t cSOTarget, SVGA3dSoTarget const *paSoTarget)
 {
     PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
@@ -5238 +5453 @@
     {
         /* Get corresponding resource. Create the buffer if does not yet exist. */
-        if (i < cSoTarget && paSoTarget[i].sid != SVGA_ID_INVALID)
+        if (i < cSOTarget && paSoTarget[i].sid != SVGA_ID_INVALID)
         {
             PVMSVGA3DSURFACE pSurface;
@@ -5266 +5481 @@
             pDXContext->svgaDXContext.streamOut.targets[i] = SVGA_ID_INVALID;
         }
-
-        /// @todo pDXContext->svgaDXContext.streamOut.soid?
     }
 
     pDevice->pImmediateContext->SOSetTargets(SVGA3D_DX_MAX_SOTARGETS, paResource, paOffset);
+
+    pDXContext->pBackendDXContext->cSOTarget = cSOTarget;
 
     return VINF_SUCCESS;
@@ -5785 +6000 @@
 static int dxDefineShader(PVMSVGA3DDXCONTEXT pDXContext, SVGA3dShaderId shaderId, SVGACOTableDXShaderEntry const *pEntry)
 {
+    /** @todo A common approach for creation of COTable backend objects: runtime, empty DX COTable, live DX COTable. */
     DXSHADER *pDXShader = &pDXContext->pBackendDXContext->paShader[shaderId];
-    pDXShader->enmShaderType = pEntry->type;
+    if (pDXShader->enmShaderType == SVGA3D_SHADERTYPE_INVALID)
+    {
+        /* Init the shader structure. */
+        pDXShader->enmShaderType = pEntry->type;
+        pDXShader->soid = SVGA_ID_INVALID;
+    }
 
     PVMSVGA3DSHADER pShader = &pDXContext->paShader[shaderId];
@@ -5802 +6023 @@
     pDXShader->pvDXBC = NULL;
     pDXShader->cbDXBC = 0;
+    pDXShader->soid = SVGA_ID_INVALID;
     return VINF_SUCCESS;
 }
@@ -5891 +6113 @@
 #endif
 
-            HRESULT hr = dxShaderCreate(pDevice, pShader, pDXShader);
+            HRESULT hr = dxShaderCreate(pDXContext, pShader, pDXShader);
             if (SUCCEEDED(hr))
             {
@@ -5930 +6152 @@
 
 
-static DECLCALLBACK(int) vmsvga3dBackDXSetStreamOutput(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext)
-{
-    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
-
-    RT_NOREF(pBackend, pDXContext);
-    AssertFailed(); /** @todo Implement */
-    return VERR_NOT_IMPLEMENTED;
+static DECLCALLBACK(int) vmsvga3dBackDXSetStreamOutput(PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid)
+{
+    PVMSVGA3DBACKEND pBackend = pThisCC->svga.p3dState->pBackend;
+    RT_NOREF(pBackend, pDXContext, soid);
+
+    return VINF_SUCCESS;
 }
 

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

@@ -454 +454 @@
     DECLCALLBACKMEMBER(int, pfnDXDefineStreamOutput,        (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid, SVGACOTableDXStreamOutputEntry const *pEntry));
     DECLCALLBACKMEMBER(int, pfnDXDestroyStreamOutput,       (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid));
-    DECLCALLBACKMEMBER(int, pfnDXSetStreamOutput,           (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
+    DECLCALLBACKMEMBER(int, pfnDXSetStreamOutput,           (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGA3dStreamOutputId soid));
     DECLCALLBACKMEMBER(int, pfnDXSetCOTable,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext, SVGACOTableType type, uint32_t cValidEntries));
     DECLCALLBACKMEMBER(int, pfnDXBufferCopy,                (PVGASTATECC pThisCC, PVMSVGA3DDXCONTEXT pDXContext));
@@ -583 +583 @@
 int vmsvga3dDXDefineStreamOutput(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDefineStreamOutput const *pCmd);
 int vmsvga3dDXDestroyStreamOutput(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXDestroyStreamOutput const *pCmd);
-int vmsvga3dDXSetStreamOutput(PVGASTATECC pThisCC, uint32_t idDXContext);
+int vmsvga3dDXSetStreamOutput(PVGASTATECC pThisCC, uint32_t idDXContext, SVGA3dCmdDXSetStreamOutput const *pCmd);
 int vmsvga3dDXSetCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXSetCOTable const *pCmd, PVMSVGAMOB pMob);
 int vmsvga3dDXReadbackCOTable(PVGASTATECC pThisCC, SVGA3dCmdDXReadbackCOTable const *pCmd);