Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/VBoxVideoTools.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/VBoxVideoTools.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/VBoxVideoTools.h	(revision 43334)
@@ -229,4 +229,93 @@
 }
 
+typedef struct VBOXPOINT3D
+{
+    UINT x;
+    UINT y;
+    UINT z;
+} VBOXPOINT3D, *PVBOXPOINT3D;
+
+typedef struct VBOXBOX3D
+{
+    UINT Left;
+    UINT Top;
+    UINT Right;
+    UINT Bottom;
+    UINT Front;
+    UINT Back;
+} VBOXBOX3D, *PVBOXBOX3D;
+
+DECLINLINE(void) vboxWddmBoxTranslate(VBOXBOX3D * pBox, int x, int y, int z)
+{
+    pBox->Left   += x;
+    pBox->Top    += y;
+    pBox->Right  += x;
+    pBox->Bottom += y;
+    pBox->Front  += z;
+    pBox->Back   += z;
+}
+
+DECLINLINE(void) vboxWddmBoxMove(VBOXBOX3D * pBox, int x, int y, int z)
+{
+    LONG w = pBox->Right - pBox->Left;
+    LONG h = pBox->Bottom - pBox->Top;
+    LONG d = pBox->Back - pBox->Front;
+    pBox->Left   = x;
+    pBox->Top    = y;
+    pBox->Right  = w + x;
+    pBox->Bottom = h + y;
+    pBox->Front  = z;
+    pBox->Back   = d + z;
+}
+
+#define VBOXWDDM_BOXDIV_U(_v, _d, _nz) do { \
+        UINT tmp = (_v) / (_d); \
+        if (!tmp && (_v) && (_nz)) \
+            (_v) = 1; \
+        else \
+            (_v) = tmp; \
+    } while (0)
+
+DECLINLINE(void) vboxWddmBoxDivide(VBOXBOX3D * pBox, int div, bool fDontReachZero)
+{
+    VBOXWDDM_BOXDIV_U(pBox->Left, div, fDontReachZero);
+    VBOXWDDM_BOXDIV_U(pBox->Top, div, fDontReachZero);
+    VBOXWDDM_BOXDIV_U(pBox->Right, div, fDontReachZero);
+    VBOXWDDM_BOXDIV_U(pBox->Bottom, div, fDontReachZero);
+    VBOXWDDM_BOXDIV_U(pBox->Front, div, fDontReachZero);
+    VBOXWDDM_BOXDIV_U(pBox->Back, div, fDontReachZero);
+}
+
+DECLINLINE(void) vboxWddmPoint3DDivide(VBOXPOINT3D * pPoint, int div, bool fDontReachZero)
+{
+    VBOXWDDM_BOXDIV_U(pPoint->x, div, fDontReachZero);
+    VBOXWDDM_BOXDIV_U(pPoint->y, div, fDontReachZero);
+    VBOXWDDM_BOXDIV_U(pPoint->y, div, fDontReachZero);
+}
+
+DECLINLINE(void) vboxWddmBoxTranslated(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int x, int y, int z)
+{
+    *pDst = *pBox;
+    vboxWddmBoxTranslate(pDst, x, y, z);
+}
+
+DECLINLINE(void) vboxWddmBoxMoved(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int x, int y, int z)
+{
+    *pDst = *pBox;
+    vboxWddmBoxMove(pDst, x, y, z);
+}
+
+DECLINLINE(void) vboxWddmBoxDivided(VBOXBOX3D * pDst, const VBOXBOX3D * pBox, int div, bool fDontReachZero)
+{
+    *pDst = *pBox;
+    vboxWddmBoxDivide(pDst, div, fDontReachZero);
+}
+
+DECLINLINE(void) vboxWddmPoint3DDivided(VBOXPOINT3D * pDst, const VBOXPOINT3D * pPoint, int div, bool fDontReachZero)
+{
+    *pDst = *pPoint;
+    vboxWddmPoint3DDivide(pDst, div, fDontReachZero);
+}
+
 /* the dirty rect info is valid */
 #define VBOXWDDM_DIRTYREGION_F_VALID      0x00000001
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/common/wddm/VBoxMPIf.h	(revision 43334)
@@ -537,4 +537,5 @@
         case D3DDDIFMT_L8:
             return 8;
+        case D3DDDIFMT_L16:
         case D3DDDIFMT_A8L8:
             return 16;
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxD3DIf.cpp	(revision 43334)
@@ -543,62 +543,96 @@
     else if (VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags))
     {
+        PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
+        IDirect3DBaseTexture9 *pD3DIfTex;
+        HANDLE hSharedHandle = pAllocation->hSharedHandle;
+        void **pavClientMem = NULL;
+        VBOXDISP_D3DIFTYPE enmD3DIfType = VBOXDISP_D3DIFTYPE_UNDEFINED;
+        hr = S_OK;
+        if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
+        {
+            pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations);
+            Assert(pavClientMem);
+            if (pavClientMem)
+            {
+                for (UINT i = 0; i < pRc->cAllocations; ++i)
+                {
+                    Assert(pRc->aAllocations[i].pvMem);
+                    pavClientMem[i] = pRc->aAllocations[i].pvMem;
+                }
+            }
+            else
+                hr = E_FAIL;
+        }
+
+#ifdef DEBUG
         if (!pRc->RcDesc.fFlags.CubeMap)
         {
-#ifdef DEBUG
-            {
-                PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
-                uint32_t tstW = pAlloc->SurfDesc.width;
-                uint32_t tstH = pAlloc->SurfDesc.height;
-                for (UINT i = 1; i < pRc->cAllocations; ++i)
-                {
-                    tstW /= 2;
-                    tstH /= 2;
-                    pAlloc = &pRc->aAllocations[i];
-                    Assert((pAlloc->SurfDesc.width == tstW) || (!tstW && (pAlloc->SurfDesc.width==1)));
-                    Assert((pAlloc->SurfDesc.height == tstH) || (!tstH && (pAlloc->SurfDesc.height==1)));
-                }
-            }
+            PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
+            uint32_t tstW = pAlloc->SurfDesc.width;
+            uint32_t tstH = pAlloc->SurfDesc.height;
+            for (UINT i = 1; i < pRc->cAllocations; ++i)
+            {
+                tstW /= 2;
+                tstH /= 2;
+                pAlloc = &pRc->aAllocations[i];
+                Assert((pAlloc->SurfDesc.width == tstW) || (!tstW && (pAlloc->SurfDesc.width==1)));
+                Assert((pAlloc->SurfDesc.height == tstH) || (!tstH && (pAlloc->SurfDesc.height==1)));
+            }
+        }
 #endif
-            PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
-            IDirect3DTexture9 *pD3DIfTex;
-            HANDLE hSharedHandle = pAllocation->hSharedHandle;
-            void **pavClientMem = NULL;
-            hr = S_OK;
-            if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
-            {
-                Assert(pAllocation->pvMem);
-                Assert(pAllocation->SurfDesc.pitch);
-                UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format);
-                Assert(minPitch);
-                if (minPitch)
-                {
-                    if (pAllocation->SurfDesc.pitch != minPitch)
-                    {
-                        Assert(pAllocation->SurfDesc.pitch > minPitch);
-                        pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.format);
-                    }
-                    Assert(pAllocation->D3DWidth >= pAllocation->SurfDesc.width);
+
+        if (SUCCEEDED(hr))
+        {
+            if (pRc->RcDesc.fFlags.CubeMap)
+            {
+                if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height)
+                     || (pRc->cAllocations%6!=0))
+                {
+                    WARN(("unexpected cubemap texture config: (%d ; %d), allocs: %d",
+                            pAllocation->SurfDesc.width, pAllocation->SurfDesc.height, pRc->cAllocations));
+                    hr = E_INVALIDARG;
                 }
                 else
                 {
-                    Assert(pAllocation->D3DWidth == pAllocation->SurfDesc.width);
-                }
-            }
-            if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
-            {
-                pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations);
-                Assert(pavClientMem);
-                if (pavClientMem)
-                {
-                    for (UINT i = 0; i < pRc->cAllocations; ++i)
-                    {
-                        Assert(pRc->aAllocations[i].pvMem);
-                        pavClientMem[i] = pRc->aAllocations[i].pvMem;
-                    }
-                }
-                else
-                    hr = E_FAIL;
-            }
-            if (hr == S_OK)
+                    hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If,
+                                                pAllocation->D3DWidth,
+                                                VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc),
+                                                vboxDDI2D3DUsage(pRc->RcDesc.fFlags),
+                                                vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
+                                                vboxDDI2D3DPool(pRc->RcDesc.enmPool),
+                                                (IDirect3DCubeTexture9**)&pD3DIfTex,
+#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
+                                                NULL,
+#else
+                                                pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL,
+#endif
+                                                pavClientMem);
+                        Assert(hr == S_OK);
+                        Assert(pD3DIfTex);
+                        enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE;
+                }
+            }
+            else if (pRc->RcDesc.fFlags.Volume)
+            {
+                hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateVolumeTexture((IDirect3DDevice9Ex *)pDevice9If,
+                                            pAllocation->D3DWidth,
+                                            pAllocation->SurfDesc.height,
+                                            pAllocation->SurfDesc.depth,
+                                            pRc->cAllocations,
+                                            vboxDDI2D3DUsage(pRc->RcDesc.fFlags),
+                                            vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
+                                            vboxDDI2D3DPool(pRc->RcDesc.enmPool),
+                                            (IDirect3DVolumeTexture9**)&pD3DIfTex,
+#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
+                                            NULL,
+#else
+                                            pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL,
+#endif
+                                            pavClientMem);
+                Assert(hr == S_OK);
+                Assert(pD3DIfTex);
+                enmD3DIfType = VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE;
+            }
+            else
             {
                 hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateTexture((IDirect3DDevice9Ex *)pDevice9If,
@@ -609,5 +643,5 @@
                                             vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
                                             vboxDDI2D3DPool(pRc->RcDesc.enmPool),
-                                            &pD3DIfTex,
+                                            (IDirect3DTexture9**)&pD3DIfTex,
 #ifdef VBOXWDDMDISP_DEBUG_NOSHARED
                                             NULL,
@@ -617,95 +651,29 @@
                                             pavClientMem);
                 Assert(hr == S_OK);
-                if (hr == S_OK)
-                {
-                    Assert(pD3DIfTex);
+                Assert(pD3DIfTex);
+                enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE;
+            }
+
+            if (SUCCEEDED(hr))
+            {
+                Assert(pD3DIfTex);
+                Assert(enmD3DIfType != VBOXDISP_D3DIFTYPE_UNDEFINED);
 #ifndef VBOXWDDMDISP_DEBUG_NOSHARED
-                    Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle));
+                Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle));
 #endif
-                    for (UINT i = 0; i < pRc->cAllocations; ++i)
-                    {
-                        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
-                        pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_TEXTURE;
-                        pAlloc->pD3DIf = pD3DIfTex;
-                        pAlloc->hSharedHandle = hSharedHandle;
-                        if (i > 0)
-                            pD3DIfTex->AddRef();
-                    }
-                }
-
-                if (pavClientMem)
-                    RTMemFree(pavClientMem);
-            }
-        }
-        else /*pRc->RcDesc.fFlags.CubeMap*/
-        {
-            PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
-            IDirect3DCubeTexture9 *pD3DIfCubeTex;
-            HANDLE hSharedHandle = pAllocation->hSharedHandle;
-            void **pavClientMem = NULL;
-
-            if ( (pAllocation->SurfDesc.width!=pAllocation->SurfDesc.height)
-                 || (pRc->cAllocations%6!=0))
-            {
-                Assert(0);
-                hr = E_INVALIDARG;
-            }
-            else
-            {
-                hr = S_OK;
-                if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
-                {
-                    pavClientMem = (void**)RTMemAlloc(sizeof (pavClientMem[0]) * pRc->cAllocations);
-                    Assert(pavClientMem);
-                    if (pavClientMem)
-                    {
-                        for (UINT i = 0; i < pRc->cAllocations; ++i)
-                        {
-                            pavClientMem[i] = pRc->aAllocations[i].pvMem;
-                        }
-                    }
-                    else
-                        hr = E_FAIL;
-                }
-
-                if (hr == S_OK)
-                {
-                    hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9CreateCubeTexture((IDirect3DDevice9Ex *)pDevice9If,
-                                            pAllocation->SurfDesc.width,
-                                            VBOXDISP_CUBEMAP_LEVELS_COUNT(pRc),
-                                            vboxDDI2D3DUsage(pRc->RcDesc.fFlags),
-                                            vboxDDI2D3DFormat(pRc->RcDesc.enmFormat),
-                                            vboxDDI2D3DPool(pRc->RcDesc.enmPool),
-                                            &pD3DIfCubeTex,
-#ifdef VBOXWDDMDISP_DEBUG_NOSHARED
-                                            NULL,
-#else
-                                            pRc->RcDesc.fFlags.SharedResource ? &hSharedHandle : NULL,
-#endif
-                                            pavClientMem);
-                    Assert(hr == S_OK);
-                    if (hr == S_OK)
-                    {
-                        Assert(pD3DIfCubeTex);
-#ifndef VBOXWDDMDISP_DEBUG_NOSHARED
-                        Assert(!!(pRc->RcDesc.fFlags.SharedResource) == !!(hSharedHandle));
-#endif
-
-                        for (UINT i = 0; i < pRc->cAllocations; ++i)
-                        {
-                            PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
-                            pAlloc->enmD3DIfType = VBOXDISP_D3DIFTYPE_CUBE_TEXTURE;
-                            pAlloc->pD3DIf = pD3DIfCubeTex;
-                            pAlloc->hSharedHandle = hSharedHandle;
-                            if (i > 0)
-                                pD3DIfCubeTex->AddRef();
-                        }
-                    }
-
-                    if (pavClientMem)
-                        RTMemFree(pavClientMem);
-                }
-            }
-        }
+                for (UINT i = 0; i < pRc->cAllocations; ++i)
+                {
+                    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
+                    pAlloc->enmD3DIfType = enmD3DIfType;
+                    pAlloc->pD3DIf = pD3DIfTex;
+                    pAlloc->hSharedHandle = hSharedHandle;
+                    if (i > 0)
+                        pD3DIfTex->AddRef();
+                }
+            }
+        }
+
+        if (pavClientMem)
+            RTMemFree(pavClientMem);
     }
     else if (pRc->RcDesc.fFlags.RenderTarget || pRc->RcDesc.fFlags.Primary)
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp	(revision 43334)
@@ -2209,4 +2209,11 @@
             VBOXVDBG_DUMP_SETTEXTURE(pRc);
         }
+        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
+        {
+            pD3DIfTex = (IDirect3DVolumeTexture9*)pRc->aAllocations[0].pD3DIf;
+
+            VBOXVDBG_BREAK_SHARED(pRc);
+            VBOXVDBG_DUMP_SETTEXTURE(pRc);
+        }
         else
         {
@@ -2701,15 +2708,47 @@
 }
 
+AssertCompile(sizeof (D3DDDIBOX) == sizeof (VBOXBOX3D));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(VBOXBOX3D, Left));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(VBOXBOX3D, Top));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(VBOXBOX3D, Right));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(VBOXBOX3D, Bottom));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(VBOXBOX3D, Front));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(VBOXBOX3D, Back));
+
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(VBOXBOX3D, Left));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(VBOXBOX3D, Top));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(VBOXBOX3D, Right));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(VBOXBOX3D, Bottom));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(VBOXBOX3D, Front));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(VBOXBOX3D, Back));
+
 static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
 {
     VBOXDISP_DDI_PROLOGUE_DEV(hDevice);
+    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
+    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
+    Assert(pDevice);
+    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
+    IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
+    PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
+    PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
+    /* requirements for D3DDevice9::UpdateTexture */
+    Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
+    Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
+    IDirect3DVolumeTexture9 * pSrcTex = (IDirect3DVolumeTexture9*)pSrcRc->aAllocations[0].pD3DIf;
+    IDirect3DVolumeTexture9 * pDstTex = (IDirect3DVolumeTexture9*)pDstRc->aAllocations[0].pD3DIf;
+    VBOXPOINT3D Point;
+    Point.x = pData->DstX;
+    Point.y = pData->DstY;
+    Point.z = pData->DstZ;
+
+    HRESULT hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9VolTexBlt((IDirect3DDevice9Ex*)pDevice9If, pSrcTex, pDstTex,
+                                        (VBOXBOX3D*)&pData->SrcBox, &Point);
+    if (FAILED(hr))
+        WARN(("pfnVBoxWineExD3DDev9VolTexBlt failed hr 0x%x", hr));
+    else
+        hr = S_OK;
     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
-    Assert(pDevice);
-    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
-    Assert(0);
-//    @todo: vboxWddmDalCheckAdd(pDevice);
-    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    return E_FAIL;
+    return hr;;
 }
 
@@ -2739,7 +2778,10 @@
     /* requirements for D3DDevice9::UpdateTexture */
     Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
-            || pDstRc->aAllocations[0].enmD3DIfType==VBOXDISP_D3DIFTYPE_CUBE_TEXTURE);
+            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
+            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
     Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
-            || pSrcRc->aAllocations[0].enmD3DIfType==VBOXDISP_D3DIFTYPE_CUBE_TEXTURE);
+            || pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
+            || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
+    Assert(pSrcRc->aAllocations[0].enmD3DIfType == pDstRc->aAllocations[0].enmD3DIfType);
     Assert(pSrcRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
     Assert(pDstRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
@@ -2769,4 +2811,7 @@
     else
     {
+        Assert(pDstRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
+        Assert(pSrcRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
+
         IDirect3DSurface9 *pSrcSurfIf = NULL;
         IDirect3DSurface9 *pDstSurfIf = NULL;
@@ -3040,4 +3085,19 @@
 }
 
+AssertCompile(sizeof (D3DDDIBOX) == sizeof (D3DBOX));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(D3DBOX, Left));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(D3DBOX, Top));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(D3DBOX, Right));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(D3DBOX, Bottom));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(D3DBOX, Front));
+AssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(D3DBOX, Back));
+
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(D3DBOX, Left));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(D3DBOX, Top));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(D3DBOX, Right));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(D3DBOX, Bottom));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(D3DBOX, Front));
+AssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(D3DBOX, Back));
+
 static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
 {
@@ -3070,5 +3130,5 @@
             Assert(pTexAlloc->pD3DIf);
             RECT *pRect = NULL;
-            bool bNeedResynch = false;
+            BOOL fNeedLock = TRUE;
             Assert(!pData->Flags.RangeValid);
             Assert(!pData->Flags.BoxValid);
@@ -3080,7 +3140,58 @@
             /* else - we lock the entire texture, pRect == NULL */
 
-            if (!pLockAlloc->LockInfo.cLocks)
+            if (pLockAlloc->LockInfo.cLocks)
+            {
+                Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
+                if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
+                {
+                    Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
+                    Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
+                    Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
+                    Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
+                }
+                Assert(pLockAlloc->LockInfo.LockedRect.pBits);
+                Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
+
+                if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
+                {
+                    switch (pTexAlloc->enmD3DIfType)
+                    {
+                        case VBOXDISP_D3DIFTYPE_TEXTURE:
+                            hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
+                            break;
+                        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
+                            hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
+                                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
+                            break;
+                        case VBOXDISP_D3DIFTYPE_SURFACE:
+                            hr = pD3DIfSurface->UnlockRect();
+                            break;
+                        default:
+                            Assert(0);
+                            break;
+                    }
+                    Assert(hr == S_OK);
+                }
+                else
+                {
+                    fNeedLock = FALSE;
+                }
+            }
+
+            if (fNeedLock && SUCCEEDED(hr))
             {
                 VBOXVDBG_CHECK_SMSYNC(pRc);
+
+                pLockAlloc->LockInfo.fFlags = pData->Flags;
+                if (pRect)
+                {
+                    pLockAlloc->LockInfo.Area = *pRect;
+                    Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
+                }
+                else
+                {
+                    Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
+                }
+
                 switch (pTexAlloc->enmD3DIfType)
                 {
@@ -3107,89 +3218,12 @@
                         break;
                 }
-                Assert(hr == S_OK);
-                if (hr == S_OK)
-                {
-                    pLockAlloc->LockInfo.fFlags = pData->Flags;
-                    if (pRect)
-                    {
-                        pLockAlloc->LockInfo.Area = *pRect;
-                        Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 1);
-                    }
-                    else
-                    {
-                        Assert(pLockAlloc->LockInfo.fFlags.AreaValid == 0);
-                    }
-
-                    bNeedResynch = !pData->Flags.Discard;
-                }
-            }
-            else
-            {
-                Assert(pLockAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
-                if (pLockAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
-                {
-                    Assert(pLockAlloc->LockInfo.Area.left == pData->Area.left);
-                    Assert(pLockAlloc->LockInfo.Area.top == pData->Area.top);
-                    Assert(pLockAlloc->LockInfo.Area.right == pData->Area.right);
-                    Assert(pLockAlloc->LockInfo.Area.bottom == pData->Area.bottom);
-                }
-                Assert(pLockAlloc->LockInfo.LockedRect.pBits);
-
-                bNeedResynch = pLockAlloc->LockInfo.fFlags.Discard && !pData->Flags.Discard;
-
-                Assert(!bNeedResynch);
-
-                if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
-                {
-                    switch (pTexAlloc->enmD3DIfType)
-                    {
-                        case VBOXDISP_D3DIFTYPE_TEXTURE:
-                            hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
-                            break;
-                        case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
-                            hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
-                                    VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
-                            break;
-                        case VBOXDISP_D3DIFTYPE_SURFACE:
-                            hr = pD3DIfSurface->UnlockRect();
-                            break;
-                        default:
-                            Assert(0);
-                            break;
-                    }
-                    Assert(hr == S_OK);
-                    if (hr == S_OK)
-                    {
-                        switch (pTexAlloc->enmD3DIfType)
-                        {
-                            case VBOXDISP_D3DIFTYPE_TEXTURE:
-                                hr = pD3DIfTex->LockRect(pData->SubResourceIndex,
-                                        &pLockAlloc->LockInfo.LockedRect,
-                                        pRect,
-                                        vboxDDI2D3DLockFlags(pData->Flags));
-                                break;
-                            case VBOXDISP_D3DIFTYPE_CUBE_TEXTURE:
-                                hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
-                                        VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex),
-                                        &pLockAlloc->LockInfo.LockedRect,
-                                        pRect,
-                                        vboxDDI2D3DLockFlags(pData->Flags));
-                                break;
-                            case VBOXDISP_D3DIFTYPE_SURFACE:
-                                hr = pD3DIfSurface->LockRect(&pLockAlloc->LockInfo.LockedRect,
-                                        pRect,
-                                        vboxDDI2D3DLockFlags(pData->Flags));
-                                break;
-                            default:
-                                Assert(0);
-                                break;
-                        }
-                        Assert(hr == S_OK);
-                        pLockAlloc->LockInfo.fFlags.ReadOnly = 0;
-                    }
-                }
-            }
-
-            if (hr == S_OK)
+
+                if (FAILED(hr))
+                {
+                    WARN(("LockRect failed, hr", hr));
+                }
+            }
+
+            if (SUCCEEDED(hr))
             {
                 ++pLockAlloc->LockInfo.cLocks;
@@ -3210,4 +3244,97 @@
 
                 VBOXVDBG_DUMP_LOCK_ST(pData);
+
+                hr = S_OK;
+            }
+        }
+        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
+        {
+            PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
+            Assert(pData->SubResourceIndex < pRc->cAllocations);
+            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
+            IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
+            Assert(pTexAlloc->pD3DIf);
+            D3DDDIBOX *pBox = NULL;
+            BOOL fNeedLock = TRUE;
+            Assert(!pData->Flags.AreaValid);
+            Assert(!pData->Flags.BoxValid);
+            if (pData->Flags.BoxValid)
+            {
+                pBox = &pData->Box;
+            }
+
+            /* else - we lock the entire texture, pBox == NULL */
+
+            if (pLockAlloc->LockInfo.cLocks)
+            {
+                Assert(pLockAlloc->LockInfo.fFlags.BoxValid == pData->Flags.BoxValid);
+                if (pLockAlloc->LockInfo.fFlags.BoxValid && pData->Flags.BoxValid)
+                {
+                    Assert(pLockAlloc->LockInfo.Box.Left == pData->Box.Left);
+                    Assert(pLockAlloc->LockInfo.Box.Top == pData->Box.Top);
+                    Assert(pLockAlloc->LockInfo.Box.Right == pData->Box.Right);
+                    Assert(pLockAlloc->LockInfo.Box.Bottom == pData->Box.Bottom);
+                    Assert(pLockAlloc->LockInfo.Box.Front == pData->Box.Front);
+                    Assert(pLockAlloc->LockInfo.Box.Back == pData->Box.Back);
+                }
+                Assert(pLockAlloc->LockInfo.LockedBox.pBits);
+                Assert((pLockAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
+
+                if (pLockAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
+                {
+                    hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
+                    Assert(hr == S_OK);
+                }
+                else
+                {
+                    fNeedLock = FALSE;
+                }
+            }
+
+            if (fNeedLock && SUCCEEDED(hr))
+            {
+                VBOXVDBG_CHECK_SMSYNC(pRc);
+
+                pLockAlloc->LockInfo.fFlags = pData->Flags;
+                if (pBox)
+                {
+                    pLockAlloc->LockInfo.Box = *pBox;
+                    Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 1);
+                }
+                else
+                {
+                    Assert(pLockAlloc->LockInfo.fFlags.BoxValid == 0);
+                }
+
+                hr = pD3DIfTex->LockBox(pData->SubResourceIndex,
+                                &pLockAlloc->LockInfo.LockedBox,
+                                (D3DBOX*)pBox,
+                                vboxDDI2D3DLockFlags(pData->Flags));
+                if (FAILED(hr))
+                {
+                    WARN(("LockRect failed, hr", hr));
+                }
+            }
+
+            if (SUCCEEDED(hr))
+            {
+                ++pLockAlloc->LockInfo.cLocks;
+
+                if (!pData->Flags.NotifyOnly)
+                {
+                    pData->pSurfData = pLockAlloc->LockInfo.LockedBox.pBits;
+                    pData->Pitch = pLockAlloc->LockInfo.LockedBox.RowPitch;
+                    pData->SlicePitch = pLockAlloc->LockInfo.LockedBox.SlicePitch;
+                    Assert(!pLockAlloc->pvMem);
+                }
+                else
+                {
+                    Assert(pLockAlloc->pvMem);
+                    Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
+                }
+
+                VBOXVDBG_DUMP_LOCK_ST(pData);
+
+                hr = S_OK;
             }
         }
@@ -3546,10 +3673,27 @@
                         break;
                 }
-                Assert(hr == S_OK);
+                if (FAILED(hr))
+                    WARN(("UnlockRect failed, hr 0x%x", hr));
                 VBOXVDBG_CHECK_SMSYNC(pRc);
             }
-            else
-            {
-                Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
+        }
+        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
+        {
+            Assert(pData->SubResourceIndex < pRc->cAllocations);
+            PVBOXWDDMDISP_ALLOCATION pLockAlloc = &pRc->aAllocations[pData->SubResourceIndex];
+
+            VBOXVDBG_DUMP_UNLOCK_ST(pData);
+
+            --pLockAlloc->LockInfo.cLocks;
+            Assert(pLockAlloc->LockInfo.cLocks < UINT32_MAX);
+            if (!pLockAlloc->LockInfo.cLocks)
+            {
+                PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
+                Assert(pTexAlloc->pD3DIf);
+                IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
+                hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
+                if (FAILED(hr))
+                    WARN(("UnlockBox failed, hr 0x%x", hr));
+                VBOXVDBG_CHECK_SMSYNC(pRc);
             }
         }
@@ -3858,4 +4002,27 @@
 
         pAllocation->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
+
+        if (pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM)
+        {
+            Assert(pAllocation->pvMem);
+            Assert(pAllocation->SurfDesc.pitch);
+            UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format);
+            Assert(minPitch);
+            if (minPitch)
+            {
+                if (pAllocation->SurfDesc.pitch != minPitch)
+                {
+                    Assert(pAllocation->SurfDesc.pitch > minPitch);
+                    pAllocation->D3DWidth = vboxWddmCalcWidthForPitch(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.format);
+                    Assert(VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags) && !pRc->RcDesc.fFlags.CubeMap); /* <- tested for textures only! */
+                }
+                Assert(pAllocation->D3DWidth >= pAllocation->SurfDesc.width);
+            }
+            else
+            {
+                Assert(pAllocation->D3DWidth == pAllocation->SurfDesc.width);
+            }
+        }
+
     }
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.h	(revision 43334)
@@ -234,5 +234,8 @@
     };
     D3DDDI_LOCKFLAGS fFlags;
-    D3DLOCKED_RECT LockedRect;
+    union {
+        D3DLOCKED_RECT LockedRect;
+        D3DLOCKED_BOX LockedBox;
+    };
 #ifdef VBOXWDDMDISP_DEBUG
     PVOID pvData;
@@ -246,4 +249,5 @@
     VBOXDISP_D3DIFTYPE_TEXTURE,
     VBOXDISP_D3DIFTYPE_CUBE_TEXTURE,
+    VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE,
     VBOXDISP_D3DIFTYPE_VERTEXBUFFER,
     VBOXDISP_D3DIFTYPE_INDEXBUFFER
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.cpp	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.cpp	(revision 43334)
@@ -66,8 +66,29 @@
         }
 
+        pD3D->pfnVBoxWineExD3DDev9CreateVolumeTexture = (PFNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9CreateVolumeTexture");
+        if (!pD3D->pfnVBoxWineExD3DDev9CreateVolumeTexture)
+        {
+            WARN(("no VBoxWineExD3DDev9CreateVolumeTexture"));
+            break;
+        }
+
         pD3D->pfnVBoxWineExD3DDev9Flush = (PFNVBOXWINEEXD3DDEV9_FLUSH)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9Flush");
         if (!pD3D->pfnVBoxWineExD3DDev9Flush)
         {
             WARN(("no VBoxWineExD3DDev9Flush"));
+            break;
+        }
+
+        pD3D->pfnVBoxWineExD3DDev9VolBlt = (PFNVBOXWINEEXD3DDEV9_VOLBLT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9VolBlt");
+        if (!pD3D->pfnVBoxWineExD3DDev9VolBlt)
+        {
+            WARN(("no VBoxWineExD3DDev9VolBlt"));
+            break;
+        }
+
+        pD3D->pfnVBoxWineExD3DDev9VolTexBlt = (PFNVBOXWINEEXD3DDEV9_VOLTEXBLT)GetProcAddress(pD3D->hD3DLib, "VBoxWineExD3DDev9VolTexBlt");
+        if (!pD3D->pfnVBoxWineExD3DDev9VolTexBlt)
+        {
+            WARN(("no VBoxWineExD3DDev9VolTexBlt"));
             break;
         }
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3DIf.h	(revision 43334)
@@ -59,5 +59,11 @@
     PFNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE pfnVBoxWineExD3DDev9CreateCubeTexture;
 
+    PFNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE pfnVBoxWineExD3DDev9CreateVolumeTexture;
+
     PFNVBOXWINEEXD3DDEV9_FLUSH pfnVBoxWineExD3DDev9Flush;
+
+    PFNVBOXWINEEXD3DDEV9_VOLBLT pfnVBoxWineExD3DDev9VolBlt;
+
+    PFNVBOXWINEEXD3DDEV9_VOLTEXBLT pfnVBoxWineExD3DDev9VolTexBlt;
 
     PFNVBOXWINEEXD3DDEV9_UPDATE pfnVBoxWineExD3DDev9Update;
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxScreen.cpp
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxScreen.cpp	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxScreen.cpp	(revision 43334)
@@ -17,4 +17,5 @@
  */
 
+#include "VBoxDispD3DCmn.h"
 #include "VBoxScreen.h"
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxUhgsmiKmt.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxUhgsmiKmt.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxUhgsmiKmt.h	(revision 43334)
@@ -20,5 +20,4 @@
 #define ___VBoxUhgsmiKmt_h__
 
-#include "VBoxUhgsmiBase.h"
 #include "VBoxDispD3DCmn.h"
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9_private.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9_private.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9_private.h	(revision 43334)
@@ -265,5 +265,10 @@
 
 HRESULT volume_init(IDirect3DVolume9Impl *volume, IDirect3DDevice9Impl *device, UINT width, UINT height,
-        UINT depth, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool) DECLSPEC_HIDDEN;
+        UINT depth, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        ) DECLSPEC_HIDDEN;
 
 /* ------------------- */
@@ -473,5 +478,10 @@
 
 HRESULT volumetexture_init(IDirect3DVolumeTexture9Impl *texture, IDirect3DDevice9Impl *device,
-        UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool) DECLSPEC_HIDDEN;
+        UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void **pavClientMem
+#endif
+        ) DECLSPEC_HIDDEN;
 
 /* ----------------------- */
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9wddm.def
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9wddm.def	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/d3d9wddm.def	(revision 43334)
@@ -15,6 +15,9 @@
   VBoxWineExD3DDev9CreateTexture
   VBoxWineExD3DDev9CreateCubeTexture
+  VBoxWineExD3DDev9CreateVolumeTexture
   VBoxWineExD3DDev9Update
   VBoxWineExD3DDev9Term
   VBoxWineExD3DSwapchain9Present
+  VBoxWineExD3DDev9VolBlt
+  VBoxWineExD3DDev9VolTexBlt
   VBoxWineExD3DRc9SetShRcState
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/device.c
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/device.c	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/device.c	(revision 43334)
@@ -32,4 +32,9 @@
 #include "config.h"
 #include "d3d9_private.h"
+
+#ifdef VBOX_WITH_WDDM
+#include <iprt/assert.h>
+# include "../../common/VBoxVideoTools.h"
+#endif
 
 WINE_DEFAULT_DEBUG_CHANNEL(d3d9);
@@ -825,4 +830,93 @@
 }
 
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateVolumeTexture(IDirect3DDevice9Ex *iface,
+        UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format,
+        D3DPOOL pool, IDirect3DVolumeTexture9 **texture, HANDLE *shared_handle,
+        void **pavClientMem)
+{
+    IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+    IDirect3DVolumeTexture9Impl *object;
+    HRESULT hr;
+
+    TRACE("iface %p, width %u, height %u, depth %u, levels %u\n",
+            iface, width, height, depth, levels);
+    TRACE("usage %#x, format %#x, pool %#x, texture %p, shared_handle %p.\n",
+            usage, format, pool, texture, shared_handle);
+
+    object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
+    if (!object)
+    {
+        ERR("Failed to allocate volume texture memory.\n");
+        ERR_D3D();
+        return D3DERR_OUTOFVIDEOMEMORY;
+    }
+
+    hr = volumetexture_init(object, This, width, height, depth, levels, usage, format, pool, shared_handle, pavClientMem);
+    if (FAILED(hr))
+    {
+        ERR_D3D();
+        WARN("Failed to initialize volume texture, hr %#x.\n", hr);
+        HeapFree(GetProcessHeap(), 0, object);
+        return hr;
+    }
+
+    TRACE("Created volume texture %p.\n", object);
+    *texture = (IDirect3DVolumeTexture9 *)object;
+
+    return D3D_OK;
+}
+
+#ifdef VBOX_WITH_WDDM
+
+AssertCompile(sizeof (WINED3DBOX) == sizeof (VBOXBOX3D));
+AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Left) == RT_SIZEOFMEMB(VBOXBOX3D, Left));
+AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Top) == RT_SIZEOFMEMB(VBOXBOX3D, Top));
+AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Right) == RT_SIZEOFMEMB(VBOXBOX3D, Right));
+AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Bottom) == RT_SIZEOFMEMB(VBOXBOX3D, Bottom));
+AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Front) == RT_SIZEOFMEMB(VBOXBOX3D, Front));
+AssertCompile(RT_SIZEOFMEMB(WINED3DBOX, Back) == RT_SIZEOFMEMB(VBOXBOX3D, Back));
+
+AssertCompile(RT_OFFSETOF(WINED3DBOX, Left) == RT_OFFSETOF(VBOXBOX3D, Left));
+AssertCompile(RT_OFFSETOF(WINED3DBOX, Top) == RT_OFFSETOF(VBOXBOX3D, Top));
+AssertCompile(RT_OFFSETOF(WINED3DBOX, Right) == RT_OFFSETOF(VBOXBOX3D, Right));
+AssertCompile(RT_OFFSETOF(WINED3DBOX, Bottom) == RT_OFFSETOF(VBOXBOX3D, Bottom));
+AssertCompile(RT_OFFSETOF(WINED3DBOX, Front) == RT_OFFSETOF(VBOXBOX3D, Front));
+AssertCompile(RT_OFFSETOF(WINED3DBOX, Back) == RT_OFFSETOF(VBOXBOX3D, Back));
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolBlt(IDirect3DDevice9Ex *iface,
+                                                    IDirect3DVolume9 *pSourceVolume, IDirect3DVolume9 *pDestinationVolume,
+                                                    const VBOXBOX3D *pSrcBoxArg,
+                                                    const VBOXPOINT3D *pDstPoin3D)
+{
+    IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+    IDirect3DVolume9Impl *src = (IDirect3DVolume9Impl *)pSourceVolume;
+    IDirect3DVolume9Impl *dst = (IDirect3DVolume9Impl *)pDestinationVolume;
+    HRESULT hr;
+
+    wined3d_mutex_lock();
+    hr = IWineD3DDevice_VolBlt(This->WineD3DDevice, src->wineD3DVolume, dst->wineD3DVolume, (WINED3DBOX*)pSrcBoxArg, pDstPoin3D);
+    wined3d_mutex_unlock();
+
+    return hr;
+}
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolTexBlt(IDirect3DDevice9Ex *iface,
+                                                    IDirect3DVolumeTexture9 *pSourceTexture, IDirect3DVolumeTexture9 *pDestinationTexture,
+                                                    const VBOXBOX3D *pSrcBoxArg,
+                                                    const VBOXPOINT3D *pDstPoin3D)
+{
+    IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
+    IDirect3DVolumeTexture9Impl *src = (IDirect3DVolumeTexture9Impl *)pSourceTexture;
+    IDirect3DVolumeTexture9Impl *dst = (IDirect3DVolumeTexture9Impl *)pDestinationTexture;
+    HRESULT hr;
+
+    wined3d_mutex_lock();
+    hr = IWineD3DDevice_VolTexBlt(This->WineD3DDevice, src->wineD3DVolumeTexture, dst->wineD3DVolumeTexture, (WINED3DBOX*)pSrcBoxArg, pDstPoin3D);
+    wined3d_mutex_unlock();
+
+    return hr;
+}
+#endif
+
 VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Update(IDirect3DDevice9Ex *iface, D3DPRESENT_PARAMETERS * pParams, IDirect3DDevice9Ex **outIface)
 {
@@ -929,4 +1023,8 @@
         D3DPOOL pool, IDirect3DVolumeTexture9 **texture, HANDLE *shared_handle)
 {
+#ifdef VBOX_WITH_WDDM
+    return VBoxWineExD3DDev9CreateVolumeTexture(iface, width, height, depth, levels, usage, format,
+            pool, texture, shared_handle, NULL);
+#else
     IDirect3DDevice9Impl *This = (IDirect3DDevice9Impl *)iface;
     IDirect3DVolumeTexture9Impl *object;
@@ -959,4 +1057,5 @@
 
     return D3D_OK;
+#endif
 }
 
@@ -3066,5 +3165,10 @@
 static HRESULT STDMETHODCALLTYPE device_parent_CreateVolume(IWineD3DDeviceParent *iface,
         IUnknown *superior, UINT width, UINT height, UINT depth, WINED3DFORMAT format,
-        WINED3DPOOL pool, DWORD usage, IWineD3DVolume **volume)
+        WINED3DPOOL pool, DWORD usage, IWineD3DVolume **volume
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        )
 {
     struct IDirect3DDevice9Impl *This = device_from_device_parent(iface);
@@ -3084,5 +3188,9 @@
     }
 
-    hr = volume_init(object, This, width, height, depth, usage, format, pool);
+    hr = volume_init(object, This, width, height, depth, usage, format, pool
+#ifdef VBOX_WITH_WDDM
+        , shared_handle, pvClientMem
+#endif
+            );
     if (FAILED(hr))
     {
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/volume.c
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/volume.c	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/volume.c	(revision 43334)
@@ -277,5 +277,10 @@
 
 HRESULT volume_init(IDirect3DVolume9Impl *volume, IDirect3DDevice9Impl *device, UINT width, UINT height,
-        UINT depth, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool)
+        UINT depth, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        )
 {
     HRESULT hr;
@@ -284,6 +289,12 @@
     volume->ref = 1;
 
+#ifdef VBOX_WITH_WDDM
+    hr = IWineD3DDevice_CreateVolume(device->WineD3DDevice, width, height, depth, usage & WINED3DUSAGE_MASK,
+            format, pool, &volume->wineD3DVolume, (IUnknown *)volume, &d3d9_volume_wined3d_parent_ops,
+            shared_handle, pvClientMem);
+#else
     hr = IWineD3DDevice_CreateVolume(device->WineD3DDevice, width, height, depth, usage & WINED3DUSAGE_MASK,
             format, pool, &volume->wineD3DVolume, (IUnknown *)volume, &d3d9_volume_wined3d_parent_ops);
+#endif
     if (FAILED(hr))
     {
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/volumetexture.c
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/volumetexture.c	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/d3d9/volumetexture.c	(revision 43334)
@@ -434,5 +434,10 @@
 
 HRESULT volumetexture_init(IDirect3DVolumeTexture9Impl *texture, IDirect3DDevice9Impl *device,
-        UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool)
+        UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT format, D3DPOOL pool
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void **pavClientMem
+#endif
+        )
 {
     HRESULT hr;
@@ -442,7 +447,14 @@
 
     wined3d_mutex_lock();
+#ifdef VBOX_WITH_WDDM
+    hr = IWineD3DDevice_CreateVolumeTexture(device->WineD3DDevice, width, height, depth, levels,
+            usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool,
+            &texture->wineD3DVolumeTexture, (IUnknown *)texture, &d3d9_volumetexture_wined3d_parent_ops
+            , shared_handle, pavClientMem);
+#else
     hr = IWineD3DDevice_CreateVolumeTexture(device->WineD3DDevice, width, height, depth, levels,
             usage & WINED3DUSAGE_MASK, wined3dformat_from_d3dformat(format), pool,
             &texture->wineD3DVolumeTexture, (IUnknown *)texture, &d3d9_volumetexture_wined3d_parent_ops);
+#endif
     wined3d_mutex_unlock();
     if (FAILED(hr))
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/VBoxWineEx.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/VBoxWineEx.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/VBoxWineEx.h	(revision 43334)
@@ -25,4 +25,5 @@
 } VBOXWINEEX_SHRC_STATE;
 
+
 #ifndef IN_VBOXLIBWINE
 
@@ -46,4 +47,22 @@
             void **pavClientMem);
 typedef FNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE *PFNVBOXWINEEXD3DDEV9_CREATECUBETEXTURE;
+
+typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE(IDirect3DDevice9Ex *iface,
+            UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT Format, D3DPOOL Pool,
+            IDirect3DVolumeTexture9 **ppVolumeTexture, HANDLE *pSharedHandle,
+            void **pavClientMem);
+typedef FNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE *PFNVBOXWINEEXD3DDEV9_CREATEVOLUMETEXTURE;
+
+typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_VOLBLT(IDirect3DDevice9Ex *iface,
+                                                    IDirect3DVolume9 *pSourceVolume, IDirect3DVolume9 *pDestinationVolume,
+                                                    const struct VBOXBOX3D *pSrcBoxArg,
+                                                    const struct VBOXPOINT3D *pDstPoin3D);
+typedef FNVBOXWINEEXD3DDEV9_VOLBLT *PFNVBOXWINEEXD3DDEV9_VOLBLT;
+
+typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_VOLTEXBLT(IDirect3DDevice9Ex *iface,
+                                                    IDirect3DVolumeTexture9 *pSourceTexture, IDirect3DVolumeTexture9 *pDestinationTexture,
+                                                    const struct VBOXBOX3D *pSrcBoxArg,
+                                                    const struct VBOXPOINT3D *pDstPoin3D);
+typedef FNVBOXWINEEXD3DDEV9_VOLTEXBLT *PFNVBOXWINEEXD3DDEV9_VOLTEXBLT;
 
 typedef VBOXWINEEX_DECL(HRESULT) FNVBOXWINEEXD3DDEV9_FLUSH(IDirect3DDevice9Ex *iface);
@@ -78,4 +97,19 @@
                                  *    applicable ONLY for SYSMEM textures */
 
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9CreateVolumeTexture(IDirect3DDevice9Ex *iface,
+            UINT width, UINT height, UINT depth, UINT levels, DWORD usage, D3DFORMAT Format, D3DPOOL Pool,
+            IDirect3DVolumeTexture9 **ppVolumeTexture, HANDLE *pSharedHandle,
+            void **pavClientMem);
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolBlt(IDirect3DDevice9Ex *iface,
+                                                    IDirect3DVolume9 *pSourceVolume, IDirect3DVolume9 *pDestinationVolume,
+                                                    const struct VBOXBOX3D *pSrcBoxArg,
+                                                    const struct VBOXPOINT3D *pDstPoin3D);
+
+VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9VolTexBlt(IDirect3DDevice9Ex *iface,
+                                                    IDirect3DVolumeTexture9 *pSourceTexture, IDirect3DVolumeTexture9 *pDestinationTexture,
+                                                    const struct VBOXBOX3D *pSrcBoxArg,
+                                                    const struct VBOXPOINT3D *pDstPoin3D);
+
 VBOXWINEEX_DECL(HRESULT) VBoxWineExD3DDev9Flush(IDirect3DDevice9Ex *iface); /* perform glFlush */
 
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/wine/wined3d.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/wine/wined3d.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/vbox/libWineStub/include/wine/wined3d.h	(revision 43334)
@@ -2679,5 +2679,10 @@
         WINED3DPOOL pool,
         DWORD usage,
-        IWineD3DVolume **volume) = 0;
+        IWineD3DVolume **volume
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        ) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE CreateSwapChain(
@@ -2755,5 +2760,10 @@
         WINED3DPOOL pool,
         DWORD usage,
-        IWineD3DVolume **volume);
+        IWineD3DVolume **volume
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        );
 
     HRESULT (STDMETHODCALLTYPE *CreateSwapChain)(
@@ -2782,5 +2792,9 @@
 #define IWineD3DDeviceParent_CreateRenderTarget(This,superior,width,height,format,multisample_type,multisample_quality,lockable,surface) (This)->lpVtbl->CreateRenderTarget(This,superior,width,height,format,multisample_type,multisample_quality,lockable,surface)
 #define IWineD3DDeviceParent_CreateDepthStencilSurface(This,superior,width,height,format,multisample_type,multisample_quality,discard,surface) (This)->lpVtbl->CreateDepthStencilSurface(This,superior,width,height,format,multisample_type,multisample_quality,discard,surface)
+#ifdef VBOX_WITH_WDDM
+#define IWineD3DDeviceParent_CreateVolume(This,superior,width,height,depth,format,pool,usage,volume,shared_handle,pvClientMem) (This)->lpVtbl->CreateVolume(This,superior,width,height,depth,format,pool,usage,volume,shared_handle,pvClientMem)
+#else
 #define IWineD3DDeviceParent_CreateVolume(This,superior,width,height,depth,format,pool,usage,volume) (This)->lpVtbl->CreateVolume(This,superior,width,height,depth,format,pool,usage,volume)
+#endif
 #define IWineD3DDeviceParent_CreateSwapChain(This,present_parameters,swapchain) (This)->lpVtbl->CreateSwapChain(This,present_parameters,swapchain)
 #endif
@@ -6874,5 +6888,10 @@
         IWineD3DVolumeTexture **texture,
         IUnknown *parent,
-        const struct wined3d_parent_ops *parent_ops) = 0;
+        const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pavClientMem
+#endif
+        ) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE CreateVolume(
@@ -6885,5 +6904,10 @@
         IWineD3DVolume **volume,
         IUnknown *parent,
-        const struct wined3d_parent_ops *parent_ops) = 0;
+        const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        ) = 0;
 
     virtual HRESULT STDMETHODCALLTYPE CreateCubeTexture(
@@ -7417,4 +7441,16 @@
     virtual HRESULT STDMETHODCALLTYPE Flush(
         ) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE VolBlt(IWineD3DDevice *iface,
+            IWineD3DVolume *pSourceVolume, IWineD3DVolume *pDestinationVolume,
+            const WINED3DBOX *pSrcBoxArg,
+            const VBOXPOINT3D *pDstPoin3D
+            ) = 0;
+
+    virtual HRESULT STDMETHODCALLTYPE VolTexBlt(IWineD3DDevice *iface,
+            IWineD3DVolumeTexture *pSourceTexture, IWineD3DVolumeTexture *pDestinationTexture,
+            const WINED3DBOX *pSrcBoxArg,
+            const VBOXPOINT3D *pDstPoin3D
+            ) = 0;
 #endif
 };
@@ -7529,5 +7565,10 @@
         IWineD3DVolumeTexture **texture,
         IUnknown *parent,
-        const struct wined3d_parent_ops *parent_ops);
+        const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void **pavClientMem
+#endif
+        );
 
     HRESULT (STDMETHODCALLTYPE *CreateVolume)(
@@ -7541,5 +7582,10 @@
         IWineD3DVolume **volume,
         IUnknown *parent,
-        const struct wined3d_parent_ops *parent_ops);
+        const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        );
 
     HRESULT (STDMETHODCALLTYPE *CreateCubeTexture)(
@@ -8194,4 +8240,16 @@
     HRESULT (STDMETHODCALLTYPE *Flush)(
         IWineD3DDevice* This);
+
+    HRESULT (STDMETHODCALLTYPE *VolBlt)(IWineD3DDevice *iface,
+            IWineD3DVolume *pSourceVolume, IWineD3DVolume *pDestinationVolume,
+            const WINED3DBOX *pSrcBoxArg,
+            const struct VBOXPOINT3D *pDstPoin3D
+            );
+
+    HRESULT (STDMETHODCALLTYPE *VolTexBlt)(IWineD3DDevice *iface,
+            IWineD3DVolumeTexture *pSourceTexture, IWineD3DVolumeTexture *pDestinationTexture,
+            const WINED3DBOX *pSrcBoxArg,
+            const struct VBOXPOINT3D *pDstPoin3D
+            );
 #endif
 
@@ -8225,6 +8283,14 @@
 #define IWineD3DDevice_CreateTexture(This,width,height,levels,usage,format,pool,texture,parent,parent_ops) (This)->lpVtbl->CreateTexture(This,width,height,levels,usage,format,pool,texture,parent,parent_ops)
 #endif
+#ifdef VBOX_WITH_WDDM
+#define IWineD3DDevice_CreateVolumeTexture(This,width,height,depth,levels,usage,format,pool,texture,parent,parent_ops,shared_handle,pavClientMem) (This)->lpVtbl->CreateVolumeTexture(This,width,height,depth,levels,usage,format,pool,texture,parent,parent_ops,shared_handle,pavClientMem)
+#else
 #define IWineD3DDevice_CreateVolumeTexture(This,width,height,depth,levels,usage,format,pool,texture,parent,parent_ops) (This)->lpVtbl->CreateVolumeTexture(This,width,height,depth,levels,usage,format,pool,texture,parent,parent_ops)
+#endif
+#ifdef VBOX_WITH_WDDM
+#define IWineD3DDevice_CreateVolume(This,width,height,depth,usage,format,pool,volume,parent,parent_ops,shared_handle,pvClientMem) (This)->lpVtbl->CreateVolume(This,width,height,depth,usage,format,pool,volume,parent,parent_ops,shared_handle,pvClientMem)
+#else
 #define IWineD3DDevice_CreateVolume(This,width,height,depth,usage,format,pool,volume,parent,parent_ops) (This)->lpVtbl->CreateVolume(This,width,height,depth,usage,format,pool,volume,parent,parent_ops)
+#endif
 #ifdef VBOX_WITH_WDDM
 #define IWineD3DDevice_CreateCubeTexture(This,edge_length,levels,usage,format,pool,texture,parent,parent_ops,shared_handle,pavClientMem) (This)->lpVtbl->CreateCubeTexture(This,edge_length,levels,usage,format,pool,texture,parent,parent_ops,shared_handle,pavClientMem)
@@ -8359,4 +8425,6 @@
 #ifdef VBOX_WITH_WDDM
 #define IWineD3DDevice_Flush(This) (This)->lpVtbl->Flush(This)
+#define IWineD3DDevice_VolBlt(This, pSourceVolume, pDestinationVolume, pSrcBoxArg, pDstPoin3D) (This)->lpVtbl->VolBlt(This, pSourceVolume, pDestinationVolume, pSrcBoxArg, pDstPoin3D)
+#define IWineD3DDevice_VolTexBlt(This, pSourceTexture, pDestinationTexture, pSrcBoxArg, pDstPoin3D) (This)->lpVtbl->VolTexBlt(This, pSourceTexture, pDestinationTexture, pSrcBoxArg, pDstPoin3D)
 #endif
 #endif
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/device.c	(revision 43334)
@@ -42,4 +42,10 @@
 #endif
 #include "wined3d_private.h"
+#ifdef VBOX_WITH_WDDM
+/* a hacky way to treat WINED3DBOX as D3DBOX */
+# define D3DBOX WINED3DBOX
+# include "../../common/VBoxVideoTools.h"
+# undef D3DBOX
+#endif
 
 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
@@ -924,5 +930,10 @@
 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolumeTexture(IWineD3DDevice *iface,
         UINT Width, UINT Height, UINT Depth, UINT Levels, DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool,
-        IWineD3DVolumeTexture **ppVolumeTexture, IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
+        IWineD3DVolumeTexture **ppVolumeTexture, IUnknown *parent, const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void **pavClientMem
+#endif
+        )
 {
     IWineD3DDeviceImpl        *This = (IWineD3DDeviceImpl *)iface;
@@ -941,5 +952,10 @@
     }
 
-    hr = volumetexture_init(object, Width, Height, Depth, Levels, This, Usage, Format, Pool, parent, parent_ops);
+    hr = volumetexture_init(object, Width, Height, Depth, Levels, This, Usage, Format, Pool, parent, parent_ops
+#ifdef VBOX_WITH_WDDM
+        , shared_handle
+        , pavClientMem
+#endif
+            );
     if (FAILED(hr))
     {
@@ -958,5 +974,10 @@
 static HRESULT WINAPI IWineD3DDeviceImpl_CreateVolume(IWineD3DDevice *iface, UINT Width, UINT Height,
         UINT Depth, DWORD Usage, WINED3DFORMAT Format, WINED3DPOOL Pool, IWineD3DVolume **ppVolume,
-        IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
+        IUnknown *parent, const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        )
 {
     IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
@@ -975,5 +996,10 @@
     }
 
-    hr = volume_init(object, This, Width, Height, Depth, Usage, Format, Pool, parent, parent_ops);
+    hr = volume_init(object, This, Width, Height, Depth, Usage, Format, Pool, parent, parent_ops
+#ifdef VBOX_WITH_WDDM
+            , shared_handle
+            , pvClientMem
+#endif
+            );
     if (FAILED(hr))
     {
@@ -4938,4 +4964,157 @@
     return hr;
 }
+
+#ifdef VBOX_WITH_WDDM
+static HRESULT WINAPI IWineD3DDeviceImpl_VolBlt(IWineD3DDevice *iface,
+        IWineD3DVolume *pSourceVolume, IWineD3DVolume *pDestinationVolume,
+        const WINED3DBOX *pSrcBoxArg,
+        const VBOXPOINT3D *pDstPoin3D
+        )
+{
+    WINED3DLOCKED_BOX src;
+    WINED3DLOCKED_BOX dst;
+    HRESULT hr;
+    WINED3DBOX DstBox, SrcBox;
+    const WINED3DBOX *pDstBox;
+    const WINED3DBOX *pSrcBox;
+    int dstW, dstH, dstD, srcW, srcH, srcD;
+    int j, k;
+    uint8_t * pDstBits;
+    uint8_t * pSrcBits;
+
+
+    TRACE("iface %p, src_volume %p, dst_volume %p.\n",
+            iface, pSourceVolume, pDestinationVolume);
+
+    pSrcBox = pSrcBoxArg;
+    if (!pSrcBox)
+    {
+        IWineD3DVolumeImpl *pSrvVolImpl = (IWineD3DVolumeImpl*)pSourceVolume;
+        SrcBox.Left   = 0;
+        SrcBox.Top    = 0;
+        SrcBox.Front  = 0;
+        SrcBox.Right  = pSrvVolImpl->currentDesc.Width;
+        SrcBox.Bottom = pSrvVolImpl->currentDesc.Height;
+        SrcBox.Back   = pSrvVolImpl->currentDesc.Depth;
+        pSrcBox = &SrcBox;
+    }
+
+    if (!pDstPoin3D)
+        pDstBox = pSrcBox;
+    else
+    {
+        vboxWddmBoxTranslated(&DstBox, pSrcBox, pDstPoin3D->x, pDstPoin3D->y, pDstPoin3D->z);
+        pDstBox = &DstBox;
+    }
+
+    dstW = pDstBox->Right - pDstBox->Left;
+    dstH = pDstBox->Bottom - pDstBox->Top;
+    dstD = pDstBox->Back - pDstBox->Front;
+
+    srcW = pSrcBox->Right - pSrcBox->Left;
+    srcH = pSrcBox->Bottom - pSrcBox->Top;
+    srcD = pSrcBox->Back - pSrcBox->Front;
+
+    if (srcW != dstW || srcH != dstH || srcD != dstD)
+    {
+        ERR("dimensions do not match, stretching not supported for volumes!");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    /* TODO: Implement direct loading into the gl volume instead of using memcpy and
+     * dirtification to improve loading performance.
+     */
+    hr = IWineD3DVolume_LockBox(pSourceVolume, &src, pSrcBox, WINED3DLOCK_READONLY);
+    if(FAILED(hr)) return hr;
+    hr = IWineD3DVolume_LockBox(pDestinationVolume, &dst, pDstBox, WINED3DLOCK_DISCARD);
+    if(FAILED(hr)) {
+    IWineD3DVolume_UnlockBox(pSourceVolume);
+            return hr;
+    }
+
+    pDstBits = dst.pBits;
+    pSrcBits = src.pBits;
+    for (k = 0; k < srcD; ++k)
+    {
+        uint8_t * pRowDstBits = pDstBits;
+        uint8_t * pRowSrcBits = pSrcBits;
+
+        for (j = 0; j < srcH; ++j)
+        {
+            memcpy(pRowDstBits, pRowSrcBits, srcW * ((IWineD3DVolumeImpl *) pDestinationVolume)->resource.format_desc->byte_count);
+            pRowDstBits += dst.RowPitch;
+            pRowSrcBits += src.RowPitch;
+        }
+        pDstBits += dst.SlicePitch;
+        pSrcBits += src.SlicePitch;
+    }
+
+    hr = IWineD3DVolume_UnlockBox(pDestinationVolume);
+    if(FAILED(hr)) {
+        IWineD3DVolume_UnlockBox(pSourceVolume);
+    } else {
+        hr = IWineD3DVolume_UnlockBox(pSourceVolume);
+    }
+    return hr;
+}
+
+static HRESULT WINAPI IWineD3DDeviceImpl_VolTexBlt(IWineD3DDevice *iface,
+        IWineD3DVolumeTexture *pSourceTexture, IWineD3DVolumeTexture *pDestinationTexture,
+        const WINED3DBOX *pSrcBoxArg,
+        const VBOXPOINT3D *pDstPoin3D
+        )
+{
+    unsigned int level_count, i;
+    IWineD3DVolume *src_volume;
+    IWineD3DVolume *dst_volume;
+    HRESULT hr = S_OK;
+
+    level_count = IWineD3DBaseTexture_GetLevelCount(pSourceTexture);
+    if (IWineD3DBaseTexture_GetLevelCount(pDestinationTexture) != level_count)
+    {
+        ERR("Source and destination have different level counts, returning WINED3DERR_INVALIDCALL.\n");
+        return WINED3DERR_INVALIDCALL;
+    }
+
+    for (i = 0; i < level_count; ++i)
+    {
+        WINED3DBOX SrcBox, *pSrcBox;
+        VBOXPOINT3D DstPoint, *pDstPoint;
+
+        if (pSrcBoxArg)
+        {
+            vboxWddmBoxDivided(&SrcBox, pSrcBoxArg, i + 1, true);
+            pSrcBox = &SrcBox;
+        }
+        else
+        {
+            pSrcBox = NULL;
+        }
+
+        if (pDstPoin3D)
+        {
+            vboxWddmPoint3DDivided(&DstPoint, pDstPoin3D, i + 1, true);
+            pDstPoint = &DstPoint;
+        }
+        else
+        {
+            pDstPoint = NULL;
+        }
+
+        IWineD3DVolumeTexture_GetVolumeLevel(pSourceTexture, i, &src_volume);
+        IWineD3DVolumeTexture_GetVolumeLevel(pDestinationTexture, i, &dst_volume);
+        hr = IWineD3DDeviceImpl_VolBlt(iface, src_volume, dst_volume, pSrcBox, pDstPoint);
+        IWineD3DVolume_Release(dst_volume);
+        IWineD3DVolume_Release(src_volume);
+        if (FAILED(hr))
+        {
+            ERR("IWineD3DDeviceImpl_UpdateVolume failed, hr %#x.\n", hr);
+            return hr;
+        }
+    }
+
+    return hr;
+}
+#endif
 
 static HRESULT WINAPI IWineD3DDeviceImpl_UpdateTexture(IWineD3DDevice *iface,
@@ -7293,4 +7472,6 @@
     /* VBox WDDM extensions */
     IWineD3DDeviceImpl_Flush,
+    IWineD3DDeviceImpl_VolBlt,
+    IWineD3DDeviceImpl_VolTexBlt,
 #endif
 };
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/volume.c
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/volume.c	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/volume.c	(revision 43334)
@@ -251,4 +251,17 @@
         This->lockedBox.Back   = This->currentDesc.Depth;
     } else {
+#ifdef VBOX_WITH_WDDM
+        if (pBox->Right <= pBox->Left
+                || pBox->Right > This->currentDesc.Width
+                || pBox->Bottom <= pBox->Top
+                || pBox->Bottom > This->currentDesc.Height
+                || pBox->Back <= pBox->Front
+                || pBox->Back > This->currentDesc.Depth
+                )
+        {
+            ERR("invalid dimensions!");
+            return WINED3DERR_INVALIDCALL;
+        }
+#endif
         TRACE("Lock Box (%p) = l %d, t %d, r %d, b %d, fr %d, ba %d\n", pBox, pBox->Left, pBox->Top, pBox->Right, pBox->Bottom, pBox->Front, pBox->Back);
         pLockedVolume->pBits = This->resource.allocatedMemory
@@ -396,5 +409,10 @@
 HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT width,
         UINT height, UINT depth, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool,
-        IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
+        IUnknown *parent, const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        )
 {
     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
@@ -413,5 +431,5 @@
             width * height * depth * format_desc->byte_count, usage, format_desc, pool, parent, parent_ops
 #ifdef VBOX_WITH_WDDM
-            , NULL, NULL
+            , shared_handle, pvClientMem
 #endif
             );
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/volumetexture.c
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/volumetexture.c	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/volumetexture.c	(revision 43334)
@@ -365,5 +365,10 @@
 HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT height,
         UINT depth, UINT levels, IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format,
-        WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops)
+        WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void **pavClientMem
+#endif
+        )
 {
     const struct wined3d_gl_info *gl_info = &device->adapter->gl_info;
@@ -373,4 +378,11 @@
     HRESULT hr;
 
+#ifdef VBOX_WITH_WDDM
+    if (shared_handle)
+    {
+        ERR("shared handle support for volume textures not impemented yet, ignoring!");
+    }
+#endif
+
     /* TODO: It should only be possible to create textures for formats
      * that are reported as supported. */
@@ -415,5 +427,5 @@
             device, 0, usage, format_desc, pool, parent, parent_ops
 #ifdef VBOX_WITH_WDDM
-        , NULL, NULL
+        , shared_handle, pavClientMem
 #endif
             );
@@ -438,6 +450,12 @@
     {
         /* Create the volume. */
+#ifdef VBOX_WITH_WDDM
+        hr = IWineD3DDeviceParent_CreateVolume(device->device_parent, parent,
+                tmp_w, tmp_h, tmp_d, format, pool, usage, &texture->volumes[i]
+                , shared_handle, pavClientMem ? pavClientMem[i] : NULL);
+#else
         hr = IWineD3DDeviceParent_CreateVolume(device->device_parent, parent,
                 tmp_w, tmp_h, tmp_d, format, pool, usage, &texture->volumes[i]);
+#endif
         if (FAILED(hr))
         {
Index: /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_private.h
===================================================================
--- /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_private.h	(revision 43333)
+++ /trunk/src/VBox/Additions/WINNT/Graphics/Wine/wined3d/wined3d_private.h	(revision 43334)
@@ -2119,5 +2119,10 @@
 HRESULT volume_init(IWineD3DVolumeImpl *volume, IWineD3DDeviceImpl *device, UINT width,
         UINT height, UINT depth, DWORD usage, WINED3DFORMAT format, WINED3DPOOL pool,
-        IUnknown *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
+        IUnknown *parent, const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void *pvClientMem
+#endif
+        ) DECLSPEC_HIDDEN;
 
 /*****************************************************************************
@@ -2137,5 +2142,10 @@
 HRESULT volumetexture_init(IWineD3DVolumeTextureImpl *texture, UINT width, UINT height,
         UINT depth, UINT levels, IWineD3DDeviceImpl *device, DWORD usage, WINED3DFORMAT format,
-        WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops) DECLSPEC_HIDDEN;
+        WINED3DPOOL pool, IUnknown *parent, const struct wined3d_parent_ops *parent_ops
+#ifdef VBOX_WITH_WDDM
+        , HANDLE *shared_handle
+        , void **pavClientMem
+#endif
+        ) DECLSPEC_HIDDEN;
 
 typedef struct _WINED3DSURFACET_DESC