VirtualBox

Changeset 30554 in vbox


Ignore:
Timestamp:
Jul 1, 2010 1:40:11 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
63267
Message:

wddm/3d: more impl

Location:
trunk/src/VBox/Additions/WINNT/Graphics
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp

    r30505 r30554  
    15741574static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
    15751575{
    1576     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1577     AssertBreakpoint();
    1578     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1579     return E_FAIL;
     1576    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1577    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1578    Assert(pDevice);
     1579    Assert(pDevice->pDevice9If);
     1580    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hIndexBuffer;
     1581    PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
     1582    IDirect3DIndexBuffer9 *pIndexBuffer = NULL;
     1583    if (pRc)
     1584    {
     1585        Assert(pRc->cAllocations == 1);
     1586        pAlloc = &pRc->aAllocations[0];
     1587        Assert(pAlloc->pD3DIf);
     1588        pIndexBuffer = (IDirect3DIndexBuffer9*)pAlloc->pD3DIf;
     1589    }
     1590    HRESULT hr = pDevice->pDevice9If->SetIndices(pIndexBuffer);
     1591    Assert(hr == S_OK);
     1592    if (hr == S_OK)
     1593    {
     1594        pDevice->pIndicesAlloc = pAlloc;
     1595        pDevice->IndiciesInfo.uiStride = pData->Stride;
     1596    }
     1597    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1598    return hr;
    15801599}
    15811600
    15821601static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
    15831602{
    1584     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1585     AssertBreakpoint();
    1586     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    1587     return E_FAIL;
     1603    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1604    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1605    Assert(pDevice);
     1606    Assert(pDevice->pDevice9If);
     1607    HRESULT hr = S_OK;
     1608    pDevice->IndiciesUm.pvBuffer = pUMBuffer;
     1609    pDevice->IndiciesUm.cbSize = IndexSize;
     1610    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1611    return hr;
    15881612}
    15891613
     
    15991623    if (!pDevice->cStreamSources)
    16001624    {
    1601         Assert(pDevice->aStreamSourceUm[0].pvBuffer);
     1625        if (pDevice->aStreamSourceUm[0].pvBuffer)
     1626        {
    16021627#ifdef DEBUG
    1603         for (UINT i = 1; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
    1604         {
    1605             Assert(!pDevice->aStreamSourceUm[i].pvBuffer);
    1606         }
     1628            for (UINT i = 1; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
     1629            {
     1630                Assert(!pDevice->aStreamSourceUm[i].pvBuffer);
     1631            }
    16071632#endif
    1608         hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType,
    1609                                   pData->PrimitiveCount,
    1610                                   ((uint8_t*)pDevice->aStreamSourceUm[0].pvBuffer) + pData->VStart * pDevice->aStreamSourceUm[0].cbStride,
    1611                                   pDevice->aStreamSourceUm[0].cbStride);
    1612         Assert(hr == S_OK);
     1633            hr = pDevice->pDevice9If->DrawPrimitiveUP(pData->PrimitiveType,
     1634                                      pData->PrimitiveCount,
     1635                                      ((uint8_t*)pDevice->aStreamSourceUm[0].pvBuffer) + pData->VStart * pDevice->aStreamSourceUm[0].cbStride,
     1636                                      pDevice->aStreamSourceUm[0].cbStride);
     1637            Assert(hr == S_OK);
     1638        }
     1639        else
     1640        {
     1641            /* todo: impl */
     1642            AssertBreakpoint();
     1643        }
    16131644    }
    16141645    else
     
    26642695        if (VBOXDISPMODE_IS_3D(pAdapter))
    26652696        {
     2697            if (pResource->Flags.SharedResource)
     2698            {
     2699                AssertBreakpoint(); /* <-- need to test that */
     2700                bIssueCreateResource = true;
     2701            }
     2702
    26662703            if (pResource->Flags.RenderTarget)
    26672704            {
    26682705                HWND hWnd = NULL;
     2706                bool bDevCreated = false;
    26692707                Assert(pResource->SurfCount);
    2670                 Assert(!pDevice->pDevice9If);
    2671                 Assert(!pDevice->hWnd);
    2672                 bIssueCreateResource = true;
    2673                 hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
    2674                 Assert(hr == S_OK);
    2675                 if (hr == S_OK)
    2676                 {
    2677                     DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
    2678                     if (pDevice->fFlags.AllowMultithreading)
    2679                         fFlags |= D3DCREATE_MULTITHREADED;
    2680 
    2681                     IDirect3DDevice9 *pDevice9If = NULL;
    2682                     D3DPRESENT_PARAMETERS params;
    2683                     memset(&params, 0, sizeof (params));
    2684         //            params.BackBufferWidth = 0;
    2685         //            params.BackBufferHeight = 0;
    2686                     params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
    2687                     Assert(pResource->SurfCount);
    2688                     params.BackBufferCount = pResource->SurfCount - 1;
    2689                     params.MultiSampleType = vboxDDI2D3DMultiSampleType(pResource->MultisampleType);
    2690                     if (pResource->Flags.DiscardRenderTarget)
    2691                         params.SwapEffect = D3DSWAPEFFECT_DISCARD;
    2692                     params.hDeviceWindow = hWnd;
    2693                     /* @todo: it seems there should be a way to detect this correctly since
    2694                      * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
    2695                     params.Windowed = TRUE;
    2696         //            params.EnableAutoDepthStencil = FALSE;
    2697         //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
    2698         //            params.Flags;
    2699         //            params.FullScreen_RefreshRateInHz;
    2700         //            params.FullScreen_PresentationInterval;
    2701                     hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, &params, &pDevice9If);
     2708                if (!pDevice->pDevice9If)
     2709                {
     2710                    Assert(!pDevice->hWnd);
     2711                    hr = VBoxDispWndCreate(pAdapter, pResource->pSurfList[0].Width, pResource->pSurfList[0].Height, &hWnd);
    27022712                    Assert(hr == S_OK);
    27032713                    if (hr == S_OK)
    27042714                    {
    2705                         pDevice->pDevice9If = pDevice9If;
    2706                         pDevice->hWnd = hWnd;
    2707                         for (UINT i = 0; i < pResource->SurfCount; ++i)
     2715                        DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
     2716                        if (pDevice->fFlags.AllowMultithreading)
     2717                            fFlags |= D3DCREATE_MULTITHREADED;
     2718
     2719                        IDirect3DDevice9 *pDevice9If = NULL;
     2720                        D3DPRESENT_PARAMETERS params;
     2721                        memset(&params, 0, sizeof (params));
     2722            //            params.BackBufferWidth = 0;
     2723            //            params.BackBufferHeight = 0;
     2724                        params.BackBufferFormat = vboxDDI2D3DFormat(pResource->Format);
     2725                        Assert(pResource->SurfCount);
     2726                        params.BackBufferCount = pResource->SurfCount - 1;
     2727                        params.MultiSampleType = vboxDDI2D3DMultiSampleType(pResource->MultisampleType);
     2728                        if (pResource->Flags.DiscardRenderTarget)
     2729                            params.SwapEffect = D3DSWAPEFFECT_DISCARD;
     2730                        params.hDeviceWindow = hWnd;
     2731                        /* @todo: it seems there should be a way to detect this correctly since
     2732                         * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
     2733                        params.Windowed = TRUE;
     2734            //            params.EnableAutoDepthStencil = FALSE;
     2735            //            params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
     2736            //            params.Flags;
     2737            //            params.FullScreen_RefreshRateInHz;
     2738            //            params.FullScreen_PresentationInterval;
     2739                        hr = pAdapter->pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, fFlags, &params, &pDevice9If);
     2740                        Assert(hr == S_OK);
     2741                        if (hr == S_OK)
    27082742                        {
    2709                             PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
    2710 
    2711                             IDirect3DSurface9* pD3D9Surf;
    2712                             hr = pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
     2743                            pDevice->pDevice9If = pDevice9If;
     2744                            pDevice->hWnd = hWnd;
     2745                            bDevCreated = true;
     2746                        }
     2747                    }
     2748                }
     2749                else
     2750                {
     2751                    Assert(pDevice->hWnd);
     2752
     2753                }
     2754
     2755                if (hr == S_OK)
     2756                {
     2757                    Assert(pDevice->pDevice9If);
     2758                    bIssueCreateResource = true;
     2759                    for (UINT i = 0; i < pResource->SurfCount; ++i)
     2760                    {
     2761                        PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
     2762
     2763                        IDirect3DSurface9* pD3D9Surf;
     2764                        hr = pDevice->pDevice9If->CreateRenderTarget(pAllocation->SurfDesc.width,
    27132765                                    pAllocation->SurfDesc.height,
    27142766                                    vboxDDI2D3DFormat(pResource->Format),
     
    27192771                                    NULL /* HANDLE* pSharedHandle */
    27202772                                  );
    2721                             Assert(hr == S_OK);
    2722                             if (hr == S_OK)
     2773                        Assert(hr == S_OK);
     2774                        if (hr == S_OK)
     2775                        {
     2776                            Assert(pD3D9Surf);
     2777                            if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
    27232778                            {
    2724                                 Assert(pD3D9Surf);
    2725                                 if (pResource->Pool == D3DDDIPOOL_SYSTEMMEM)
     2779                                Assert(pAllocation->pvMem);
     2780                                D3DLOCKED_RECT lockInfo;
     2781                                hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
     2782                                Assert(hr == S_OK);
     2783                                if (hr == S_OK)
    27262784                                {
    2727                                     Assert(pAllocation->pvMem);
    2728                                     D3DLOCKED_RECT lockInfo;
    2729                                     hr = pD3D9Surf->LockRect(&lockInfo, NULL, D3DLOCK_DISCARD);
    2730                                     Assert(hr == S_OK);
    2731                                     if (hr == S_OK)
    2732                                     {
    2733                                         vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
    2734                                         HRESULT tmpHr = pD3D9Surf->UnlockRect();
    2735                                         Assert(tmpHr == S_OK);
    2736                                     }
     2785                                    vboxWddmLockUnlockMemSynch(pAllocation, &lockInfo, NULL, true /*bool bToLockInfo*/);
     2786                                    HRESULT tmpHr = pD3D9Surf->UnlockRect();
     2787                                    Assert(tmpHr == S_OK);
    27372788                                }
    2738                                 else
    2739                                 {
    2740                                     Assert(!pAllocation->pvMem);
    2741                                 }
    2742                                 pAllocation->pD3DIf = pD3D9Surf;
    27432789                            }
    27442790                            else
    27452791                            {
    2746                                 for (UINT j = 0; j < i; ++j)
    2747                                 {
    2748                                     pRc->aAllocations[j].pD3DIf->Release();
    2749                                 }
    2750                                 break;
     2792                                Assert(!pAllocation->pvMem);
    27512793                            }
     2794                            pAllocation->pD3DIf = pD3D9Surf;
     2795                        }
     2796                        else
     2797                        {
     2798                            for (UINT j = 0; j < i; ++j)
     2799                            {
     2800                                pRc->aAllocations[j].pD3DIf->Release();
     2801                            }
     2802                            break;
    27522803                        }
    27532804                    }
    2754 
    2755                     if (hr != S_OK)
     2805                }
     2806
     2807                if (hr != S_OK)
     2808                {
     2809                    if (bDevCreated)
    27562810                    {
    27572811                        VBoxDispWndDestroy(pAdapter, hWnd);
     2812                        pDevice->pDevice9If->Release();
    27582813                    }
    27592814                }
     
    30073062                    pDdiAllocI->VidPnSourceId = pResource->VidPnSourceId;
    30083063                    pDdiAllocI->Flags.Value = 0;
    3009                     if (pResource->Flags.Primary && pResource->Flags.RenderTarget)
     3064                    if (pResource->Flags.Primary)
     3065                    {
     3066                        Assert(pResource->Flags.RenderTarget);
    30103067                        pDdiAllocI->Flags.Primary = 1;
     3068                    }
    30113069
    30123070                    pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
     
    31043162            Assert(pDevice->hWnd);
    31053163            Assert(pDevice->pDevice9If);
    3106             pDevice->pDevice9If->Release();
    3107             HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
    3108             Assert(tmpHr == S_OK);
     3164            if (pDevice->pDevice9If)
     3165            {
     3166                pDevice->pDevice9If->Release();
     3167                HRESULT tmpHr = VBoxDispWndDestroy(pAdapter, pDevice->hWnd);
     3168                Assert(tmpHr == S_OK);
     3169            }
    31093170        }
    31103171
     
    31483209static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
    31493210{
    3150     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3151     AssertBreakpoint();
    3152     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3153     return E_FAIL;
     3211    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3212    HRESULT hr = S_OK;
     3213    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3214    Assert(pDevice);
     3215    Assert(VBOXDISPMODE_IS_3D(pDevice->pAdapter));
     3216    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
     3217    Assert(pRc);
     3218    Assert(pRc->cAllocations > pData->SubResourceIndex);
     3219    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3220    Assert(pRc->RcDesc.fFlags.RenderTarget);
     3221    Assert(pAlloc->hAllocation);
     3222    D3DDDICB_SETDISPLAYMODE DdiDm = {0};
     3223    DdiDm.hPrimaryAllocation = pAlloc->hAllocation;
     3224//    DdiDm.PrivateDriverFormatAttribute = 0;
     3225    hr = pDevice->RtCallbacks.pfnSetDisplayModeCb(pDevice->hDevice, &DdiDm);
     3226    Assert(hr == S_OK);
     3227
     3228    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3229    return hr;
    31543230}
    31553231static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
     
    33313407static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
    33323408{
    3333     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3334     AssertBreakpoint();
    3335     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3336     return E_FAIL;
     3409    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3410    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3411    Assert(pDevice);
     3412    Assert(pDevice->pDevice9If);
     3413    HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantI(pData->Register, pRegisters, pData->Count);
     3414    Assert(hr == S_OK);
     3415    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3416    return hr;
    33373417}
    33383418static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
    33393419{
    3340     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3341     AssertBreakpoint();
    3342     vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    3343     return E_FAIL;
     3420    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3421    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3422    Assert(pDevice);
     3423    Assert(pDevice->pDevice9If);
     3424    HRESULT hr = pDevice->pDevice9If->SetVertexShaderConstantB(pData->Register, pRegisters, pData->Count);
     3425    Assert(hr == S_OK);
     3426    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3427    return hr;
    33443428}
    33453429static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
     
    33613445    Assert(pDevice->pDevice9If);
    33623446    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hVertexBuffer;
    3363     Assert(pRc);
    3364     Assert(pRc->cAllocations == 1);
    3365     PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[0];
    3366     Assert(pAlloc->pD3DIf);
    3367     IDirect3DVertexBuffer9 *pStreamData = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
     3447    PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
     3448    IDirect3DVertexBuffer9 *pStreamData = NULL;
     3449    if (pRc)
     3450    {
     3451        Assert(pRc->cAllocations == 1);
     3452        pAlloc = &pRc->aAllocations[0];
     3453        Assert(pAlloc->pD3DIf);
     3454        pStreamData = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
     3455    }
    33683456    HRESULT hr = pDevice->pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
     3457    Assert(hr == S_OK);
    33693458    Assert(pData->Stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS);
    3370     pDevice->aStreamSource[pData->Stream] = pAlloc;
    3371     pDevice->StreamSourceInfo[pData->Stream].uiOffset = pData->Offset;
    3372     pDevice->StreamSourceInfo[pData->Stream].uiStride = pData->Stride;
    3373     Assert(hr == S_OK);
     3459    if (hr == S_OK)
     3460    {
     3461        pDevice->aStreamSource[pData->Stream] = pAlloc;
     3462        pDevice->StreamSourceInfo[pData->Stream].uiOffset = pData->Offset;
     3463        pDevice->StreamSourceInfo[pData->Stream].uiStride = pData->Stride;
     3464    }
    33743465    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    33753466    return hr;
     
    34683559    Assert(pDevice->pDevice9If);
    34693560    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
    3470     Assert(pRc);
    3471     Assert(pRc->cAllocations == 1);
    3472     IDirect3DSurface9 *pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[0].pD3DIf;
    3473     Assert(pD3D9Surf);
     3561    IDirect3DSurface9 *pD3D9Surf = NULL;
     3562    if (pRc)
     3563    {
     3564        Assert(pRc->cAllocations == 1);
     3565        pD3D9Surf = (IDirect3DSurface9*)pRc->aAllocations[0].pD3DIf;
     3566        Assert(pD3D9Surf);
     3567    }
    34743568    HRESULT hr = pDevice->pDevice9If->SetDepthStencilSurface(pD3D9Surf);
    34753569    Assert(hr == S_OK);
     
    39374031        else
    39384032        {
     4033            AssertBreakpoint(); /* <-- need to test that */
     4034
    39394035            /* this is a "generic" resource whose creation is initiaded by the UMD */
    39404036            Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.h

    r30405 r30554  
    7272} VBOXWDDMDISP_STREAMSOURCEUM, *PVBOXWDDMDISP_STREAMSOURCEUM;
    7373
     74typedef struct VBOXWDDMDISP_INDICIESUM
     75{
     76    CONST VOID* pvBuffer;
     77    UINT cbSize;
     78} VBOXWDDMDISP_INDICIESUM, *PVBOXWDDMDISP_INDICIESUM;
     79
    7480struct VBOXWDDMDISP_ALLOCATION;
    7581
     
    7985  UINT   uiStride;
    8086} VBOXWDDMDISP_STREAM_SOURCE_INFO;
     87
     88typedef struct VBOXWDDMDISP_INDICES_INFO
     89{
     90  UINT   uiStride;
     91} VBOXWDDMDISP_INDICES_INFO;
    8192
    8293typedef struct VBOXWDDMDISP_DEVICE
     
    96107    VBOXWDDMDISP_ALLOCATION *aStreamSource[VBOXWDDMDISP_MAX_VERTEX_STREAMS];
    97108    VBOXWDDMDISP_STREAM_SOURCE_INFO StreamSourceInfo[VBOXWDDMDISP_MAX_VERTEX_STREAMS];
     109    VBOXWDDMDISP_INDICIESUM IndiciesUm;
     110    VBOXWDDMDISP_ALLOCATION *pIndicesAlloc;
     111    VBOXWDDMDISP_INDICES_INFO IndiciesInfo;
    98112    IDirect3DDevice9 *pDevice9If;
    99113    /* need to cache the ViewPort data because IDirect3DDevice9::SetViewport
  • trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3DCmn.h

    r30508 r30554  
    6363    } while (0)
    6464#define vboxVDbgPrintR vboxVDbgPrint
    65 #define vboxVDbgPrintF(_m) do {} while (0)
     65#define vboxVDbgPrintF vboxVDbgPrint
    6666#else
    6767#define vboxVDbgBreak() do {} while (0)
  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

    r30540 r30554  
    33413341    DXGKARG_GETSCANLINE*  pGetScanLine)
    33423342{
    3343     dfprintf(("==> "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
     3343//    dfprintf(("==> "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
    33443344
    33453345    PDEVICE_EXTENSION pDevExt = (PDEVICE_EXTENSION)hAdapter;
     
    33693369    }
    33703370
    3371     dfprintf(("<== "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
     3371//    dfprintf(("<== "__FUNCTION__ ", hAdapter(0x%x)\n", hAdapter));
    33723372
    33733373    return STATUS_SUCCESS;
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette