Changeset 30084 in vbox for trunk

Timestamp:

Jun 7, 2010 6:46:35 PM (15 years ago)

Author:

vboxsync

Message:

wddm/3d: texture resource creation

File:

• trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp (modified) (13 diffs)

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

@@ -619 +619 @@
         },
 };
+
+static D3DDDIQUERYTYPE gVBoxQueryTypes[] = {
+        D3DDDIQUERYTYPE_EVENT,
+        D3DDDIQUERYTYPE_OCCLUSION
+};
+
+#define VBOX_QUERYTYPE_COUNT() RT_ELEMENTS(gVBoxQueryTypes)
 
 #ifdef VBOX_WITH_VIDEOHWACCEL
@@ -992 +999 @@
         case D3DDDICAPS_DDRAW:
         {
-            Assert(pData->DataSize >= sizeof (DDRAW_CAPS));
+            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
+            Assert(pData->DataSize == sizeof (DDRAW_CAPS));
             if (pData->DataSize >= sizeof (DDRAW_CAPS))
             {
@@ -1013 +1021 @@
         case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
         {
-            Assert(pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS));
+            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
+            Assert(pData->DataSize == sizeof (DDRAW_MODE_SPECIFIC_CAPS));
             if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
             {
@@ -1062 +1071 @@
             break;
         case D3DDDICAPS_GETFORMATDATA:
-            Assert(pData->DataSize >= pAdapter->cFormstOps * sizeof (FORMATOP));
+            Assert(pData->DataSize == pAdapter->cFormstOps * sizeof (FORMATOP));
             memcpy(pData->pData, pAdapter->paFormstOps, pAdapter->cFormstOps * sizeof (FORMATOP));
             break;
         case D3DDDICAPS_GETD3DQUERYCOUNT:
-            *((uint32_t*)pData->pData) = 0;//VBOX_QUERYTYPE_COUNT();
+#if 0
+            *((uint32_t*)pData->pData) = VBOX_QUERYTYPE_COUNT();
+#else
+            *((uint32_t*)pData->pData) = 0;
+#endif
             break;
         case D3DDDICAPS_GETD3DQUERYDATA:
+#if 0
+            Assert(pData->DataSize == VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
+            memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
+#else
             AssertBreakpoint();
             memset(pData->pData, 0, pData->DataSize);
-//            Assert(pData->DataSize >= VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
-//            memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
+#endif
             break;
         case D3DDDICAPS_GETD3D3CAPS:
+            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
             Assert(pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA));
             if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
@@ -1146 +1163 @@
             break;
         case D3DDDICAPS_GETD3D7CAPS:
+            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
             Assert(pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS));
             if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
@@ -1158 +1176 @@
             if (pData->DataSize >= sizeof (D3DCAPS9))
             {
+                Assert(VBOXDISPMODE_IS_3D(pAdapter));
                 if (VBOXDISPMODE_IS_3D(pAdapter))
                 {
@@ -1569 +1588 @@
 {
     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    AssertBreakpoint();
     PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
@@ -1576 +1594 @@
         return E_INVALIDARG;
 
-    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
-    D3DDDICB_LOCK LockData;
-    LockData.hAllocation = pAlloc->hAllocation;
-    LockData.PrivateDriverData = 0;
-    LockData.NumPages = 0;
-    LockData.pPages = NULL;
-    LockData.pData = NULL; /* out */
-    LockData.Flags.Value = 0;
-    LockData.Flags.Discard = pData->Flags.Discard;
-    LockData.Flags.DonotWait = pData->Flags.DoNotWait;
-
-
-    HRESULT hr = pDevice->RtCallbacks.pfnLockCb(hDevice, &LockData);
-    Assert(hr == S_OK || (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
-    if (hr == S_OK)
+    HRESULT hr = S_OK;
+
+    if (VBOXDISPMODE_IS_3D(pDevice->pAdapter))
     {
-        uintptr_t offset;
-        if (pData->Flags.AreaValid)
+        if (pRc->RcDesc.fFlags.Texture)
         {
-            offset = pAlloc->SurfDesc.pitch * pData->Area.top +
-                    ((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3);
-        }
-        else if (pData->Flags.RangeValid)
-        {
-            offset = pData->Range.Offset;
-        }
-        else if (pData->Flags.BoxValid)
-        {
-            vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
-            AssertBreakpoint();
+            PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
         }
         else
@@ -1611 +1606 @@
             AssertBreakpoint();
         }
-
-        if (pData->Flags.Discard)
+    }
+    else
+    {
+        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
+        D3DDDICB_LOCK LockData;
+        LockData.hAllocation = pAlloc->hAllocation;
+        LockData.PrivateDriverData = 0;
+        LockData.NumPages = 0;
+        LockData.pPages = NULL;
+        LockData.pData = NULL; /* out */
+        LockData.Flags.Value = 0;
+        LockData.Flags.Discard = pData->Flags.Discard;
+        LockData.Flags.DonotWait = pData->Flags.DoNotWait;
+
+
+        hr = pDevice->RtCallbacks.pfnLockCb(hDevice, &LockData);
+        Assert(hr == S_OK || (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
+        if (hr == S_OK)
         {
-            /* check if the surface was renamed */
-            if (LockData.hAllocation)
-                pAlloc->hAllocation = LockData.hAllocation;
+            uintptr_t offset;
+            if (pData->Flags.AreaValid)
+            {
+                offset = pAlloc->SurfDesc.pitch * pData->Area.top +
+                        ((pAlloc->SurfDesc.bpp * pData->Area.left) >> 3);
+            }
+            else if (pData->Flags.RangeValid)
+            {
+                offset = pData->Range.Offset;
+            }
+            else if (pData->Flags.BoxValid)
+            {
+                vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
+                AssertBreakpoint();
+            }
+            else
+            {
+                AssertBreakpoint();
+            }
+
+            if (pData->Flags.Discard)
+            {
+                /* check if the surface was renamed */
+                if (LockData.hAllocation)
+                    pAlloc->hAllocation = LockData.hAllocation;
+            }
+
+            pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
+            pData->Pitch = pAlloc->SurfDesc.pitch;
+            pData->SlicePitch = pAlloc->SurfDesc.slicePitch;
         }
-
-        pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
-        pData->Pitch = pAlloc->SurfDesc.pitch;
-        pData->SlicePitch = pAlloc->SurfDesc.slicePitch;
     }
 
@@ -1766 +1800 @@
                     PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
                     CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
+                    Assert(!pSurf->pSysMem);
                     IDirect3DSurface9 *pD3D9Surf;
                     hr = pDevice->pDevice9If->CreateDepthStencilSurface(pSurf->Width,
@@ -1798 +1833 @@
                     PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
                     CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
+                    Assert(!pSurf->pSysMem);
                     IDirect3DVertexBuffer9  *pD3D9VBuf;
                     hr = pDevice->pDevice9If->CreateVertexBuffer(pSurf->Width,
@@ -1828 +1864 @@
                     PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
                     CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
+                    Assert(!pSurf->pSysMem);
                     IDirect3DIndexBuffer9  *pD3D9IBuf;
                     hr = pDevice->pDevice9If->CreateIndexBuffer(pSurf->Width,
@@ -1849 +1886 @@
                         }
                         break;
+                    }
+                }
+            }
+            else if (pResource->Flags.Texture)
+            {
+                Assert(pDevice->pDevice9If);
+#ifdef DEBUG
+                {
+                    uint32_t tstW = pResource->pSurfList[0].Width;
+                    uint32_t tstH = pResource->pSurfList[0].Height;
+                    for (UINT i = 1; i < pResource->SurfCount; ++i)
+                    {
+                        tstW /= 2;
+                        tstH /= 2;
+                        CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
+                        Assert(pSurf->Width == tstW);
+                        Assert(pSurf->Height == tstH);
+                    }
+                }
+#endif
+
+                PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[0];
+                CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[0];
+                IDirect3DTexture9 *pD3DIfTex;
+                hr = pDevice->pDevice9If->CreateTexture(pSurf->Width,
+                                            pSurf->Height,
+                                            pResource->SurfCount,
+                                            vboxDDI2D3DUsage(pResource->Flags),
+                                            vboxDDI2D3DFormat(pResource->Format),
+                                            vboxDDI2D3DPool(pResource->Pool),
+                                            &pD3DIfTex,
+                                            NULL /* HANDLE* pSharedHandle */
+                                            );
+                Assert(hr == S_OK);
+                if (hr == S_OK)
+                {
+                    Assert(pD3DIfTex);
+                    pAllocation->pD3DIf = pD3DIfTex;
+                    for (UINT i = 0; i < pResource->SurfCount; ++i)
+                    {
+                        D3DLOCKED_RECT lockInfo;
+                        CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
+                        hr = pD3DIfTex->LockRect(i, &lockInfo, NULL, D3DLOCK_DISCARD);
+                        Assert(hr == S_OK);
+                        if (hr == S_OK)
+                        {
+                            Assert(lockInfo.Pitch == pSurf->SysMemPitch);
+                            if (pSurf->SysMemPitch == lockInfo.Pitch)
+                            {
+                                memcpy(lockInfo.pBits, pSurf->pSysMem, pSurf->SysMemPitch * pSurf->Height);
+                            }
+                            else
+                            {
+                                uint8_t * pvSrc = (uint8_t *)pSurf->pSysMem;
+                                uint8_t * pvDst = (uint8_t *)lockInfo.pBits;
+                                uint32_t pitch = RT_MIN(pSurf->SysMemPitch, (UINT)lockInfo.Pitch);
+                                Assert(pitch);
+                                for (UINT j = 0; j < pSurf->Height; ++j)
+                                {
+                                    memcpy(pvDst, pvSrc, pitch);
+                                    pvSrc += pSurf->SysMemPitch;
+                                    pvDst += lockInfo.Pitch;
+                                }
+                            }
+                            pD3DIfTex->UnlockRect(i);
+                        }
+                        else
+                            pD3DIfTex->Release();
                     }
                 }