Changeset 30133 in vbox for trunk

Timestamp:

Jun 9, 2010 6:22:21 PM (15 years ago)

Author:

vboxsync

Message:

wddm/3d: more impl

Location:

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm

Files:

• VBoxDispD3D.cpp (modified) (3 diffs)
• VBoxDispD3D.h (modified) (2 diffs)
• VBoxDispD3DCmn.h (modified) (1 diff)

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

@@ -1479 +1479 @@
 static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
 {
-    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    AssertBreakpoint();
-    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    return E_FAIL;
+    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
+    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
+    Assert(pDevice);
+    Assert(pDevice->pDevice9If);
+    HRESULT hr = S_OK;
+//    IDirect3DVertexBuffer9 *pStreamData;
+//    UINT cbOffset;
+//    UINT cbStride;
+//    hr = pDevice->pDevice9If->GetStreamSource(pData->Stream, &pStreamData, &cbOffset, &cbStride);
+//    Assert(hr == S_OK);
+//    if (hr == S_OK)
+//    {
+//        if (pStreamData)
+//        {
+//            AssertBreakpoint();
+//            /* @todo: impl! */
+//        }
+//        else
+//        {
+            Assert(pData->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm));
+            PVBOXWDDMDISP_STREAMSOURCEUM pStrSrcUm = &pDevice->aStreamSourceUm[pData->Stream];
+            pStrSrcUm->pvBuffer = pUMBuffer;
+            pStrSrcUm->cbStride = pData->Stride;
+//        }
+//    }
+    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
+    return hr;
 }
 
@@ -1503 +1526 @@
 static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
 {
-    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    AssertBreakpoint();
-    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    return E_FAIL;
+    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
+    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
+    Assert(pDevice);
+    Assert(pDevice->pDevice9If);
+    Assert(!pFlagBuffer);
+    IDirect3DVertexDeclaration9* pDecl;
+    HRESULT hr = pDevice->pDevice9If->GetVertexDeclaration(&pDecl);
+    Assert(hr == S_OK);
+    if (hr == S_OK)
+    {
+        Assert(pDecl);
+        D3DVERTEXELEMENT9 aDecls9[MAXD3DDECLLENGTH];
+        UINT cDecls9 = 0;
+        hr = pDecl->GetDeclaration(aDecls9, &cDecls9);
+        Assert(hr == S_OK);
+        if (hr == S_OK)
+        {
+            Assert(cDecls9);
+            for (UINT i = 0; i < cDecls9 - 1 /* the last one is D3DDECL_END */; ++i)
+            {
+                D3DVERTEXELEMENT9 *pDecl9 = &aDecls9[i];
+                Assert(pDecl9->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm) || pDecl9->Stream == 0xff);
+                if (pDecl9->Stream != 0xff)
+                {
+                    PVBOXWDDMDISP_STREAMSOURCEUM pStrSrc = &pDevice->aStreamSourceUm[pDecl9->Stream];
+                    if (pStrSrc->pvBuffer)
+                    {
+                        WORD iStream = pDecl9->Stream;
+                        D3DVERTEXELEMENT9 *pLastCDecl9 = pDecl9;
+                        for (UINT j = i+1; j < cDecls9 - 1 /* the last one is D3DDECL_END */; ++j)
+                        {
+                            pDecl9 = &aDecls9[j];
+                            if (iStream == pDecl9->Stream)
+                            {
+                                pDecl9->Stream = 0xff; /* mark as done */
+                                Assert(pDecl9->Offset != pLastCDecl9->Offset);
+                                if (pDecl9->Offset > pLastCDecl9->Offset)
+                                    pLastCDecl9 = pDecl9;
+                            }
+                        }
+                        /* vertex size is MAX(all Offset's) + sizeof (data_type with MAX offset) + stride*/
+                        UINT cbVertex = pLastCDecl9->Offset + pStrSrc->cbStride;
+                        UINT cbType;
+                        switch (pLastCDecl9->Type)
+                        {
+                            case D3DDECLTYPE_FLOAT1:
+                                cbType = sizeof (float);
+                                break;
+                            case D3DDECLTYPE_FLOAT2:
+                                cbType = sizeof (float) * 2;
+                                break;
+                            case D3DDECLTYPE_FLOAT3:
+                                cbType = sizeof (float) * 3;
+                                break;
+                            case D3DDECLTYPE_FLOAT4:
+                                cbType = sizeof (float) * 4;
+                                break;
+                            case D3DDECLTYPE_D3DCOLOR:
+                                cbType = 4;
+                                break;
+                            case D3DDECLTYPE_UBYTE4:
+                                cbType = 4;
+                                break;
+                            case D3DDECLTYPE_SHORT2:
+                                cbType = sizeof (short) * 2;
+                                break;
+                            case D3DDECLTYPE_SHORT4:
+                                cbType = sizeof (short) * 4;
+                                break;
+                            case D3DDECLTYPE_UBYTE4N:
+                                cbType = 4;
+                                break;
+                            case D3DDECLTYPE_SHORT2N:
+                                cbType = sizeof (short) * 2;
+                                break;
+                            case D3DDECLTYPE_SHORT4N:
+                                cbType = sizeof (short) * 4;
+                                break;
+                            case D3DDECLTYPE_USHORT2N:
+                                cbType = sizeof (short) * 2;
+                                break;
+                            case D3DDECLTYPE_USHORT4N:
+                                cbType = sizeof (short) * 4;
+                                break;
+                            case D3DDECLTYPE_UDEC3:
+                                cbType = sizeof (signed) * 3;
+                                break;
+                            case D3DDECLTYPE_DEC3N:
+                                cbType = sizeof (unsigned) * 3;
+                                break;
+                            case D3DDECLTYPE_FLOAT16_2:
+                                cbType = 2 * 2;
+                                break;
+                            case D3DDECLTYPE_FLOAT16_4:
+                                cbType = 2 * 4;
+                                break;
+                            default:
+                                AssertBreakpoint();
+                                cbType = 1;
+                        }
+                        cbVertex += cbType;
+
+                        UINT cVertexes;
+                        switch (pData->PrimitiveType)
+                        {
+                            case D3DPT_POINTLIST:
+                                cVertexes = pData->PrimitiveCount;
+                                break;
+                            case D3DPT_LINELIST:
+                                cVertexes = pData->PrimitiveCount * 2;
+                                break;
+                            case D3DPT_LINESTRIP:
+                                cVertexes = pData->PrimitiveCount + 1;
+                                break;
+                            case D3DPT_TRIANGLELIST:
+                                cVertexes = pData->PrimitiveCount * 3;
+                                break;
+                            case D3DPT_TRIANGLESTRIP:
+                                cVertexes = pData->PrimitiveCount + 2;
+                                break;
+                            case D3DPT_TRIANGLEFAN:
+                                cVertexes = pData->PrimitiveCount + 2;
+                                break;
+                            default:
+                                AssertBreakpoint();
+                                cVertexes = pData->PrimitiveCount;
+                        }
+                        UINT cbVertexes = cVertexes * cbVertex;
+                        IDirect3DVertexBuffer9 *pCurVb = NULL, *pVb = NULL;
+                        UINT cbOffset;
+                        UINT cbStride;
+                        hr = pDevice->pDevice9If->GetStreamSource(iStream, &pCurVb, &cbOffset, &cbStride);
+                        Assert(hr == S_OK);
+                        if (hr == S_OK)
+                        {
+                            if (pCurVb)
+                            {
+                                if (cbStride == pStrSrc->cbStride)
+                                {
+                                    /* ensure our data feets in the buffer */
+                                    D3DVERTEXBUFFER_DESC Desc;
+                                    hr = pCurVb->GetDesc(&Desc);
+                                    Assert(hr == S_OK);
+                                    if (hr == S_OK)
+                                    {
+                                        if (Desc.Size >= cbVertexes)
+                                            pVb = pCurVb;
+                                    }
+                                }
+                            }
+                        }
+                        else
+                        {
+                            pCurVb = NULL;
+                        }
+
+                        if (!pVb)
+                        {
+                            hr = pDevice->pDevice9If->CreateVertexBuffer(cbVertexes,
+                                    0, /* DWORD Usage */
+                                    0, /* DWORD FVF */
+                                    D3DPOOL_DEFAULT, /* D3DPOOL Pool */
+                                    &pVb,
+                                    NULL /*HANDLE* pSharedHandle*/);
+                            Assert(hr == S_OK);
+                            if (hr == S_OK)
+                            {
+                                hr = pDevice->pDevice9If->SetStreamSource(iStream, pVb, 0, pStrSrc->cbStride);
+                                Assert(hr == S_OK);
+                                if (hr == S_OK)
+                                {
+                                    if (pCurVb)
+                                        pCurVb->Release();
+                                }
+                                else
+                                {
+                                    pVb->Release();
+                                    pVb = NULL;
+                                }
+                            }
+                        }
+
+                        if (pVb)
+                        {
+                            Assert(hr == S_OK);
+                            VOID *pvData;
+                            hr = pVb->Lock(0, /* UINT OffsetToLock */
+                                    cbVertexes,
+                                    &pvData,
+                                    D3DLOCK_DISCARD);
+                            Assert(hr == S_OK);
+                            if (hr == S_OK)
+                            {
+                                memcpy (pvData, ((uint8_t*)pStrSrc->pvBuffer) + pData->VStart * cbVertex, cbVertexes);
+                                HRESULT tmpHr = pVb->Unlock();
+                                Assert(tmpHr == S_OK);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (hr == S_OK)
+        {
+            hr = pDevice->pDevice9If->DrawPrimitive(pData->PrimitiveType,
+                    0 /* <- since we use our owne StreamSource buffer which has data at the very beginning*/,
+                    pData->PrimitiveCount);
+            Assert(hr == S_OK);
+        }
+    }
+    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
+    return hr;
 }
 
@@ -2555 +2786 @@
 static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
 {
-    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    AssertBreakpoint();
-    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    return E_FAIL;
+    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
+    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
+    Assert(pDevice);
+    Assert(pDevice->pDevice9If);
+    HRESULT hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
+            NULL, /* CONST RECT * pDestRect */
+            NULL, /* HWND hDestWindowOverride */
+            NULL /*CONST RGNDATA * pDirtyRegion */
+            );
+    Assert(hr == S_OK);
+    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
+    return hr;
 }
 static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
 {
-    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    AssertBreakpoint();
-    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
-    return E_FAIL;
+    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
+    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
+    Assert(pDevice);
+    Assert(pDevice->pDevice9If);
+    HRESULT hr = pDevice->pDevice9If->Present(NULL, /* CONST RECT * pSourceRect */
+            NULL, /* CONST RECT * pDestRect */
+            NULL, /* HWND hDestWindowOverride */
+            NULL /*CONST RGNDATA * pDirtyRegion */
+            );
+    Assert(hr == S_OK);
+    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
+    return hr;
 }
 

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

@@ -62 +62 @@
 } VBOXWDDMDISP_CONTEXT, *PVBOXWDDMDISP_CONTEXT;
 
+typedef struct VBOXWDDMDISP_STREAMSOURCEUM
+{
+    CONST VOID* pvBuffer;
+    UINT cbStride;
+} VBOXWDDMDISP_STREAMSOURCEUM, *PVBOXWDDMDISP_STREAMSOURCEUM;
+
 typedef struct VBOXWDDMDISP_DEVICE
 {
@@ -73 +79 @@
     D3DDDI_CREATEDEVICEFLAGS fFlags;
     HWND hWnd;
+    VBOXWDDMDISP_STREAMSOURCEUM aStreamSourceUm[16];
     IDirect3DDevice9 *pDevice9If;
     /* need to cache the ViewPort data because IDirect3DDevice9::SetViewport

trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3DCmn.h

@@ -39 +39 @@
 #endif
 
-#ifndef DEBUG_misha
+#if 0
 # ifdef Assert
 #  undef Assert