VirtualBox

Changeset 77046 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Jan 30, 2019 2:31:40 PM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
128489
Message:

WDDM: Gallium Display Driver: separate Gallium based driver from the old code. bugref:8893

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

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxDispD3D.cpp

    r76553 r77046  
    57895789    VBOXDISPPROFILE_DDI_TERM(pDevice);
    57905790
     5791    AssertReturn(pDevice->pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VBOX, E_INVALIDARG);
     5792
    57915793#ifdef VBOXWDDMDISP_DEBUG_TIMER
    57925794        DeleteTimerQueueEx(pDevice->hTimerQueue, INVALID_HANDLE_VALUE /* see term */);
    … …  
    58025804        if (pDevice->pDevice9If)
    58035805        {
    5804             if (pDevice->pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VBOX)
    5805                 pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9Term((IDirect3DDevice9Ex *)pDevice->pDevice9If);
    5806 #ifdef VBOX_WITH_MESA3D
    5807             else if (pDevice->pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
    5808             {
    5809                 pDevice->pDevice9If->Release();
    5810                 pDevice->pDevice9If = NULL;
    5811             }
    5812 #endif
     5806            pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9Term((IDirect3DDevice9Ex *)pDevice->pDevice9If);
    58135807        }
    58145808    }
    … …  
    62266220//    Assert(0);
    62276221    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
     6222    AssertReturn(pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VBOX, E_INVALIDARG);
    62286223
    62296224    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(RT_UOFFSETOF_DYN(VBOXWDDMDISP_DEVICE,
    … …  
    63576352        pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
    63586353
    6359 #ifdef VBOX_WITH_MESA3D
    6360         /** @todo For now just override functions which are already implemented for Gallium backend.
    6361          * The plan is to have only OpenAdapter as common function between old Chromium and new Gallium code.
    6362          * Adapter and device callbacks will be reimplemented for Gallium, because this will simplify
    6363          * the Gallium-only code and keep the old code unchanged.
    6364          * Currently the common callbacks do things which Gallium does not need: vboxWddmDal*, etc.
    6365          *
    6366          * See gallium\GaDdi.h for list of GaDdi* functions which are already implemented.
    6367          */
    6368         if (pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
    6369         {
    6370             pDevice->pfnCreateDirect3DDevice = GaD3DIfDeviceCreate;
    6371             pDevice->pfnCreateSharedPrimary  = GaD3DIfCreateSharedPrimary;
    6372 
    6373             pCreateData->pDeviceFuncs->pfnDrawPrimitive          = GaDdiDrawPrimitive;
    6374             pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive   = GaDdiDrawIndexedPrimitive;
    6375             pCreateData->pDeviceFuncs->pfnDrawPrimitive2         = GaDdiDrawPrimitive2;
    6376             pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2  = GaDdiDrawIndexedPrimitive2;
    6377             pCreateData->pDeviceFuncs->pfnBlt                    = GaDdiBlt;
    6378             pCreateData->pDeviceFuncs->pfnTexBlt                 = GaDdiTexBlt;
    6379             pCreateData->pDeviceFuncs->pfnVolBlt                 = GaDdiVolBlt;
    6380             pCreateData->pDeviceFuncs->pfnFlush                  = GaDdiFlush;
    6381             pCreateData->pDeviceFuncs->pfnPresent                = GaDdiPresent;
    6382             pCreateData->pDeviceFuncs->pfnLock                   = GaDdiLock;
    6383             pCreateData->pDeviceFuncs->pfnUnlock                 = GaDdiUnlock;
    6384             pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = GaDdiCreateVertexShaderFunc;
    6385             pCreateData->pDeviceFuncs->pfnCreatePixelShader      = GaDdiCreatePixelShader;
    6386             pCreateData->pDeviceFuncs->pfnCreateResource         = GaDdiCreateResource;
    6387             pCreateData->pDeviceFuncs->pfnDestroyResource        = GaDdiDestroyResource;
    6388             pCreateData->pDeviceFuncs->pfnOpenResource           = GaDdiOpenResource;
    6389         }
    6390 #endif
    6391 
    63926354        VBOXDISPPROFILE_DDI_INIT_DEV(pDevice);
    63936355#ifdef VBOX_WDDMDISP_WITH_PROFILE
    … …  
    64116373                    VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
    64126374
    6413 #ifdef VBOX_WITH_MESA3D
    6414                     if (pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
    6415                     {
    6416                         RT_ZERO(pDevice->DefaultContext);
    6417                         hr = S_OK;
    6418                     }
    6419                     else
    6420                         hr = vboxDispCmCtxCreate(pDevice, &pDevice->DefaultContext);
    6421 #else
    64226375                    hr = vboxDispCmCtxCreate(pDevice, &pDevice->DefaultContext);
    6423 #endif
    64246376                    Assert(hr == S_OK);
    64256377                    if (hr == S_OK)
    … …  
    65106462    }
    65116463
    6512 #if defined(VBOX_WITH_MESA3D) && defined(VBOX_WITH_MESA3D_D3DTEST)
    6513     /* Built-in gallium backend test for early development stages.
    6514      * Use it only with kernel debugger attached to the VM.
    6515      */
    6516     extern void GaDrvTest(IGalliumStack *pGalliumStack, PVBOXWDDMDISP_DEVICE pDevice);
    6517     if (SUCCEEDED(hr))
    6518        GaDrvTest(pAdapter->D3D.pGalliumStack, pDevice);
    6519 #endif
    6520 
    65216464    vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
    65226465
    … …  
    66336576    if (pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VBOX)
    66346577        pAdapter->u32VBox3DCaps = pAdapterInfo->u.vbox.u32VBox3DCaps;
    6635 #ifdef VBOX_WITH_MESA3D
    6636     /** @todo Remove the hack. u32VBox3DCaps should not be used with Gallium. */
    6637     else if (pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
    6638         pAdapter->u32VBox3DCaps = CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA;
    6639 #endif
    66406578    pAdapter->AdapterInfo = *pAdapterInfo;
    66416579#ifdef VBOX_WITH_VIDEOHWACCEL
    … …  
    67016639
    67026640        /* Return data to the OS. */
    6703         pOpenData->hAdapter = pAdapter;
    6704         pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
    6705         pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
    6706         pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
    6707         pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION_VISTA;
    6708     }
    6709     else
     6641        if (pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VBOX)
     6642        {
     6643            pOpenData->hAdapter = pAdapter;
     6644            pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
     6645            pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
     6646            pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
     6647            pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION_VISTA;
     6648        }
     6649#ifdef VBOX_WITH_MESA3D
     6650        else if (pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
     6651        {
     6652            pOpenData->hAdapter                       = pAdapter;
     6653            pOpenData->pAdapterFuncs->pfnGetCaps      = GaDdiAdapterGetCaps;
     6654            pOpenData->pAdapterFuncs->pfnCreateDevice = GaDdiAdapterCreateDevice;
     6655            pOpenData->pAdapterFuncs->pfnCloseAdapter = GaDdiAdapterCloseAdapter;
     6656            pOpenData->DriverVersion                  = D3D_UMD_INTERFACE_VERSION_VISTA;
     6657        }
     6658#endif
     6659        else
     6660            hr = E_FAIL;
     6661    }
     6662
     6663    if (FAILED(hr))
    67106664    {
    67116665        WARN(("OpenAdapter failed hr 0x%x", hr));

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/VBoxUhgsmiKmt.cpp

    r76553 r77046  
    334334    if (Query.enmHwType == VBOXVIDEO_HWTYPE_VBOX)
    335335        *pu32Caps = Query.u.vbox.u32VBox3DCaps;
    336 #ifdef VBOX_WITH_MESA3D
    337     /** @todo Remove the hack. u32VBox3DCaps should not be used with Gallium. */
    338     else if (Query.enmHwType == VBOXVIDEO_HWTYPE_VMSVGA)
    339         *pu32Caps = CR_VBOX_CAP_TEX_PRESENT | CR_VBOX_CAP_CMDVBVA;
    340 #endif
    341336    else
    342337        *pu32Caps = 0;

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDdi.cpp

    r76553 r77046  
    342342    }
    343343
    344 //    vboxWddmDalCheckAddRc(pDevice, pDstRc, TRUE);
    345 //    vboxWddmDalCheckAddRc(pDevice, pSrcRc, FALSE);
    346 
    347344    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    348345    return hr;
    … …  
    14671464}
    14681465
     1466HRESULT APIENTRY GaDdiSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
     1467{
     1468    VBOXVDBG_BREAK_DDI();
     1469
     1470    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1471
     1472    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1473    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     1474
     1475    IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9 *)hShaderHandle;
     1476
     1477    HRESULT hr = pDevice9If->SetVertexShader(pShader);
     1478    Assert(hr == S_OK);
     1479
     1480    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1481    return hr;
     1482}
     1483
     1484HRESULT APIENTRY GaDdiDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
     1485{
     1486    VBOXVDBG_BREAK_DDI();
     1487
     1488    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1489
     1490    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1491    RT_NOREF(pDevice);
     1492
     1493    IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9 *)hShaderHandle;
     1494    pShader->Release();
     1495
     1496    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, S_OK));
     1497    return S_OK;
     1498}
     1499
     1500HRESULT APIENTRY GaDdiSetVertexShaderConst(HANDLE hDevice, const D3DDDIARG_SETVERTEXSHADERCONST *pData,
     1501                                           const VOID *pRegisters)
     1502{
     1503    VBOXVDBG_BREAK_DDI();
     1504
     1505    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1506
     1507    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1508    IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
     1509
     1510    HRESULT hr = pDevice9If->SetVertexShaderConstantF(pData->Register,
     1511                                                      (const float*)pRegisters,
     1512                                                      pData->Count);
     1513    Assert(hr == S_OK);
     1514
     1515    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1516    return hr;
     1517}
     1518
     1519HRESULT APIENTRY GaDdiSetVertexShaderConstI(HANDLE hDevice, const D3DDDIARG_SETVERTEXSHADERCONSTI *pData,
     1520                                            const INT *pRegisters)
     1521{
     1522    VBOXVDBG_BREAK_DDI();
     1523
     1524    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1525
     1526    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1527    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     1528
     1529    HRESULT hr = pDevice9If->SetVertexShaderConstantI(pData->Register, pRegisters, pData->Count);
     1530    Assert(hr == S_OK);
     1531
     1532    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1533    return hr;
     1534}
     1535
     1536HRESULT APIENTRY GaDdiSetVertexShaderConstB(HANDLE hDevice, const D3DDDIARG_SETVERTEXSHADERCONSTB *pData,
     1537                                            const BOOL *pRegisters)
     1538{
     1539    VBOXVDBG_BREAK_DDI();
     1540
     1541    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1542
     1543    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1544    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     1545
     1546    HRESULT hr = pDevice9If->SetVertexShaderConstantB(pData->Register, pRegisters, pData->Count);
     1547    Assert(hr == S_OK);
     1548
     1549    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1550    return hr;
     1551}
     1552
    14691553HRESULT APIENTRY GaDdiCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER *pData, const UINT *pCode)
    14701554{
    … …  
    15281612        }
    15291613    }
     1614
     1615    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1616    return hr;
     1617}
     1618
     1619HRESULT APIENTRY GaDdiDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
     1620{
     1621    VBOXVDBG_BREAK_DDI();
     1622
     1623    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1624
     1625    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1626    RT_NOREF(pDevice);
     1627
     1628    IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9 *)hShaderHandle;
     1629
     1630    pShader->Release();
     1631
     1632    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, S_OK));
     1633    return S_OK;
     1634}
     1635
     1636HRESULT APIENTRY GaDdiSetPixelShaderConstI(HANDLE hDevice, const D3DDDIARG_SETPIXELSHADERCONSTI *pData,
     1637                                           const INT *pRegisters)
     1638{
     1639    VBOXVDBG_BREAK_DDI();
     1640
     1641    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1642
     1643    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1644    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     1645
     1646    HRESULT hr = pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
     1647    Assert(hr == S_OK);
     1648
     1649    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     1650    return hr;
     1651}
     1652
     1653HRESULT APIENTRY GaDdiSetPixelShaderConstB(HANDLE hDevice, const D3DDDIARG_SETPIXELSHADERCONSTB *pData,
     1654                                           const BOOL *pRegisters)
     1655{
     1656    VBOXVDBG_BREAK_DDI();
     1657
     1658    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     1659
     1660    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     1661    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     1662
     1663    HRESULT hr = pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
     1664    Assert(hr == S_OK);
    15301665
    15311666    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    … …  
    18942029}
    18952030
    1896 /** @todo Will be removed when there will be a full set of GaDdi functions, which will not use this. */
    1897 extern BOOLEAN vboxWddmDalCheckNotifyRemove(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc);
    1898 
    18992031HRESULT APIENTRY GaDdiDestroyResource(HANDLE hDevice, HANDLE hResource)
    19002032{
    … …  
    19392071            if (pAlloc->pD3DIf)
    19402072                pAlloc->pD3DIf->Release();
    1941 
    1942             vboxWddmDalCheckNotifyRemove(pDevice, pAlloc);
    19432073        }
    19442074    }
    … …  
    21512281}
    21522282
    2153 /** @todo Will be removed when there will be a full set of GaDdi functions, which will not use this. */
    2154 extern VOID vboxWddmDalCheckAddOnDraw(PVBOXWDDMDISP_DEVICE pDevice);
    2155 
    21562283HRESULT APIENTRY GaDdiDrawPrimitive(HANDLE hDevice, const D3DDDIARG_DRAWPRIMITIVE *pData, const UINT *pFlagBuffer)
    21572284{
    … …  
    22342361        Assert(hr == S_OK);
    22352362    }
    2236 
    2237     vboxWddmDalCheckAddOnDraw(pDevice);
    22382363
    22392364    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    … …  
    23482473    }
    23492474
    2350     vboxWddmDalCheckAddOnDraw(pDevice);
    2351 
    23522475    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
    23532476    return hr;
    … …  
    24022525        hr = E_FAIL;
    24032526    }
    2404 
    2405     vboxWddmDalCheckAddOnDraw(pDevice);
    24062527
    24072528    Assert(hr == S_OK);
    … …  
    26082729    }
    26092730
    2610     vboxWddmDalCheckAddOnDraw(pDevice);
    2611 
    2612     vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
    2613     return hr;
    2614 }
     2731    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2732    return hr;
     2733}
     2734
     2735HRESULT APIENTRY GaDdiSetRenderState(HANDLE hDevice, const D3DDDIARG_RENDERSTATE *pData)
     2736{
     2737    VBOXVDBG_BREAK_DDI();
     2738
     2739    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2740
     2741    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2742    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2743
     2744    D3DRENDERSTATETYPE const enmD3DRenderStateType = vboxDDI2D3DRenderStateType(pData->State);
     2745    HRESULT hr = pDevice9If->SetRenderState(enmD3DRenderStateType, pData->Value);
     2746    Assert(hr == S_OK);
     2747
     2748    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     2749    return hr;
     2750}
     2751
     2752HRESULT APIENTRY GaDdiUpdateWInfo(HANDLE hDevice, const D3DDDIARG_WINFO *pData)
     2753{
     2754    VBOXVDBG_BREAK_DDI();
     2755
     2756    RT_NOREF(hDevice, pData);
     2757
     2758    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2759
     2760    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2761    return S_OK;
     2762}
     2763
     2764HRESULT APIENTRY GaDdiValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE *pData)
     2765{
     2766    VBOXVDBG_BREAK_DDI();
     2767
     2768    RT_NOREF(hDevice, pData);
     2769
     2770    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2771
     2772    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2773    return S_OK;
     2774}
     2775
     2776HRESULT APIENTRY GaDdiSetTextureStageState(HANDLE hDevice, const D3DDDIARG_TEXTURESTAGESTATE *pData)
     2777{
     2778    VBOXVDBG_BREAK_DDI();
     2779
     2780    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2781
     2782    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2783    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2784
     2785    VBOXWDDMDISP_TSS_LOOKUP lookup = vboxDDI2D3DTestureStageStateType(pData->State);
     2786
     2787    HRESULT hr;
     2788    if (lookup.bSamplerState)
     2789    {
     2790        hr = pDevice9If->SetSamplerState(pData->Stage, (D3DSAMPLERSTATETYPE)lookup.dType, pData->Value);
     2791    }
     2792    else
     2793    {
     2794        hr = pDevice9If->SetTextureStageState(pData->Stage, (D3DTEXTURESTAGESTATETYPE)lookup.dType, pData->Value);
     2795    }
     2796    Assert(hr == S_OK);
     2797
     2798    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     2799    return hr;
     2800}
     2801
     2802HRESULT APIENTRY GaDdiSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
     2803{
     2804    VBOXVDBG_BREAK_DDI();
     2805
     2806    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2807
     2808    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2809    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2810
     2811    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hTexture;
     2812
     2813    int const idx = VBOXWDDMDISP_SAMPLER_IDX(Stage);
     2814    AssertMsgReturn(idx >= 0 && idx < RT_ELEMENTS(pDevice->aSamplerTextures),
     2815                    ("Stage %d, idx %d, hTexture %p\n", Stage, idx, hTexture), E_FAIL);
     2816
     2817    Assert(pDevice->cSamplerTextures < RT_ELEMENTS(pDevice->aSamplerTextures));
     2818
     2819    IDirect3DBaseTexture9 *pD3DIfTex = NULL;
     2820    if (pRc)
     2821    {
     2822        // VBOXVDBG_CHECK_SMSYNC(pRc);
     2823        if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
     2824        {
     2825            pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
     2826        }
     2827        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE)
     2828        {
     2829            pD3DIfTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
     2830        }
     2831        else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
     2832        {
     2833            pD3DIfTex = (IDirect3DVolumeTexture9*)pRc->aAllocations[0].pD3DIf;
     2834        }
     2835        else
     2836        {
     2837            AssertFailed();
     2838        }
     2839
     2840        if (pD3DIfTex && !pDevice->aSamplerTextures[idx])
     2841        {
     2842            ++pDevice->cSamplerTextures;
     2843        }
     2844    }
     2845    else
     2846    {
     2847        if (pDevice->aSamplerTextures[idx])
     2848        {
     2849            Assert(pDevice->cSamplerTextures);
     2850            --pDevice->cSamplerTextures;
     2851        }
     2852    }
     2853
     2854    Assert(pDevice->cSamplerTextures < RT_ELEMENTS(pDevice->aSamplerTextures));
     2855    pDevice->aSamplerTextures[idx] = pRc;
     2856
     2857    HRESULT hr = pDevice9If->SetTexture(Stage, pD3DIfTex);
     2858    Assert(hr == S_OK);
     2859
     2860    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     2861    return hr;
     2862}
     2863
     2864HRESULT APIENTRY GaDdiSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
     2865{
     2866    VBOXVDBG_BREAK_DDI();
     2867
     2868    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2869
     2870    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2871    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2872
     2873    IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9 *)hShaderHandle;
     2874    HRESULT hr = pDevice9If->SetPixelShader(pShader);
     2875    Assert(hr == S_OK);
     2876
     2877    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     2878    return hr;
     2879}
     2880
     2881HRESULT APIENTRY GaDdiSetPixelShaderConst(HANDLE hDevice, const D3DDDIARG_SETPIXELSHADERCONST *pData,
     2882                                          const FLOAT *pRegisters)
     2883{
     2884    VBOXVDBG_BREAK_DDI();
     2885
     2886    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2887    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2888    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2889
     2890    HRESULT hr = pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
     2891    Assert(hr == S_OK);
     2892
     2893    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     2894    return hr;
     2895}
     2896
     2897HRESULT APIENTRY GaDdiSetStreamSourceUm(HANDLE hDevice, const D3DDDIARG_SETSTREAMSOURCEUM *pData,
     2898                                        const VOID *pUMBuffer)
     2899{
     2900    VBOXVDBG_BREAK_DDI();
     2901
     2902    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2903
     2904    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2905    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2906
     2907    AssertReturn(pData->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm), E_INVALIDARG);
     2908
     2909    PVBOXWDDMDISP_STREAMSOURCEUM pStrSrcUm = &pDevice->aStreamSourceUm[pData->Stream];
     2910    if (pStrSrcUm->pvBuffer && !pUMBuffer)
     2911    {
     2912        --pDevice->cStreamSourcesUm;
     2913        Assert(pDevice->cStreamSourcesUm < UINT32_MAX/2);
     2914    }
     2915    else if (!pStrSrcUm->pvBuffer && pUMBuffer)
     2916    {
     2917        ++pDevice->cStreamSourcesUm;
     2918        Assert(pDevice->cStreamSourcesUm <= RT_ELEMENTS(pDevice->aStreamSourceUm));
     2919    }
     2920
     2921    pStrSrcUm->pvBuffer = pUMBuffer;
     2922    pStrSrcUm->cbStride = pData->Stride;
     2923
     2924    HRESULT hr = S_OK;
     2925    if (pDevice->aStreamSource[pData->Stream])
     2926    {
     2927        hr = pDevice9If->SetStreamSource(pData->Stream, NULL, 0, 0);
     2928        pDevice->aStreamSource[pData->Stream] = NULL;
     2929
     2930        --pDevice->cStreamSources;
     2931        Assert(pDevice->cStreamSources < UINT32_MAX/2);
     2932    }
     2933
     2934    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     2935    return hr;
     2936}
     2937
     2938HRESULT APIENTRY GaDdiSetIndices(HANDLE hDevice, const D3DDDIARG_SETINDICES *pData)
     2939{
     2940    VBOXVDBG_BREAK_DDI();
     2941
     2942    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2943
     2944    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2945    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2946
     2947    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hIndexBuffer;
     2948    PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
     2949    IDirect3DIndexBuffer9 *pIndexBuffer = NULL;
     2950    if (pRc)
     2951    {
     2952        // VBOXVDBG_CHECK_SMSYNC(pRc);
     2953        Assert(pRc->cAllocations == 1);
     2954
     2955        pAlloc = &pRc->aAllocations[0];
     2956        Assert(pAlloc->pD3DIf);
     2957
     2958        pIndexBuffer = (IDirect3DIndexBuffer9 *)pAlloc->pD3DIf;
     2959    }
     2960
     2961    HRESULT hr = pDevice9If->SetIndices(pIndexBuffer);
     2962    Assert(hr == S_OK);
     2963    if (hr == S_OK)
     2964    {
     2965        pDevice->IndiciesInfo.pIndicesAlloc = pAlloc;
     2966        pDevice->IndiciesInfo.uiStride = pData->Stride;
     2967        pDevice->IndiciesInfo.pvIndicesUm = NULL;
     2968    }
     2969
     2970    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     2971    return hr;
     2972}
     2973
     2974HRESULT APIENTRY GaDdiSetIndicesUm(HANDLE hDevice, UINT IndexSize, const VOID *pUMBuffer)
     2975{
     2976    VBOXVDBG_BREAK_DDI();
     2977
     2978    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     2979
     2980    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     2981    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     2982
     2983    HRESULT hr = S_OK;
     2984    if (pDevice->IndiciesInfo.pIndicesAlloc)
     2985    {
     2986        hr = pDevice9If->SetIndices(NULL);
     2987    }
     2988
     2989    if (SUCCEEDED(hr))
     2990    {
     2991        pDevice->IndiciesInfo.pvIndicesUm = pUMBuffer;
     2992        pDevice->IndiciesInfo.uiStride = IndexSize;
     2993        pDevice->IndiciesInfo.pIndicesAlloc = NULL;
     2994        hr = S_OK;
     2995    }
     2996    else
     2997    {
     2998        WARN(("SetIndices failed hr 0x%x", hr));
     2999    }
     3000
     3001    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3002    return hr;
     3003}
     3004
     3005HRESULT APIENTRY GaDdiBufBlt(HANDLE hDevice, const D3DDDIARG_BUFFERBLT *pData)
     3006{
     3007    VBOXVDBG_BREAK_DDI();
     3008
     3009    RT_NOREF(pData);
     3010
     3011    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3012    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3013    RT_NOREF(pDevice);
     3014
     3015    /// @todo Not implemented.
     3016    AssertFailed();
     3017
     3018    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3019    return E_NOTIMPL;
     3020}
     3021
     3022HRESULT APIENTRY GaDdiStateSet(HANDLE hDevice, D3DDDIARG_STATESET *pData)
     3023{
     3024    VBOXVDBG_BREAK_DDI();
     3025
     3026    RT_NOREF(pData);
     3027
     3028    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3029
     3030    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3031    RT_NOREF(pDevice);
     3032
     3033    /// @todo Not implemented.
     3034    AssertFailed();
     3035
     3036    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3037    return E_NOTIMPL;
     3038}
     3039
     3040HRESULT APIENTRY GaDdiSetPriority(HANDLE hDevice, const D3DDDIARG_SETPRIORITY *pData)
     3041{
     3042    VBOXVDBG_BREAK_DDI();
     3043
     3044    RT_NOREF(pData);
     3045
     3046    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3047
     3048    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3049    RT_NOREF(pDevice);
     3050
     3051    /// @todo Not implemented.
     3052    AssertFailed();
     3053
     3054    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3055
     3056    return S_OK;
     3057}
     3058
     3059AssertCompile(sizeof (RECT) == sizeof (D3DRECT));
     3060AssertCompile(RT_SIZEOFMEMB(RECT, left)   == RT_SIZEOFMEMB(D3DRECT, x1));
     3061AssertCompile(RT_SIZEOFMEMB(RECT, right)  == RT_SIZEOFMEMB(D3DRECT, x2));
     3062AssertCompile(RT_SIZEOFMEMB(RECT, top)    == RT_SIZEOFMEMB(D3DRECT, y1));
     3063AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DRECT, y2));
     3064AssertCompile(RT_OFFSETOF(RECT, left)   == RT_OFFSETOF(D3DRECT, x1));
     3065AssertCompile(RT_OFFSETOF(RECT, right)  == RT_OFFSETOF(D3DRECT, x2));
     3066AssertCompile(RT_OFFSETOF(RECT, top)    == RT_OFFSETOF(D3DRECT, y1));
     3067AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DRECT, y2));
     3068
     3069HRESULT APIENTRY GaDdiClear(HANDLE hDevice, const D3DDDIARG_CLEAR *pData, UINT NumRect, const RECT *pRect)
     3070{
     3071    VBOXVDBG_BREAK_DDI();
     3072
     3073    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3074
     3075    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3076    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3077
     3078    HRESULT hr = pDevice9If->Clear(NumRect, (D3DRECT *)pRect /* see AssertCompile above */,
     3079                                   pData->Flags,
     3080                                   pData->FillColor,
     3081                                   pData->FillDepth,
     3082                                   pData->FillStencil);
     3083    Assert(hr == S_OK);
     3084
     3085    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3086    return hr;
     3087}
     3088
     3089HRESULT APIENTRY GaDdiUpdatePalette(HANDLE hDevice, const D3DDDIARG_UPDATEPALETTE *pData,
     3090                                    const PALETTEENTRY *pPaletteData)
     3091{
     3092    VBOXVDBG_BREAK_DDI();
     3093
     3094    RT_NOREF(pData, pPaletteData);
     3095
     3096    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3097
     3098    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3099    RT_NOREF(pDevice);
     3100
     3101    /// @todo Not implemented.
     3102    AssertFailed();
     3103
     3104    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3105    return E_NOTIMPL;
     3106}
     3107
     3108HRESULT APIENTRY GaDdiSetPalette(HANDLE hDevice, const D3DDDIARG_SETPALETTE *pData)
     3109{
     3110    VBOXVDBG_BREAK_DDI();
     3111
     3112    RT_NOREF(pData);
     3113
     3114    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3115
     3116    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3117    RT_NOREF(pDevice);
     3118
     3119    /// @todo Not implemented.
     3120    AssertFailed();
     3121
     3122    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3123    return E_NOTIMPL;
     3124}
     3125
     3126HRESULT APIENTRY GaDdiMultiplyTransform(HANDLE hDevice, const D3DDDIARG_MULTIPLYTRANSFORM *pData)
     3127{
     3128    VBOXVDBG_BREAK_DDI();
     3129
     3130    RT_NOREF(pData);
     3131
     3132    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3133
     3134    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3135    RT_NOREF(pDevice);
     3136
     3137    /// @todo Not implemented.
     3138    AssertFailed();
     3139
     3140    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3141    return E_NOTIMPL;
     3142}
     3143
     3144HRESULT APIENTRY GaDdiSetTransform(HANDLE hDevice, const D3DDDIARG_SETTRANSFORM *pData)
     3145{
     3146    VBOXVDBG_BREAK_DDI();
     3147
     3148    RT_NOREF(pData);
     3149
     3150    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3151
     3152    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3153    RT_NOREF(pDevice);
     3154
     3155    /// @todo Not implemented.
     3156    AssertFailed();
     3157
     3158    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3159    return E_NOTIMPL;
     3160}
     3161
     3162HRESULT APIENTRY GaDdiSetViewport(HANDLE hDevice, const D3DDDIARG_VIEWPORTINFO *pData)
     3163{
     3164    VBOXVDBG_BREAK_DDI();
     3165
     3166    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3167
     3168    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3169    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3170
     3171    pDevice->ViewPort.X      = pData->X;
     3172    pDevice->ViewPort.Y      = pData->Y;
     3173    pDevice->ViewPort.Width  = pData->Width;
     3174    pDevice->ViewPort.Height = pData->Height;
     3175
     3176    HRESULT hr = pDevice9If->SetViewport(&pDevice->ViewPort);
     3177    Assert(hr == S_OK);
     3178
     3179    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3180    return hr;
     3181}
     3182
     3183HRESULT APIENTRY GaDdiSetZRange(HANDLE hDevice, const D3DDDIARG_ZRANGE *pData)
     3184{
     3185    VBOXVDBG_BREAK_DDI();
     3186
     3187    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3188
     3189    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3190    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3191
     3192    pDevice->ViewPort.MinZ = pData->MinZ;
     3193    pDevice->ViewPort.MaxZ = pData->MaxZ;
     3194
     3195    HRESULT hr = pDevice9If->SetViewport(&pDevice->ViewPort);
     3196    Assert(hr == S_OK);
     3197
     3198    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3199    return hr;
     3200}
     3201
     3202HRESULT APIENTRY GaDdiSetMaterial(HANDLE hDevice, const D3DDDIARG_SETMATERIAL *pData)
     3203{
     3204    VBOXVDBG_BREAK_DDI();
     3205
     3206    RT_NOREF(pData);
     3207
     3208    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3209
     3210    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3211    RT_NOREF(pDevice);
     3212
     3213    /// @todo Not implemented.
     3214    AssertFailed();
     3215
     3216    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3217    return E_NOTIMPL;
     3218}
     3219
     3220HRESULT APIENTRY GaDdiSetLight(HANDLE hDevice, const D3DDDIARG_SETLIGHT *pData, const D3DDDI_LIGHT *pLightProperties)
     3221{
     3222    VBOXVDBG_BREAK_DDI();
     3223
     3224    RT_NOREF(pData, pLightProperties);
     3225
     3226    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3227
     3228    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3229    RT_NOREF(pDevice);
     3230
     3231    /// @todo Not implemented.
     3232    AssertFailed();
     3233
     3234    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3235    return E_NOTIMPL;
     3236}
     3237
     3238HRESULT APIENTRY GaDdiCreateLight(HANDLE hDevice, const D3DDDIARG_CREATELIGHT *pData)
     3239{
     3240    VBOXVDBG_BREAK_DDI();
     3241
     3242    RT_NOREF(pData);
     3243
     3244    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3245
     3246    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3247    RT_NOREF(pDevice);
     3248
     3249    /// @todo Not implemented.
     3250    AssertFailed();
     3251
     3252    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3253    return E_NOTIMPL;
     3254}
     3255
     3256HRESULT APIENTRY GaDdiDestroyLight(HANDLE hDevice, const D3DDDIARG_DESTROYLIGHT *pData)
     3257{
     3258    VBOXVDBG_BREAK_DDI();
     3259
     3260    RT_NOREF(pData);
     3261
     3262    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3263
     3264    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3265    RT_NOREF(pDevice);
     3266
     3267    /// @todo Not implemented.
     3268    AssertFailed();
     3269
     3270    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3271    return E_NOTIMPL;
     3272}
     3273
     3274HRESULT APIENTRY GaDdiSetClipPlane(HANDLE hDevice, const D3DDDIARG_SETCLIPPLANE *pData)
     3275{
     3276    VBOXVDBG_BREAK_DDI();
     3277
     3278    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3279
     3280    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3281    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3282
     3283    HRESULT hr = pDevice9If->SetClipPlane(pData->Index, pData->Plane);
     3284    Assert(hr == S_OK);
     3285
     3286    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3287    return hr;
     3288}
     3289
     3290HRESULT APIENTRY GaDdiGetInfo(HANDLE hDevice, UINT DevInfoID, VOID *pDevInfoStruct, UINT DevInfoSize)
     3291{
     3292    VBOXVDBG_BREAK_DDI();
     3293
     3294    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3295
     3296    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3297    RT_NOREF(pDevice);
     3298
     3299    HRESULT hr = S_OK;
     3300    switch (DevInfoID)
     3301    {
     3302        case D3DDDIDEVINFOID_VCACHE:
     3303        {
     3304            Assert(DevInfoSize == sizeof (D3DDDIDEVINFO_VCACHE));
     3305            if (DevInfoSize == sizeof (D3DDDIDEVINFO_VCACHE))
     3306            {
     3307                D3DDDIDEVINFO_VCACHE *pVCache = (D3DDDIDEVINFO_VCACHE*)pDevInfoStruct;
     3308                pVCache->Pattern = MAKEFOURCC('C', 'A', 'C', 'H');
     3309                pVCache->OptMethod = 0 /* D3DXMESHOPT_STRIPREORDER */;
     3310                pVCache->CacheSize = 0;
     3311                pVCache->MagicNumber = 0;
     3312            }
     3313            else
     3314                hr = E_INVALIDARG;
     3315            break;
     3316        }
     3317
     3318        default:
     3319            AssertFailed();
     3320            hr = E_NOTIMPL;
     3321    }
     3322
     3323    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3324    return hr;
     3325}
     3326
     3327HRESULT APIENTRY GaDdiSetDisplayMode(HANDLE hDevice, const D3DDDIARG_SETDISPLAYMODE *pData)
     3328{
     3329    VBOXVDBG_BREAK_DDI();
     3330
     3331    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3332
     3333    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3334    Assert(VBOXDISPMODE_IS_3D(pDevice->pAdapter));
     3335
     3336    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
     3337    Assert(pRc);
     3338    Assert(pRc->cAllocations > pData->SubResourceIndex);
     3339
     3340    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3341    Assert(pRc->RcDesc.fFlags.RenderTarget);
     3342    Assert(pRc->RcDesc.fFlags.Primary);
     3343    Assert(pAlloc->hAllocation);
     3344
     3345    D3DDDICB_SETDISPLAYMODE DdiDm;
     3346    RT_ZERO(DdiDm);
     3347    DdiDm.hPrimaryAllocation = pAlloc->hAllocation;
     3348
     3349    HRESULT hr = pDevice->RtCallbacks.pfnSetDisplayModeCb(pDevice->hDevice, &DdiDm);
     3350    Assert(hr == S_OK);
     3351
     3352    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3353    return hr;
     3354}
     3355
     3356AssertCompile(sizeof(D3DDDIVERTEXELEMENT) == sizeof(D3DVERTEXELEMENT9));
     3357AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Stream)     == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Stream));
     3358AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Offset)     == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Offset));
     3359AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Type)       == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Type));
     3360AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Method)     == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Method));
     3361AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Usage)      == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Usage));
     3362AssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, UsageIndex) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, UsageIndex));
     3363AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Stream)     == RT_OFFSETOF(D3DVERTEXELEMENT9, Stream));
     3364AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Offset)     == RT_OFFSETOF(D3DVERTEXELEMENT9, Offset));
     3365AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Type)       == RT_OFFSETOF(D3DVERTEXELEMENT9, Type));
     3366AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Method)     == RT_OFFSETOF(D3DVERTEXELEMENT9, Method));
     3367AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Usage)      == RT_OFFSETOF(D3DVERTEXELEMENT9, Usage));
     3368AssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, UsageIndex) == RT_OFFSETOF(D3DVERTEXELEMENT9, UsageIndex));
     3369
     3370HRESULT APIENTRY GaDdiCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL *pData,
     3371                                             const D3DDDIVERTEXELEMENT *pVertexElements)
     3372{
     3373    static D3DVERTEXELEMENT9 DeclEnd = D3DDECL_END();
     3374
     3375    VBOXVDBG_BREAK_DDI();
     3376
     3377    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3378
     3379    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3380    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3381
     3382    HRESULT hr = S_OK;
     3383
     3384    D3DVERTEXELEMENT9 *pVe = NULL;
     3385    if (memcmp(&DeclEnd, &pVertexElements[pData->NumVertexElements], sizeof(DeclEnd)) != 0)
     3386    {
     3387        pVe = (D3DVERTEXELEMENT9 *)RTMemAlloc(sizeof(D3DVERTEXELEMENT9) * (pData->NumVertexElements + 1));
     3388        if (pVe)
     3389        {
     3390            memcpy(pVe, pVertexElements, sizeof(D3DVERTEXELEMENT9) * pData->NumVertexElements);
     3391            pVe[pData->NumVertexElements] = DeclEnd;
     3392        }
     3393        else
     3394            hr = E_OUTOFMEMORY;
     3395    }
     3396    else
     3397        pVe = (D3DVERTEXELEMENT9 *)pVertexElements;
     3398
     3399    if (hr == S_OK)
     3400    {
     3401        IDirect3DVertexDeclaration9 *pDecl = NULL;
     3402        hr = pDevice9If->CreateVertexDeclaration(pVe, &pDecl);
     3403        Assert(hr == S_OK);
     3404        if (hr == S_OK)
     3405        {
     3406            Assert(pDecl);
     3407            pData->ShaderHandle = pDecl;
     3408        }
     3409    }
     3410
     3411    if (pVe && pVe != (D3DVERTEXELEMENT9 *)pVertexElements)
     3412        RTMemFree(pVe);
     3413
     3414    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3415    return hr;
     3416}
     3417
     3418HRESULT APIENTRY GaDdiSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
     3419{
     3420    VBOXVDBG_BREAK_DDI();
     3421
     3422    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3423
     3424    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3425    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3426
     3427    IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9 *)hShaderHandle;
     3428
     3429    HRESULT hr = pDevice9If->SetVertexDeclaration(pDecl);
     3430    Assert(hr == S_OK);
     3431
     3432    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3433    return hr;
     3434}
     3435
     3436HRESULT APIENTRY GaDdiDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
     3437{
     3438    VBOXVDBG_BREAK_DDI();
     3439
     3440    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3441
     3442    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3443    RT_NOREF(pDevice);
     3444
     3445    IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9 *)hShaderHandle;
     3446
     3447    pDecl->Release();
     3448
     3449    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, S_OK));
     3450    return S_OK;
     3451}
     3452
     3453HRESULT APIENTRY GaDdiSetScissorRect(HANDLE hDevice, const RECT *pRect)
     3454{
     3455    VBOXVDBG_BREAK_DDI();
     3456
     3457    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3458
     3459    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3460    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3461
     3462    HRESULT hr = pDevice9If->SetScissorRect(pRect);
     3463    Assert(hr == S_OK);
     3464
     3465    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3466    return hr;
     3467}
     3468
     3469HRESULT APIENTRY GaDdiSetStreamSource(HANDLE hDevice, const D3DDDIARG_SETSTREAMSOURCE *pData)
     3470{
     3471    VBOXVDBG_BREAK_DDI();
     3472
     3473    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3474
     3475    AssertReturn(pData->Stream < VBOXWDDMDISP_MAX_VERTEX_STREAMS, E_INVALIDARG);
     3476
     3477    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3478    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3479
     3480    PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
     3481    IDirect3DVertexBuffer9 *pStreamData = NULL;
     3482
     3483    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hVertexBuffer;
     3484    if (pRc)
     3485    {
     3486        // VBOXVDBG_CHECK_SMSYNC(pRc);
     3487        Assert(pRc->cAllocations == 1);
     3488        pAlloc = &pRc->aAllocations[0];
     3489
     3490        Assert(pAlloc->pD3DIf);
     3491        pStreamData = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
     3492    }
     3493
     3494    HRESULT hr = pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
     3495    Assert(hr == S_OK);
     3496    if (hr == S_OK)
     3497    {
     3498        if (pDevice->aStreamSource[pData->Stream] && !pAlloc)
     3499        {
     3500            --pDevice->cStreamSources;
     3501            Assert(pDevice->cStreamSources < UINT32_MAX/2);
     3502        }
     3503        else if (!pDevice->aStreamSource[pData->Stream] && pAlloc)
     3504        {
     3505            ++pDevice->cStreamSources;
     3506            Assert(pDevice->cStreamSources <= RT_ELEMENTS(pDevice->aStreamSource));
     3507        }
     3508
     3509        pDevice->aStreamSource[pData->Stream] = pAlloc;
     3510        pDevice->StreamSourceInfo[pData->Stream].uiOffset = pData->Offset;
     3511        pDevice->StreamSourceInfo[pData->Stream].uiStride = pData->Stride;
     3512
     3513        PVBOXWDDMDISP_STREAMSOURCEUM pStrSrcUm = &pDevice->aStreamSourceUm[pData->Stream];
     3514        if (pStrSrcUm->pvBuffer)
     3515        {
     3516            --pDevice->cStreamSourcesUm;
     3517            Assert(pDevice->cStreamSourcesUm < UINT32_MAX/2);
     3518
     3519            pStrSrcUm->pvBuffer = NULL;
     3520            pStrSrcUm->cbStride = 0;
     3521        }
     3522    }
     3523
     3524    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3525    return hr;
     3526}
     3527
     3528HRESULT APIENTRY GaDdiSetStreamSourceFreq(HANDLE hDevice, const D3DDDIARG_SETSTREAMSOURCEFREQ *pData)
     3529{
     3530    VBOXVDBG_BREAK_DDI();
     3531
     3532    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3533
     3534    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3535    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3536
     3537    HRESULT hr = pDevice9If->SetStreamSourceFreq(pData->Stream, pData->Divider);
     3538    Assert(hr == S_OK);
     3539
     3540    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3541    return hr;
     3542}
     3543
     3544HRESULT APIENTRY GaDdiSetConvolutionKernelMono(HANDLE hDevice, const D3DDDIARG_SETCONVOLUTIONKERNELMONO *pData)
     3545{
     3546    VBOXVDBG_BREAK_DDI();
     3547
     3548    RT_NOREF(pData);
     3549
     3550    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3551
     3552    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3553    RT_NOREF(pDevice);
     3554
     3555    /// @todo Not implemented.
     3556    AssertFailed();
     3557
     3558    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3559    return E_NOTIMPL;
     3560}
     3561
     3562HRESULT APIENTRY GaDdiComposeRects(HANDLE hDevice, const D3DDDIARG_COMPOSERECTS *pData)
     3563{
     3564    VBOXVDBG_BREAK_DDI();
     3565
     3566    RT_NOREF(pData);
     3567
     3568    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3569
     3570    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3571    RT_NOREF(pDevice);
     3572
     3573    /// @todo Not implemented.
     3574    AssertFailed();
     3575
     3576    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3577    return E_NOTIMPL;
     3578}
     3579
     3580HRESULT APIENTRY GaDdiColorFill(HANDLE hDevice, const D3DDDIARG_COLORFILL *pData)
     3581{
     3582    VBOXVDBG_BREAK_DDI();
     3583
     3584    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3585
     3586    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3587    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3588
     3589    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
     3590    Assert(pRc);
     3591
     3592    IDirect3DSurface9 *pSurfIf = NULL;
     3593    HRESULT hr = VBoxD3DIfSurfGet(pRc, pData->SubResourceIndex, &pSurfIf);
     3594    Assert(hr == S_OK);
     3595    if (hr == S_OK)
     3596    {
     3597        // VBOXVDBG_CHECK_SMSYNC(pRc);
     3598        Assert(pSurfIf);
     3599
     3600        hr = pDevice9If->ColorFill(pSurfIf, &pData->DstRect, pData->Color);
     3601        Assert(hr == S_OK);
     3602
     3603        /** @todo check what need to do when PresentToDwm flag is set */
     3604        Assert(pData->Flags.Value == 0);
     3605
     3606        pSurfIf->Release();
     3607    }
     3608
     3609    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3610    return hr;
     3611}
     3612
     3613HRESULT APIENTRY GaDdiDepthFill(HANDLE hDevice, const D3DDDIARG_DEPTHFILL *pData)
     3614{
     3615    VBOXVDBG_BREAK_DDI();
     3616
     3617    RT_NOREF(pData);
     3618
     3619    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3620
     3621    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3622    RT_NOREF(pDevice);
     3623
     3624    /// @todo Not implemented.
     3625    AssertFailed();
     3626
     3627    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3628    return E_NOTIMPL;
     3629}
     3630
     3631HRESULT APIENTRY GaDdiCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY *pData)
     3632{
     3633    VBOXVDBG_BREAK_DDI();
     3634
     3635    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3636
     3637    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3638    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3639
     3640    PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)RTMemAllocZ(sizeof(VBOXWDDMDISP_QUERY));
     3641    AssertReturn(pQuery, E_OUTOFMEMORY);
     3642
     3643    D3DQUERYTYPE const d3dQueryType = vboxDDI2D3DQueryType(pData->QueryType);
     3644    HRESULT hr = pDevice9If->CreateQuery(d3dQueryType, &pQuery->pQueryIf);
     3645    if (hr == S_OK)
     3646    {
     3647        pQuery->enmType = pData->QueryType;
     3648        pData->hQuery = pQuery;
     3649    }
     3650    else
     3651    {
     3652        WARN(("CreateQuery failed, hr 0x%x", hr));
     3653        RTMemFree(pQuery);
     3654    }
     3655
     3656    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3657    return hr;
     3658}
     3659
     3660HRESULT APIENTRY GaDdiDestroyQuery(HANDLE hDevice, HANDLE hQuery)
     3661{
     3662    VBOXVDBG_BREAK_DDI();
     3663
     3664    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3665
     3666    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3667    RT_NOREF(pDevice);
     3668
     3669    PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)hQuery;
     3670    Assert(pQuery);
     3671    if (pQuery)
     3672    {
     3673        Assert(pQuery->pQueryIf);
     3674        if (pQuery->pQueryIf)
     3675        {
     3676            pQuery->pQueryIf->Release();
     3677        }
     3678        RTMemFree(pQuery);
     3679    }
     3680
     3681    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3682    return S_OK;
     3683}
     3684
     3685HRESULT APIENTRY GaDdiIssueQuery(HANDLE hDevice, const D3DDDIARG_ISSUEQUERY *pData)
     3686{
     3687    VBOXVDBG_BREAK_DDI();
     3688
     3689    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3690
     3691    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3692    RT_NOREF(pDevice);
     3693
     3694    PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)pData->hQuery;
     3695    AssertReturn(pQuery, E_INVALIDARG);
     3696
     3697    pQuery->fQueryState.Value |= pData->Flags.Value;
     3698
     3699    DWORD const d3dQueryFlags = vboxDDI2D3DIssueQueryFlags(pData->Flags);
     3700    HRESULT hr = pQuery->pQueryIf->Issue(d3dQueryFlags);
     3701    Assert(hr == S_OK);
     3702
     3703    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3704    return hr;
     3705}
     3706
     3707HRESULT APIENTRY GaDdiGetQueryData(HANDLE hDevice, const D3DDDIARG_GETQUERYDATA *pData)
     3708{
     3709    VBOXVDBG_BREAK_DDI();
     3710
     3711    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3712
     3713    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3714    RT_NOREF(pDevice);
     3715
     3716    PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)pData->hQuery;
     3717    AssertReturn(pQuery && pQuery->pQueryIf, E_INVALIDARG);
     3718
     3719    DWORD const cbData = pQuery->pQueryIf->GetDataSize();
     3720#ifdef DEBUG
     3721    switch (pQuery->enmType)
     3722    {
     3723        case D3DDDIQUERYTYPE_EVENT:
     3724            Assert(cbData == sizeof (BOOL));
     3725            break;
     3726        case D3DDDIQUERYTYPE_OCCLUSION:
     3727            Assert(cbData == sizeof (UINT));
     3728            break;
     3729        default:
     3730            AssertFailed();
     3731            break;
     3732    }
     3733#endif
     3734
     3735    HRESULT hr = pQuery->pQueryIf->GetData(pData->pData, cbData, 0);
     3736    Assert(hr == S_OK || hr == S_FALSE);
     3737
     3738#ifdef DEBUG
     3739    switch (pQuery->enmType)
     3740    {
     3741        case D3DDDIQUERYTYPE_EVENT:
     3742            vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p) D3DDDIQUERYTYPE_EVENT %d\n", hDevice, *(BOOL *)pData->pData));
     3743            break;
     3744        case D3DDDIQUERYTYPE_OCCLUSION:
     3745            vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p) D3DDDIQUERYTYPE_OCCLUSION %d\n", hDevice, *(UINT *)pData->pData));
     3746            break;
     3747        default:
     3748            break;
     3749    }
     3750#endif
     3751
     3752    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3753    return hr;
     3754}
     3755
     3756#if 0
     3757static HRESULT vboxWddmRenderTargetSet(PVBOXWDDMDISP_DEVICE pDevice, UINT iRt, PVBOXWDDMDISP_ALLOCATION pAlloc)
     3758{
     3759    IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
     3760    HRESULT hr = S_OK;
     3761    IDirect3DSurface9 *pD3D9Surf = NULL;
     3762    if (pAlloc)
     3763    {
     3764        hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9Surf);
     3765        if (FAILED(hr))
     3766        {
     3767            WARN(("VBoxD3DIfSurfGet failed, hr(0x%x)",hr));
     3768            return hr;
     3769        }
     3770
     3771        Assert(pD3D9Surf);
     3772    }
     3773
     3774    hr = pDevice9If->SetRenderTarget(iRt, pD3D9Surf);
     3775    if (hr == S_OK)
     3776    {
     3777        pDevice->apRTs[iRt] = pAlloc;
     3778    }
     3779    else
     3780    {
     3781        /** @todo This is workaround for wine 1 render target. */
     3782        if (!pAlloc)
     3783        {
     3784            pDevice->apRTs[iRt] = NULL;
     3785            hr = S_OK;
     3786        }
     3787        else
     3788        {
     3789            AssertFailed();
     3790        }
     3791    }
     3792
     3793    if (pD3D9Surf)
     3794    {
     3795        pD3D9Surf->Release();
     3796    }
     3797
     3798    return hr;
     3799}
     3800#endif
     3801
     3802HRESULT APIENTRY GaDdiSetRenderTarget(HANDLE hDevice, const D3DDDIARG_SETRENDERTARGET *pData)
     3803{
     3804    VBOXVDBG_BREAK_DDI();
     3805
     3806    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3807
     3808    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3809    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3810
     3811    AssertReturn(pData->RenderTargetIndex < pDevice->cRTs, E_INVALIDARG);
     3812
     3813    HRESULT hr = S_OK;
     3814    PVBOXWDDMDISP_ALLOCATION pAlloc = NULL;
     3815    IDirect3DSurface9 *pD3D9Surf = NULL;
     3816    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
     3817    if (pRc)
     3818    {
     3819        // VBOXVDBG_CHECK_SMSYNC(pRc);
     3820        Assert(pData->SubResourceIndex < pRc->cAllocations);
     3821
     3822        pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
     3823        hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9Surf);
     3824        if (FAILED(hr))
     3825        {
     3826            WARN(("VBoxD3DIfSurfGet failed, hr(0x%x)",hr));
     3827            return hr;
     3828        }
     3829
     3830        Assert(pD3D9Surf);
     3831    }
     3832
     3833    hr = pDevice9If->SetRenderTarget(pData->RenderTargetIndex, pD3D9Surf);
     3834    Assert(hr == S_OK);
     3835    if (hr == S_OK)
     3836    {
     3837        pDevice->apRTs[pData->RenderTargetIndex] = pAlloc;
     3838    }
     3839
     3840    if (pD3D9Surf)
     3841    {
     3842        pD3D9Surf->Release();
     3843    }
     3844
     3845    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3846    return hr;
     3847}
     3848
     3849HRESULT APIENTRY GaDdiSetDepthStencil(HANDLE hDevice, const D3DDDIARG_SETDEPTHSTENCIL *pData)
     3850{
     3851    VBOXVDBG_BREAK_DDI();
     3852
     3853    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3854
     3855    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3856    IDirect3DDevice9 *pDevice9If = VBOXDISP_D3DEV(pDevice);
     3857
     3858    HRESULT hr = S_OK;
     3859    IDirect3DSurface9 *pD3D9Surf = NULL;
     3860
     3861    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
     3862    if (pRc)
     3863    {
     3864        // VBOXVDBG_CHECK_SMSYNC(pRc);
     3865        Assert(pRc->cAllocations == 1);
     3866
     3867        hr = VBoxD3DIfSurfGet(pRc, 0, &pD3D9Surf);
     3868        if (FAILED(hr))
     3869            WARN(("VBoxD3DIfSurfGet failed, hr (0x%x)",hr));
     3870        else
     3871            Assert(pD3D9Surf);
     3872    }
     3873
     3874    if (SUCCEEDED(hr))
     3875    {
     3876        hr = pDevice9If->SetDepthStencilSurface(pD3D9Surf);
     3877        if (SUCCEEDED(hr))
     3878        {
     3879            pDevice->pDepthStencilRc = pRc;
     3880        }
     3881        else
     3882            WARN(("VBoxD3DIfSurfGet failed, hr (0x%x)",hr));
     3883
     3884        if (pD3D9Surf)
     3885            pD3D9Surf->Release();
     3886    }
     3887
     3888    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
     3889    return hr;
     3890}
     3891
     3892HRESULT APIENTRY GaDdiGenerateMipSubLevels(HANDLE hDevice, const D3DDDIARG_GENERATEMIPSUBLEVELS *pData)
     3893{
     3894    VBOXVDBG_BREAK_DDI();
     3895
     3896    RT_NOREF(pData);
     3897
     3898    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3899
     3900    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3901    RT_NOREF(pDevice);
     3902
     3903    /// @todo Not implemented.
     3904    AssertFailed();
     3905
     3906    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3907    return E_NOTIMPL;
     3908}
     3909
     3910HRESULT APIENTRY GaDdiCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE *pData)
     3911{
     3912    VBOXVDBG_BREAK_DDI();
     3913
     3914    RT_NOREF(pData);
     3915
     3916    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3917
     3918    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3919    RT_NOREF(pDevice);
     3920
     3921    /// @todo Not implemented.
     3922    AssertFailed();
     3923
     3924    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3925    return E_NOTIMPL;
     3926}
     3927
     3928HRESULT APIENTRY GaDdiDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
     3929{
     3930    VBOXVDBG_BREAK_DDI();
     3931
     3932    RT_NOREF(hDecodeDevice);
     3933
     3934    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3935
     3936    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3937    RT_NOREF(pDevice);
     3938
     3939    /// @todo Not implemented.
     3940    AssertFailed();
     3941
     3942    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3943    return E_NOTIMPL;
     3944}
     3945
     3946HRESULT APIENTRY GaDdiSetDecodeRenderTarget(HANDLE hDevice, const D3DDDIARG_SETDECODERENDERTARGET *pData)
     3947{
     3948    VBOXVDBG_BREAK_DDI();
     3949
     3950    RT_NOREF(pData);
     3951
     3952    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3953
     3954    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3955    RT_NOREF(pDevice);
     3956
     3957    /// @todo Not implemented.
     3958    AssertFailed();
     3959
     3960    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3961    return E_NOTIMPL;
     3962}
     3963
     3964HRESULT APIENTRY GaDdiDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
     3965{
     3966    VBOXVDBG_BREAK_DDI();
     3967
     3968    RT_NOREF(pData);
     3969
     3970    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3971
     3972    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3973    RT_NOREF(pDevice);
     3974
     3975    /// @todo Not implemented.
     3976    AssertFailed();
     3977
     3978    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3979    return E_NOTIMPL;
     3980}
     3981
     3982HRESULT APIENTRY GaDdiDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
     3983{
     3984    VBOXVDBG_BREAK_DDI();
     3985
     3986    RT_NOREF(pData);
     3987
     3988    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3989
     3990    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     3991    RT_NOREF(pDevice);
     3992
     3993    /// @todo Not implemented.
     3994    AssertFailed();
     3995
     3996    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     3997    return E_NOTIMPL;
     3998}
     3999
     4000HRESULT APIENTRY GaDdiDecodeExecute(HANDLE hDevice, const D3DDDIARG_DECODEEXECUTE *pData)
     4001{
     4002    VBOXVDBG_BREAK_DDI();
     4003
     4004    RT_NOREF(pData);
     4005
     4006    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4007
     4008    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4009    RT_NOREF(pDevice);
     4010
     4011    /// @todo Not implemented.
     4012    AssertFailed();
     4013
     4014    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4015    return E_NOTIMPL;
     4016}
     4017
     4018HRESULT APIENTRY GaDdiDecodeExtensionExecute(HANDLE hDevice, const D3DDDIARG_DECODEEXTENSIONEXECUTE *pData)
     4019{
     4020    VBOXVDBG_BREAK_DDI();
     4021
     4022    RT_NOREF(pData);
     4023
     4024    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4025
     4026    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4027    RT_NOREF(pDevice);
     4028
     4029    /// @todo Not implemented.
     4030    AssertFailed();
     4031
     4032    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4033    return E_NOTIMPL;
     4034}
     4035
     4036HRESULT APIENTRY GaDdiCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE *pData)
     4037{
     4038    VBOXVDBG_BREAK_DDI();
     4039
     4040    RT_NOREF(pData);
     4041
     4042    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4043
     4044    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4045    RT_NOREF(pDevice);
     4046
     4047    /// @todo Not implemented.
     4048    AssertFailed();
     4049
     4050    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4051    return E_NOTIMPL;
     4052}
     4053
     4054HRESULT APIENTRY GaDdiDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
     4055{
     4056    VBOXVDBG_BREAK_DDI();
     4057
     4058    RT_NOREF(hVideoProcessor);
     4059
     4060    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4061
     4062    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4063    RT_NOREF(pDevice);
     4064
     4065    /// @todo Not implemented.
     4066    AssertFailed();
     4067
     4068    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4069    return E_NOTIMPL;
     4070}
     4071
     4072HRESULT APIENTRY GaDdiVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcessor)
     4073{
     4074    VBOXVDBG_BREAK_DDI();
     4075
     4076    RT_NOREF(hVideoProcessor);
     4077
     4078    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4079
     4080    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4081    RT_NOREF(pDevice);
     4082
     4083    /// @todo Not implemented.
     4084    AssertFailed();
     4085
     4086    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4087    return E_NOTIMPL;
     4088}
     4089
     4090HRESULT APIENTRY GaDdiVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
     4091{
     4092    VBOXVDBG_BREAK_DDI();
     4093
     4094    RT_NOREF(pData);
     4095
     4096    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4097
     4098    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4099    RT_NOREF(pDevice);
     4100
     4101    /// @todo Not implemented.
     4102    AssertFailed();
     4103
     4104    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4105    return E_NOTIMPL;
     4106}
     4107
     4108HRESULT APIENTRY GaDdiSetVideoProcessRenderTarget(HANDLE hDevice,
     4109                                                  const D3DDDIARG_SETVIDEOPROCESSRENDERTARGET *pData)
     4110{
     4111    VBOXVDBG_BREAK_DDI();
     4112
     4113    RT_NOREF(pData);
     4114
     4115    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4116
     4117    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4118    RT_NOREF(pDevice);
     4119
     4120    /// @todo Not implemented.
     4121    AssertFailed();
     4122
     4123    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4124    return E_NOTIMPL;
     4125}
     4126
     4127HRESULT APIENTRY GaDdiVideoProcessBlt(HANDLE hDevice, const D3DDDIARG_VIDEOPROCESSBLT *pData)
     4128{
     4129    VBOXVDBG_BREAK_DDI();
     4130
     4131    RT_NOREF(pData);
     4132
     4133    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4134
     4135    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4136    RT_NOREF(pDevice);
     4137
     4138    /// @todo Not implemented.
     4139    AssertFailed();
     4140
     4141    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4142    return E_NOTIMPL;
     4143}
     4144
     4145HRESULT APIENTRY GaDdiCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE *pData)
     4146{
     4147    VBOXVDBG_BREAK_DDI();
     4148
     4149    RT_NOREF(pData);
     4150
     4151    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4152
     4153    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4154    RT_NOREF(pDevice);
     4155
     4156    /// @todo Not implemented.
     4157    AssertFailed();
     4158
     4159    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4160    return E_NOTIMPL;
     4161}
     4162
     4163HRESULT APIENTRY GaDdiDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
     4164{
     4165    VBOXVDBG_BREAK_DDI();
     4166
     4167    RT_NOREF(hExtension);
     4168
     4169    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4170
     4171    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4172    RT_NOREF(pDevice);
     4173
     4174    /// @todo Not implemented.
     4175    AssertFailed();
     4176
     4177    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4178    return E_NOTIMPL;
     4179}
     4180
     4181HRESULT APIENTRY GaDdiExtensionExecute(HANDLE hDevice, const D3DDDIARG_EXTENSIONEXECUTE *pData)
     4182{
     4183    VBOXVDBG_BREAK_DDI();
     4184
     4185    RT_NOREF(pData);
     4186
     4187    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4188
     4189    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4190    RT_NOREF(pDevice);
     4191
     4192    /// @todo Not implemented.
     4193    AssertFailed();
     4194
     4195    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4196    return E_NOTIMPL;
     4197}
     4198
     4199AssertCompile(sizeof(RECT) == sizeof(D3DDDIRECT));
     4200AssertCompile(RT_SIZEOFMEMB(RECT, left)   == RT_SIZEOFMEMB(D3DDDIRECT, left));
     4201AssertCompile(RT_SIZEOFMEMB(RECT, right)  == RT_SIZEOFMEMB(D3DDDIRECT, right));
     4202AssertCompile(RT_SIZEOFMEMB(RECT, top)    == RT_SIZEOFMEMB(D3DDDIRECT, top));
     4203AssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DDDIRECT, bottom));
     4204AssertCompile(RT_OFFSETOF(RECT, left)   == RT_OFFSETOF(D3DDDIRECT, left));
     4205AssertCompile(RT_OFFSETOF(RECT, right)  == RT_OFFSETOF(D3DDDIRECT, right));
     4206AssertCompile(RT_OFFSETOF(RECT, top)    == RT_OFFSETOF(D3DDDIRECT, top));
     4207AssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DDDIRECT, bottom));
     4208
     4209HRESULT APIENTRY GaDdiCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY *pData)
     4210{
     4211    VBOXVDBG_BREAK_DDI();
     4212
     4213    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4214
     4215    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4216
     4217    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
     4218    AssertReturn(pData->OverlayInfo.SubResourceIndex < pRc->cAllocations, E_INVALIDARG);
     4219
     4220    HRESULT hr = S_OK;
     4221    PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)RTMemAllocZ(sizeof(VBOXWDDMDISP_OVERLAY));
     4222    Assert(pOverlay);
     4223    if (pOverlay)
     4224    {
     4225        PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
     4226
     4227        VBOXWDDM_OVERLAY_INFO OurInfo;
     4228        OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
     4229        OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
     4230        OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
     4231        OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
     4232        OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
     4233
     4234        vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
     4235
     4236        Assert(!pAlloc->LockInfo.cLocks);
     4237        vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
     4238
     4239        D3DDDICB_CREATEOVERLAY OverInfo;
     4240        OverInfo.VidPnSourceId = pData->VidPnSourceId;
     4241        OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
     4242        Assert(pAlloc->hAllocation);
     4243        OverInfo.OverlayInfo.DstRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.DstRect);
     4244        OverInfo.OverlayInfo.SrcRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.SrcRect);
     4245        OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
     4246        OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
     4247        OverInfo.hKernelOverlay = NULL; /* <-- out */
     4248
     4249        hr = pDevice->RtCallbacks.pfnCreateOverlayCb(pDevice->hDevice, &OverInfo);
     4250        Assert(hr == S_OK);
     4251        if (hr == S_OK)
     4252        {
     4253            Assert(OverInfo.hKernelOverlay);
     4254            pOverlay->hOverlay = OverInfo.hKernelOverlay;
     4255            pOverlay->VidPnSourceId = pData->VidPnSourceId;
     4256
     4257            Assert(!pAlloc->LockInfo.cLocks);
     4258            if (!pAlloc->LockInfo.cLocks)
     4259            {
     4260                /* we have reported the dirty rect, may clear it if no locks are pending currently */
     4261                vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
     4262            }
     4263
     4264            pData->hOverlay = pOverlay;
     4265        }
     4266        else
     4267        {
     4268            RTMemFree(pOverlay);
     4269        }
     4270    }
     4271    else
     4272        hr = E_OUTOFMEMORY;
     4273
     4274    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4275    return hr;
     4276}
     4277
     4278HRESULT APIENTRY GaDdiUpdateOverlay(HANDLE hDevice, const D3DDDIARG_UPDATEOVERLAY *pData)
     4279{
     4280    VBOXVDBG_BREAK_DDI();
     4281
     4282    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4283
     4284    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4285
     4286    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
     4287    Assert(pRc);
     4288    AssertReturn(pRc->cAllocations > pData->OverlayInfo.SubResourceIndex, E_INVALIDARG);
     4289
     4290    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
     4291
     4292    HRESULT hr = S_OK;
     4293    PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
     4294
     4295    VBOXWDDM_OVERLAY_INFO OurInfo;
     4296    OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
     4297    OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
     4298    OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
     4299    OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
     4300    OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
     4301    vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
     4302
     4303    Assert(!pAlloc->LockInfo.cLocks);
     4304    vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
     4305
     4306    D3DDDICB_UPDATEOVERLAY OverInfo;
     4307    OverInfo.hKernelOverlay = pOverlay->hOverlay;
     4308    OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
     4309    OverInfo.OverlayInfo.DstRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.DstRect);
     4310    OverInfo.OverlayInfo.SrcRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.SrcRect);
     4311    OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
     4312    OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
     4313
     4314    hr = pDevice->RtCallbacks.pfnUpdateOverlayCb(pDevice->hDevice, &OverInfo);
     4315    Assert(hr == S_OK);
     4316    if (hr == S_OK)
     4317    {
     4318        Assert(!pAlloc->LockInfo.cLocks);
     4319        if (!pAlloc->LockInfo.cLocks)
     4320        {
     4321            /* we have reported the dirty rect, may clear it if no locks are pending currently */
     4322            vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
     4323        }
     4324    }
     4325
     4326    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4327    return hr;
     4328}
     4329
     4330HRESULT APIENTRY GaDdiFlipOverlay(HANDLE hDevice, const D3DDDIARG_FLIPOVERLAY *pData)
     4331{
     4332    VBOXVDBG_BREAK_DDI();
     4333
     4334    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4335
     4336    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4337
     4338    PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSource;
     4339    Assert(pRc);
     4340    Assert(pRc->cAllocations > pData->SourceIndex);
     4341
     4342    PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SourceIndex];
     4343
     4344    HRESULT hr = S_OK;
     4345    PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
     4346
     4347    VBOXWDDM_OVERLAYFLIP_INFO OurInfo;
     4348    vboxWddmDirtyRegionClear(&OurInfo.DirtyRegion);
     4349    Assert(!pAlloc->LockInfo.cLocks);
     4350    vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
     4351
     4352    D3DDDICB_FLIPOVERLAY OverInfo;
     4353    OverInfo.hKernelOverlay = pOverlay->hOverlay;
     4354    OverInfo.hSource = pAlloc->hAllocation;
     4355    OverInfo.pPrivateDriverData = &OurInfo;
     4356    OverInfo.PrivateDriverDataSize = sizeof (OurInfo);
     4357
     4358    hr = pDevice->RtCallbacks.pfnFlipOverlayCb(pDevice->hDevice, &OverInfo);
     4359    Assert(hr == S_OK);
     4360    if (hr == S_OK)
     4361    {
     4362        Assert(!pAlloc->LockInfo.cLocks);
     4363        if (!pAlloc->LockInfo.cLocks)
     4364        {
     4365            /* we have reported the dirty rect, may clear it if no locks are pending currently */
     4366            vboxWddmDirtyRegionClear(&pAlloc->DirtyRegion);
     4367        }
     4368    }
     4369
     4370    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4371    return hr;
     4372}
     4373
     4374HRESULT APIENTRY GaDdiGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS *pData)
     4375{
     4376    VBOXVDBG_BREAK_DDI();
     4377
     4378    RT_NOREF(pData);
     4379
     4380    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4381
     4382    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4383    RT_NOREF(pDevice);
     4384
     4385    /// @todo Not implemented.
     4386    AssertFailed();
     4387
     4388    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4389    return E_NOTIMPL;
     4390}
     4391
     4392HRESULT APIENTRY GaDdiSetOverlayColorControls(HANDLE hDevice, const D3DDDIARG_SETOVERLAYCOLORCONTROLS *pData)
     4393{
     4394    VBOXVDBG_BREAK_DDI();
     4395
     4396    RT_NOREF(pData);
     4397
     4398    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4399
     4400    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4401    RT_NOREF(pDevice);
     4402
     4403    /// @todo Not implemented.
     4404    AssertFailed();
     4405
     4406    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4407    return E_NOTIMPL;
     4408}
     4409
     4410HRESULT APIENTRY GaDdiDestroyOverlay(HANDLE hDevice, const D3DDDIARG_DESTROYOVERLAY *pData)
     4411{
     4412    VBOXVDBG_BREAK_DDI();
     4413
     4414    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4415
     4416    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4417
     4418    PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
     4419
     4420    D3DDDICB_DESTROYOVERLAY OverInfo;
     4421    OverInfo.hKernelOverlay = pOverlay->hOverlay;
     4422
     4423    HRESULT hr = pDevice->RtCallbacks.pfnDestroyOverlayCb(pDevice->hDevice, &OverInfo);
     4424    Assert(hr == S_OK);
     4425    if (hr == S_OK)
     4426    {
     4427        RTMemFree(pOverlay);
     4428    }
     4429
     4430    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4431    return hr;
     4432}
     4433
     4434HRESULT APIENTRY GaDdiQueryResourceResidency(HANDLE hDevice, const D3DDDIARG_QUERYRESOURCERESIDENCY *pData)
     4435{
     4436    VBOXVDBG_BREAK_DDI();
     4437
     4438    RT_NOREF(pData);
     4439
     4440    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4441
     4442    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4443    RT_NOREF(pDevice);
     4444
     4445    HRESULT hr = S_OK;
     4446    /** @todo check residency for the "real" allocations */
     4447
     4448    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4449    return hr;
     4450}
     4451
     4452HRESULT APIENTRY GaDdiGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE *pData)
     4453{
     4454    VBOXVDBG_BREAK_DDI();
     4455
     4456    RT_NOREF(pData);
     4457
     4458    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4459
     4460    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4461    RT_NOREF(pDevice);
     4462
     4463    /// @todo Not implemented.
     4464    AssertFailed();
     4465
     4466    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4467    return E_NOTIMPL;
     4468}
     4469
     4470HRESULT APIENTRY GaDdiCaptureToSysMem(HANDLE hDevice, const D3DDDIARG_CAPTURETOSYSMEM *pData)
     4471{
     4472    VBOXVDBG_BREAK_DDI();
     4473
     4474    RT_NOREF(pData);
     4475
     4476    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4477
     4478    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4479    RT_NOREF(pDevice);
     4480
     4481    /// @todo Not implemented.
     4482    AssertFailed();
     4483
     4484    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4485    return E_NOTIMPL;
     4486}
     4487
     4488HRESULT APIENTRY GaDdiDrawRectPatch(HANDLE hDevice, const D3DDDIARG_DRAWRECTPATCH *pData,
     4489                                    const D3DDDIRECTPATCH_INFO *pInfo, const FLOAT *pPatch)
     4490{
     4491    VBOXVDBG_BREAK_DDI();
     4492
     4493    RT_NOREF3(pData, pInfo, pPatch);
     4494
     4495    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4496
     4497    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4498    RT_NOREF(pDevice);
     4499
     4500    /// @todo Not implemented.
     4501    AssertFailed();
     4502
     4503    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4504    return E_NOTIMPL;
     4505}
     4506
     4507HRESULT APIENTRY GaDdiDrawTriPatch(HANDLE hDevice, const D3DDDIARG_DRAWTRIPATCH *pData,
     4508                                   const D3DDDITRIPATCH_INFO *pInfo, const FLOAT *pPatch)
     4509{
     4510    VBOXVDBG_BREAK_DDI();
     4511
     4512    RT_NOREF3(pData, pInfo, pPatch);
     4513
     4514    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4515
     4516    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4517    RT_NOREF(pDevice);
     4518
     4519    /// @todo Not implemented.
     4520    AssertFailed();
     4521
     4522    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4523    return E_NOTIMPL;
     4524}
     4525
     4526HRESULT APIENTRY GaDdiDestroyDevice(HANDLE hDevice)
     4527{
     4528    VBOXVDBG_BREAK_DDI();
     4529
     4530    vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4531
     4532    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
     4533    AssertReturn(pDevice->pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA, E_FAIL);
     4534
     4535    PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
     4536    if (VBOXDISPMODE_IS_3D(pAdapter))
     4537    {
     4538        if (pDevice->pDevice9If)
     4539        {
     4540            pDevice->pDevice9If->Release();
     4541            pDevice->pDevice9If = NULL;
     4542        }
     4543    }
     4544
     4545    RTMemFree(pDevice);
     4546
     4547    vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
     4548    return S_OK;
     4549}
     4550
     4551HRESULT APIENTRY GaDdiAdapterCreateDevice(HANDLE hAdapter, D3DDDIARG_CREATEDEVICE *pCreateData)
     4552{
     4553    VBOXVDBG_BREAK_DDI();
     4554
     4555    HRESULT hr = S_OK;
     4556
     4557    vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
     4558
     4559    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
     4560    AssertReturn(pAdapter->enmHwType == VBOXVIDEO_HWTYPE_VMSVGA, E_INVALIDARG);
     4561
     4562    PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(RT_UOFFSETOF_DYN(VBOXWDDMDISP_DEVICE,
     4563                                                                                      apRTs[pAdapter->D3D.cMaxSimRTs]));
     4564    if (pDevice)
     4565    {
     4566        /*
     4567         * Initialize our device object.
     4568         */
     4569        pDevice->cRTs                    = pAdapter->D3D.cMaxSimRTs;
     4570        pDevice->pfnCreateDirect3DDevice = GaD3DIfDeviceCreate;
     4571        pDevice->pfnCreateSharedPrimary  = GaD3DIfCreateSharedPrimary;
     4572        pDevice->hDevice                 = pCreateData->hDevice;
     4573        pDevice->pAdapter                = pAdapter;
     4574        pDevice->u32IfVersion            = pCreateData->Interface;
     4575        pDevice->uRtVersion              = pCreateData->Version;
     4576        pDevice->RtCallbacks             = *pCreateData->pCallbacks;
     4577        pDevice->pvCmdBuffer             = pCreateData->pCommandBuffer;
     4578        pDevice->cbCmdBuffer             = pCreateData->CommandBufferSize;
     4579        pDevice->fFlags                  = pCreateData->Flags;
     4580
     4581        /* Set Viewport to some default values */
     4582        pDevice->ViewPort.X      = 0;
     4583        pDevice->ViewPort.Y      = 0;
     4584        pDevice->ViewPort.Width  = 1;
     4585        pDevice->ViewPort.Height = 1;
     4586        pDevice->ViewPort.MinZ   = 0.;
     4587        pDevice->ViewPort.MaxZ   = 1.;
     4588
     4589        /*
     4590         * Set data for the DX runtime.
     4591         */
     4592        pCreateData->hDevice = pDevice;
     4593
     4594        pCreateData->pDeviceFuncs->pfnSetRenderState            = GaDdiSetRenderState;
     4595        pCreateData->pDeviceFuncs->pfnUpdateWInfo               = GaDdiUpdateWInfo;
     4596        pCreateData->pDeviceFuncs->pfnValidateDevice            = GaDdiValidateDevice;
     4597        pCreateData->pDeviceFuncs->pfnSetTextureStageState      = GaDdiSetTextureStageState;
     4598        pCreateData->pDeviceFuncs->pfnSetTexture                = GaDdiSetTexture;
     4599        pCreateData->pDeviceFuncs->pfnSetPixelShader            = GaDdiSetPixelShader;
     4600        pCreateData->pDeviceFuncs->pfnSetPixelShaderConst       = GaDdiSetPixelShaderConst;
     4601        pCreateData->pDeviceFuncs->pfnSetStreamSourceUm         = GaDdiSetStreamSourceUm;
     4602        pCreateData->pDeviceFuncs->pfnSetIndices                = GaDdiSetIndices;
     4603        pCreateData->pDeviceFuncs->pfnSetIndicesUm              = GaDdiSetIndicesUm;
     4604        pCreateData->pDeviceFuncs->pfnDrawPrimitive             = GaDdiDrawPrimitive;
     4605        pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive      = GaDdiDrawIndexedPrimitive;
     4606        pCreateData->pDeviceFuncs->pfnDrawRectPatch             = GaDdiDrawRectPatch;
     4607        pCreateData->pDeviceFuncs->pfnDrawTriPatch              = GaDdiDrawTriPatch;
     4608        pCreateData->pDeviceFuncs->pfnDrawPrimitive2            = GaDdiDrawPrimitive2;
     4609        pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2     = GaDdiDrawIndexedPrimitive2;
     4610        pCreateData->pDeviceFuncs->pfnVolBlt                    = GaDdiVolBlt;
     4611        pCreateData->pDeviceFuncs->pfnBufBlt                    = GaDdiBufBlt;
     4612        pCreateData->pDeviceFuncs->pfnTexBlt                    = GaDdiTexBlt;
     4613        pCreateData->pDeviceFuncs->pfnStateSet                  = GaDdiStateSet;
     4614        pCreateData->pDeviceFuncs->pfnSetPriority               = GaDdiSetPriority;
     4615        pCreateData->pDeviceFuncs->pfnClear                     = GaDdiClear;
     4616        pCreateData->pDeviceFuncs->pfnUpdatePalette             = GaDdiUpdatePalette;
     4617        pCreateData->pDeviceFuncs->pfnSetPalette                = GaDdiSetPalette;
     4618        pCreateData->pDeviceFuncs->pfnSetVertexShaderConst      = GaDdiSetVertexShaderConst;
     4619        pCreateData->pDeviceFuncs->pfnMultiplyTransform         = GaDdiMultiplyTransform;
     4620        pCreateData->pDeviceFuncs->pfnSetTransform              = GaDdiSetTransform;
     4621        pCreateData->pDeviceFuncs->pfnSetViewport               = GaDdiSetViewport;
     4622        pCreateData->pDeviceFuncs->pfnSetZRange                 = GaDdiSetZRange;
     4623        pCreateData->pDeviceFuncs->pfnSetMaterial               = GaDdiSetMaterial;
     4624        pCreateData->pDeviceFuncs->pfnSetLight                  = GaDdiSetLight;
     4625        pCreateData->pDeviceFuncs->pfnCreateLight               = GaDdiCreateLight;
     4626        pCreateData->pDeviceFuncs->pfnDestroyLight              = GaDdiDestroyLight;
     4627        pCreateData->pDeviceFuncs->pfnSetClipPlane              = GaDdiSetClipPlane;
     4628        pCreateData->pDeviceFuncs->pfnGetInfo                   = GaDdiGetInfo;
     4629        pCreateData->pDeviceFuncs->pfnLock                      = GaDdiLock;
     4630        pCreateData->pDeviceFuncs->pfnUnlock                    = GaDdiUnlock;
     4631        pCreateData->pDeviceFuncs->pfnCreateResource            = GaDdiCreateResource;
     4632        pCreateData->pDeviceFuncs->pfnDestroyResource           = GaDdiDestroyResource;
     4633        pCreateData->pDeviceFuncs->pfnSetDisplayMode            = GaDdiSetDisplayMode;
     4634        pCreateData->pDeviceFuncs->pfnPresent                   = GaDdiPresent;
     4635        pCreateData->pDeviceFuncs->pfnFlush                     = GaDdiFlush;
     4636        pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc    = GaDdiCreateVertexShaderFunc;
     4637        pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc    = GaDdiDeleteVertexShaderFunc;
     4638        pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc       = GaDdiSetVertexShaderFunc;
     4639        pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl    = GaDdiCreateVertexShaderDecl;
     4640        pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl    = GaDdiDeleteVertexShaderDecl;
     4641        pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl       = GaDdiSetVertexShaderDecl;
     4642        pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI     = GaDdiSetVertexShaderConstI;
     4643        pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB     = GaDdiSetVertexShaderConstB;
     4644        pCreateData->pDeviceFuncs->pfnSetScissorRect            = GaDdiSetScissorRect;
     4645        pCreateData->pDeviceFuncs->pfnSetStreamSource           = GaDdiSetStreamSource;
     4646        pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq       = GaDdiSetStreamSourceFreq;
     4647        pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono  = GaDdiSetConvolutionKernelMono;
     4648        pCreateData->pDeviceFuncs->pfnComposeRects              = GaDdiComposeRects;
     4649        pCreateData->pDeviceFuncs->pfnBlt                       = GaDdiBlt;
     4650        pCreateData->pDeviceFuncs->pfnColorFill                 = GaDdiColorFill;
     4651        pCreateData->pDeviceFuncs->pfnDepthFill                 = GaDdiDepthFill;
     4652        pCreateData->pDeviceFuncs->pfnCreateQuery               = GaDdiCreateQuery;
     4653        pCreateData->pDeviceFuncs->pfnDestroyQuery              = GaDdiDestroyQuery;
     4654        pCreateData->pDeviceFuncs->pfnIssueQuery                = GaDdiIssueQuery;
     4655        pCreateData->pDeviceFuncs->pfnGetQueryData              = GaDdiGetQueryData;
     4656        pCreateData->pDeviceFuncs->pfnSetRenderTarget           = GaDdiSetRenderTarget;
     4657        pCreateData->pDeviceFuncs->pfnSetDepthStencil           = GaDdiSetDepthStencil;
     4658        pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels      = GaDdiGenerateMipSubLevels;
     4659        pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI      = GaDdiSetPixelShaderConstI;
     4660        pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB      = GaDdiSetPixelShaderConstB;
     4661        pCreateData->pDeviceFuncs->pfnCreatePixelShader         = GaDdiCreatePixelShader;
     4662        pCreateData->pDeviceFuncs->pfnDeletePixelShader         = GaDdiDeletePixelShader;
     4663        pCreateData->pDeviceFuncs->pfnCreateDecodeDevice        = GaDdiCreateDecodeDevice;
     4664        pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice       = GaDdiDestroyDecodeDevice;
     4665        pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget     = GaDdiSetDecodeRenderTarget;
     4666        pCreateData->pDeviceFuncs->pfnDecodeBeginFrame          = GaDdiDecodeBeginFrame;
     4667        pCreateData->pDeviceFuncs->pfnDecodeEndFrame            = GaDdiDecodeEndFrame;
     4668        pCreateData->pDeviceFuncs->pfnDecodeExecute             = GaDdiDecodeExecute;
     4669        pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute    = GaDdiDecodeExtensionExecute;
     4670        pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice  = GaDdiCreateVideoProcessDevice;
     4671        pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = GaDdiDestroyVideoProcessDevice;
     4672        pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame    = GaDdiVideoProcessBeginFrame;
     4673        pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame      = GaDdiVideoProcessEndFrame;
     4674        pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = GaDdiSetVideoProcessRenderTarget;
     4675        pCreateData->pDeviceFuncs->pfnVideoProcessBlt           = GaDdiVideoProcessBlt;
     4676        pCreateData->pDeviceFuncs->pfnCreateExtensionDevice     = GaDdiCreateExtensionDevice;
     4677        pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice    = GaDdiDestroyExtensionDevice;
     4678        pCreateData->pDeviceFuncs->pfnExtensionExecute          = GaDdiExtensionExecute;
     4679        pCreateData->pDeviceFuncs->pfnCreateOverlay             = GaDdiCreateOverlay;
     4680        pCreateData->pDeviceFuncs->pfnUpdateOverlay             = GaDdiUpdateOverlay;
     4681        pCreateData->pDeviceFuncs->pfnFlipOverlay               = GaDdiFlipOverlay;
     4682        pCreateData->pDeviceFuncs->pfnGetOverlayColorControls   = GaDdiGetOverlayColorControls;
     4683        pCreateData->pDeviceFuncs->pfnSetOverlayColorControls   = GaDdiSetOverlayColorControls;
     4684        pCreateData->pDeviceFuncs->pfnDestroyOverlay            = GaDdiDestroyOverlay;
     4685        pCreateData->pDeviceFuncs->pfnDestroyDevice             = GaDdiDestroyDevice;
     4686        pCreateData->pDeviceFuncs->pfnQueryResourceResidency    = GaDdiQueryResourceResidency;
     4687        pCreateData->pDeviceFuncs->pfnOpenResource              = GaDdiOpenResource;
     4688        pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = GaDdiGetCaptureAllocationHandle;
     4689        pCreateData->pDeviceFuncs->pfnCaptureToSysMem           = GaDdiCaptureToSysMem;
     4690        // pCreateData->pDeviceFuncs->pfnLockAsync                 = NULL; /* Optional. */
     4691        // pCreateData->pDeviceFuncs->pfnUnlockAsync               = NULL; /* Optional. */
     4692        // pCreateData->pDeviceFuncs->pfnRename                    = NULL; /* Optional. */
     4693
     4694    }
     4695    else
     4696    {
     4697        vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
     4698        hr = E_OUTOFMEMORY;
     4699    }
     4700
     4701#ifdef VBOX_WITH_MESA3D_D3DTEST
     4702    /* Built-in gallium backend test for early development stages.
     4703     * Use it only with kernel debugger attached to the VM.
     4704     */
     4705    extern void GaDrvTest(IGalliumStack *pGalliumStack, PVBOXWDDMDISP_DEVICE pDevice);
     4706    if (SUCCEEDED(hr))
     4707       GaDrvTest(pAdapter->D3D.pGalliumStack, pDevice);
     4708#endif
     4709
     4710    vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
     4711    return hr;
     4712}
     4713
     4714HRESULT APIENTRY GaDdiAdapterCloseAdapter(IN HANDLE hAdapter)
     4715{
     4716    VBOXVDBG_BREAK_DDI();
     4717
     4718    vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
     4719
     4720    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
     4721    if (VBOXDISPMODE_IS_3D(pAdapter))
     4722    {
     4723        VBoxDispD3DGlobalClose(&pAdapter->D3D, &pAdapter->Formats);
     4724    }
     4725#ifdef VBOX_WITH_VIDEOHWACCEL
     4726    else
     4727    {
     4728        VBoxDispD3DGlobal2DFormatsTerm(pAdapter);
     4729    }
     4730#endif
     4731
     4732    RTMemFree(pAdapter);
     4733
     4734    vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
     4735
     4736    return S_OK;
     4737}
     4738
     4739static D3DDDIQUERYTYPE const gVBoxQueryTypes[] = {
     4740        D3DDDIQUERYTYPE_EVENT,
     4741        D3DDDIQUERYTYPE_OCCLUSION
     4742};
     4743
     4744#ifdef VBOX_WITH_VIDEOHWACCEL
     4745static bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
     4746{
     4747    for (uint32_t i = 0; i < pAdapter->cHeads; ++i)
     4748    {
     4749        VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
     4750        if (   (pSettings->fFlags & VBOXVHWA_F_ENABLED)
     4751            && (   (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
     4752                || (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)))
     4753            return true;
     4754    }
     4755    return false;
     4756}
     4757#endif
     4758
     4759HRESULT APIENTRY GaDdiAdapterGetCaps(HANDLE hAdapter, const D3DDDIARG_GETCAPS *pData)
     4760{
     4761    VBOXVDBG_BREAK_DDI();
     4762
     4763    vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
     4764
     4765    HRESULT hr = S_OK;
     4766    PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
     4767
     4768    switch (pData->Type)
     4769    {
     4770        case D3DDDICAPS_DDRAW:
     4771        {
     4772            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
     4773            Assert(pData->DataSize == sizeof(DDRAW_CAPS));
     4774            if (pData->DataSize >= sizeof(DDRAW_CAPS))
     4775            {
     4776                memset(pData->pData, 0, sizeof(DDRAW_CAPS));
     4777#ifdef VBOX_WITH_VIDEOHWACCEL
     4778                if (!VBOXDISPMODE_IS_3D(pAdapter))
     4779                {
     4780                    if (vboxVhwaHasCKeying(pAdapter))
     4781                    {
     4782                        DDRAW_CAPS *pCaps = (DDRAW_CAPS*)pData->pData;
     4783                        pCaps->Caps |= DDRAW_CAPS_COLORKEY;
     4784//                        pCaps->Caps2 |= DDRAW_CAPS2_FLIPNOVSYNC;
     4785                    }
     4786                }
     4787                else
     4788                {
     4789                    WARN(("D3DDDICAPS_DDRAW query for D3D mode!"));
     4790                }
     4791#endif
     4792            }
     4793            else
     4794                hr = E_INVALIDARG;
     4795            break;
     4796        }
     4797
     4798        case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
     4799        {
     4800            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
     4801            Assert(pData->DataSize == sizeof(DDRAW_MODE_SPECIFIC_CAPS));
     4802            if (pData->DataSize >= sizeof(DDRAW_MODE_SPECIFIC_CAPS))
     4803            {
     4804                DDRAW_MODE_SPECIFIC_CAPS *pCaps = (DDRAW_MODE_SPECIFIC_CAPS *)pData->pData;
     4805                /* Do not overwrite the first "Head" field, zero starting with the one following "Head", i.e. Caps. */
     4806                memset(&pCaps->Caps, 0, sizeof(DDRAW_MODE_SPECIFIC_CAPS) - RT_UOFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
     4807#ifdef VBOX_WITH_VIDEOHWACCEL
     4808                if (!VBOXDISPMODE_IS_3D(pAdapter))
     4809                {
     4810                    VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
     4811                    if (pSettings->fFlags & VBOXVHWA_F_ENABLED)
     4812                    {
     4813                        pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
     4814
     4815                        if (pSettings->fFlags & VBOXVHWA_F_CKEY_DST)
     4816                        {
     4817                            pCaps->CKeyCaps |= MODE_CKEYCAPS_DESTOVERLAY
     4818                                    | MODE_CKEYCAPS_DESTOVERLAYYUV /* ?? */
     4819                                    ;
     4820                        }
     4821
     4822                        if (pSettings->fFlags & VBOXVHWA_F_CKEY_SRC)
     4823                        {
     4824                            pCaps->CKeyCaps |= MODE_CKEYCAPS_SRCOVERLAY
     4825                                    | MODE_CKEYCAPS_SRCOVERLAYCLRSPACE /* ?? */
     4826                                    | MODE_CKEYCAPS_SRCOVERLAYCLRSPACEYUV /* ?? */
     4827                                    | MODE_CKEYCAPS_SRCOVERLAYYUV /* ?? */
     4828                                    ;
     4829                        }
     4830
     4831                        pCaps->FxCaps = MODE_FXCAPS_OVERLAYSHRINKX
     4832                                | MODE_FXCAPS_OVERLAYSHRINKY
     4833                                | MODE_FXCAPS_OVERLAYSTRETCHX
     4834                                | MODE_FXCAPS_OVERLAYSTRETCHY;
     4835
     4836
     4837                        pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
     4838                        pCaps->MinOverlayStretch = 1;
     4839                        pCaps->MaxOverlayStretch = 32000;
     4840                    }
     4841                }
     4842                else
     4843                {
     4844                    WARN(("D3DDDICAPS_DDRAW_MODE_SPECIFIC query for D3D mode!"));
     4845                }
     4846#endif
     4847            }
     4848            else
     4849                hr = E_INVALIDARG;
     4850            break;
     4851        }
     4852
     4853        case D3DDDICAPS_GETFORMATCOUNT:
     4854            *((uint32_t*)pData->pData) = pAdapter->Formats.cFormstOps;
     4855            break;
     4856
     4857        case D3DDDICAPS_GETFORMATDATA:
     4858            Assert(pData->DataSize == pAdapter->Formats.cFormstOps * sizeof(FORMATOP));
     4859            memcpy(pData->pData, pAdapter->Formats.paFormstOps, pAdapter->Formats.cFormstOps * sizeof(FORMATOP));
     4860            break;
     4861
     4862        case D3DDDICAPS_GETD3DQUERYCOUNT:
     4863            *((uint32_t*)pData->pData) = RT_ELEMENTS(gVBoxQueryTypes);
     4864            break;
     4865
     4866        case D3DDDICAPS_GETD3DQUERYDATA:
     4867            Assert(pData->DataSize == RT_ELEMENTS(gVBoxQueryTypes) * sizeof(D3DDDIQUERYTYPE));
     4868            memcpy(pData->pData, gVBoxQueryTypes, RT_ELEMENTS(gVBoxQueryTypes) * sizeof(D3DDDIQUERYTYPE));
     4869            break;
     4870
     4871        case D3DDDICAPS_GETD3D3CAPS:
     4872            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
     4873            Assert(pData->DataSize == sizeof(D3DHAL_GLOBALDRIVERDATA));
     4874            if (pData->DataSize >= sizeof(D3DHAL_GLOBALDRIVERDATA))
     4875            {
     4876                D3DHAL_GLOBALDRIVERDATA *pCaps = (D3DHAL_GLOBALDRIVERDATA *)pData->pData;
     4877                memset (pCaps, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
     4878                pCaps->dwSize = sizeof (D3DHAL_GLOBALDRIVERDATA);
     4879                pCaps->hwCaps.dwSize = sizeof (D3DDEVICEDESC_V1);
     4880                pCaps->hwCaps.dwFlags = D3DDD_COLORMODEL
     4881                        | D3DDD_DEVCAPS
     4882                        | D3DDD_DEVICERENDERBITDEPTH;
     4883
     4884                pCaps->hwCaps.dcmColorModel = D3DCOLOR_RGB;
     4885                pCaps->hwCaps.dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP
     4886//                        | D3DDEVCAPS_DRAWPRIMTLVERTEX
     4887                        | D3DDEVCAPS_EXECUTESYSTEMMEMORY
     4888                        | D3DDEVCAPS_EXECUTEVIDEOMEMORY
     4889//                        | D3DDEVCAPS_FLOATTLVERTEX
     4890                        | D3DDEVCAPS_HWRASTERIZATION
     4891//                        | D3DDEVCAPS_HWTRANSFORMANDLIGHT
     4892//                        | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY
     4893//                        | D3DDEVCAPS_TEXTUREVIDEOMEMORY
     4894                        ;
     4895                pCaps->hwCaps.dtcTransformCaps.dwSize = sizeof (D3DTRANSFORMCAPS);
     4896                pCaps->hwCaps.dtcTransformCaps.dwCaps = 0;
     4897                pCaps->hwCaps.bClipping = FALSE;
     4898                pCaps->hwCaps.dlcLightingCaps.dwSize = sizeof (D3DLIGHTINGCAPS);
     4899                pCaps->hwCaps.dlcLightingCaps.dwCaps = 0;
     4900                pCaps->hwCaps.dlcLightingCaps.dwLightingModel = 0;
     4901                pCaps->hwCaps.dlcLightingCaps.dwNumLights = 0;
     4902                pCaps->hwCaps.dpcLineCaps.dwSize = sizeof (D3DPRIMCAPS);
     4903                pCaps->hwCaps.dpcLineCaps.dwMiscCaps = 0;
     4904                pCaps->hwCaps.dpcLineCaps.dwRasterCaps = 0;
     4905                pCaps->hwCaps.dpcLineCaps.dwZCmpCaps = 0;
     4906                pCaps->hwCaps.dpcLineCaps.dwSrcBlendCaps = 0;
     4907                pCaps->hwCaps.dpcLineCaps.dwDestBlendCaps = 0;
     4908                pCaps->hwCaps.dpcLineCaps.dwAlphaCmpCaps = 0;
     4909                pCaps->hwCaps.dpcLineCaps.dwShadeCaps = 0;
     4910                pCaps->hwCaps.dpcLineCaps.dwTextureCaps = 0;
     4911                pCaps->hwCaps.dpcLineCaps.dwTextureFilterCaps = 0;
     4912                pCaps->hwCaps.dpcLineCaps.dwTextureBlendCaps = 0;
     4913                pCaps->hwCaps.dpcLineCaps.dwTextureAddressCaps = 0;
     4914                pCaps->hwCaps.dpcLineCaps.dwStippleWidth = 0;
     4915                pCaps->hwCaps.dpcLineCaps.dwStippleHeight = 0;
     4916
     4917                pCaps->hwCaps.dpcTriCaps.dwSize = sizeof (D3DPRIMCAPS);
     4918                pCaps->hwCaps.dpcTriCaps.dwMiscCaps = 0;
     4919                pCaps->hwCaps.dpcTriCaps.dwRasterCaps = 0;
     4920                pCaps->hwCaps.dpcTriCaps.dwZCmpCaps = 0;
     4921                pCaps->hwCaps.dpcTriCaps.dwSrcBlendCaps = 0;
     4922                pCaps->hwCaps.dpcTriCaps.dwDestBlendCaps = 0;
     4923                pCaps->hwCaps.dpcTriCaps.dwAlphaCmpCaps = 0;
     4924                pCaps->hwCaps.dpcTriCaps.dwShadeCaps = 0;
     4925                pCaps->hwCaps.dpcTriCaps.dwTextureCaps = 0;
     4926                pCaps->hwCaps.dpcTriCaps.dwTextureFilterCaps = 0;
     4927                pCaps->hwCaps.dpcTriCaps.dwTextureBlendCaps = 0;
     4928                pCaps->hwCaps.dpcTriCaps.dwTextureAddressCaps = 0;
     4929                pCaps->hwCaps.dpcTriCaps.dwStippleWidth = 0;
     4930                pCaps->hwCaps.dpcTriCaps.dwStippleHeight = 0;
     4931                pCaps->hwCaps.dwDeviceRenderBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32;
     4932                pCaps->hwCaps.dwDeviceZBufferBitDepth = 0;
     4933                pCaps->hwCaps.dwMaxBufferSize = 0;
     4934                pCaps->hwCaps.dwMaxVertexCount = 0;
     4935
     4936
     4937                pCaps->dwNumVertices = 0;
     4938                pCaps->dwNumClipVertices = 0;
     4939                pCaps->dwNumTextureFormats = 0;//pAdapter->cSurfDescs;
     4940                pCaps->lpTextureFormats = NULL;//pAdapter->paSurfDescs;
     4941            }
     4942            else
     4943                hr = E_INVALIDARG;
     4944            break;
     4945
     4946        case D3DDDICAPS_GETD3D7CAPS:
     4947            Assert(!VBOXDISPMODE_IS_3D(pAdapter));
     4948            Assert(pData->DataSize == sizeof(D3DHAL_D3DEXTENDEDCAPS));
     4949            if (pData->DataSize >= sizeof(D3DHAL_D3DEXTENDEDCAPS))
     4950            {
     4951                memset(pData->pData, 0, sizeof(D3DHAL_D3DEXTENDEDCAPS));
     4952                D3DHAL_D3DEXTENDEDCAPS *pCaps = (D3DHAL_D3DEXTENDEDCAPS *)pData->pData;
     4953                pCaps->dwSize = sizeof(D3DHAL_D3DEXTENDEDCAPS);
     4954            }
     4955            else
     4956                hr = E_INVALIDARG;
     4957            break;
     4958
     4959        case D3DDDICAPS_GETD3D9CAPS:
     4960        {
     4961            Assert(pData->DataSize == sizeof(D3DCAPS9));
     4962            if (pData->DataSize >= sizeof(D3DCAPS9))
     4963            {
     4964                if (VBOXDISPMODE_IS_3D(pAdapter))
     4965                {
     4966                    memcpy(pData->pData, &pAdapter->D3D.Caps, sizeof(D3DCAPS9));
     4967                }
     4968                else
     4969                {
     4970                    AssertFailed();
     4971                    memset(pData->pData, 0, sizeof (D3DCAPS9));
     4972                }
     4973            }
     4974            else
     4975                hr = E_INVALIDARG;
     4976            break;
     4977        }
     4978
     4979        case D3DDDICAPS_GETD3D8CAPS:
     4980        {
     4981            Assert(pData->DataSize == RT_UOFFSETOF(D3DCAPS9, DevCaps2));
     4982            if (pData->DataSize == RT_UOFFSETOF(D3DCAPS9, DevCaps2))
     4983            {
     4984                if (VBOXDISPMODE_IS_3D(pAdapter))
     4985                {
     4986                    memcpy(pData->pData, &pAdapter->D3D.Caps, RT_UOFFSETOF(D3DCAPS9, DevCaps2));
     4987                }
     4988                else
     4989                {
     4990                    AssertFailed();
     4991                    memset(pData->pData, 0, RT_UOFFSETOF(D3DCAPS9, DevCaps2));
     4992                }
     4993            }
     4994            else
     4995                hr = E_INVALIDARG;
     4996            break;
     4997        }
     4998
     4999        case D3DDDICAPS_GETGAMMARAMPCAPS:
     5000            *((uint32_t*)pData->pData) = 0;
     5001            break;
     5002
     5003        case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
     5004        case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
     5005        case D3DDDICAPS_GETDECODEGUIDCOUNT:
     5006        case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
     5007        case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
     5008        case D3DDDICAPS_GETCONTENTPROTECTIONCAPS:
     5009            if (pData->pData && pData->DataSize)
     5010                memset(pData->pData, 0, pData->DataSize);
     5011            break;
     5012
     5013        case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
     5014        case D3DDDICAPS_GETD3D5CAPS:
     5015        case D3DDDICAPS_GETD3D6CAPS:
     5016        case D3DDDICAPS_GETDECODEGUIDS:
     5017        case D3DDDICAPS_GETDECODERTFORMATCOUNT:
     5018        case D3DDDICAPS_GETDECODERTFORMATS:
     5019        case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
     5020        case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
     5021        case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
     5022        case D3DDDICAPS_GETDECODECONFIGURATIONS:
     5023        case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
     5024        case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
     5025        case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
     5026        case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
     5027        case D3DDDICAPS_GETPROCAMPRANGE:
     5028        case D3DDDICAPS_FILTERPROPERTYRANGE:
     5029        case D3DDDICAPS_GETEXTENSIONGUIDS:
     5030        case D3DDDICAPS_GETEXTENSIONCAPS:
     5031            vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
     5032            AssertFailed();
     5033            if (pData->pData && pData->DataSize)
     5034                memset(pData->pData, 0, pData->DataSize);
     5035            break;
     5036
     5037        default:
     5038            vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
     5039            AssertFailed();
     5040    }
     5041
     5042    vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
     5043    return S_OK;
     5044}

  • trunk/src/VBox/Additions/WINNT/Graphics/Video/disp/wddm/gallium/GaDdi.h

    r76563 r77046  
    2727 * PFND3DDDI_* functions implemented for the Gallium based driver.
    2828 */
     29HRESULT APIENTRY GaDdiSetRenderState(HANDLE hDevice, const D3DDDIARG_RENDERSTATE *pData);
     30HRESULT APIENTRY GaDdiUpdateWInfo(HANDLE hDevice, const D3DDDIARG_WINFO *pData);
     31HRESULT APIENTRY GaDdiValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE *pData);
     32HRESULT APIENTRY GaDdiSetTextureStageState(HANDLE hDevice, const D3DDDIARG_TEXTURESTAGESTATE *pData);
     33HRESULT APIENTRY GaDdiSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture);
     34HRESULT APIENTRY GaDdiSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle);
     35HRESULT APIENTRY GaDdiSetPixelShaderConst(HANDLE hDevice, const D3DDDIARG_SETPIXELSHADERCONST *pData,
     36                                          const FLOAT *pRegisters);
     37HRESULT APIENTRY GaDdiSetStreamSourceUm(HANDLE hDevice, const D3DDDIARG_SETSTREAMSOURCEUM *pData,
     38                                        const VOID *pUMBuffer);
     39HRESULT APIENTRY GaDdiSetIndices(HANDLE hDevice, const D3DDDIARG_SETINDICES *pData);
     40HRESULT APIENTRY GaDdiSetIndicesUm(HANDLE hDevice, UINT IndexSize, const VOID *pUMBuffer);
    2941HRESULT APIENTRY GaDdiDrawPrimitive(HANDLE hDevice, const D3DDDIARG_DRAWPRIMITIVE *pData, const UINT *pFlagBuffer);
    3042HRESULT APIENTRY GaDdiDrawIndexedPrimitive(HANDLE hDevice, const D3DDDIARG_DRAWINDEXEDPRIMITIVE *pData);
     43HRESULT APIENTRY GaDdiDrawRectPatch(HANDLE hDevice, const D3DDDIARG_DRAWRECTPATCH *pData,
     44                                    const D3DDDIRECTPATCH_INFO *pInfo, const FLOAT *pPatch);
     45HRESULT APIENTRY GaDdiDrawTriPatch(HANDLE hDevice, const D3DDDIARG_DRAWTRIPATCH *pData,
     46                                   const D3DDDITRIPATCH_INFO *pInfo, const FLOAT *pPatch);
    3147HRESULT APIENTRY GaDdiDrawPrimitive2(HANDLE hDevice, const D3DDDIARG_DRAWPRIMITIVE2 *pData);
    3248HRESULT APIENTRY GaDdiDrawIndexedPrimitive2(HANDLE hDevice, const D3DDDIARG_DRAWINDEXEDPRIMITIVE2 *pData,
    3349                                            UINT dwIndicesSize, const VOID *pIndexBuffer, const UINT *pFlagBuffer);
    34 HRESULT APIENTRY GaDdiBlt(HANDLE hDevice, const D3DDDIARG_BLT *pData);
     50HRESULT APIENTRY GaDdiVolBlt(HANDLE hDevice, const D3DDDIARG_VOLUMEBLT *pData);
     51HRESULT APIENTRY GaDdiBufBlt(HANDLE hDevice, const D3DDDIARG_BUFFERBLT *pData);
    3552HRESULT APIENTRY GaDdiTexBlt(HANDLE hDevice, const D3DDDIARG_TEXBLT *pData);
    36 HRESULT APIENTRY GaDdiVolBlt(HANDLE hDevice, const D3DDDIARG_VOLUMEBLT *pData);
    37 HRESULT APIENTRY GaDdiFlush(HANDLE hDevice);
    38 HRESULT APIENTRY GaDdiPresent(HANDLE hDevice, const D3DDDIARG_PRESENT *pData);
     53HRESULT APIENTRY GaDdiStateSet(HANDLE hDevice, D3DDDIARG_STATESET *pData);
     54HRESULT APIENTRY GaDdiSetPriority(HANDLE hDevice, const D3DDDIARG_SETPRIORITY *pData);
     55HRESULT APIENTRY GaDdiClear(HANDLE hDevice, const D3DDDIARG_CLEAR *pData, UINT NumRect, const RECT *pRect);
     56HRESULT APIENTRY GaDdiUpdatePalette(HANDLE hDevice, const D3DDDIARG_UPDATEPALETTE *pData,
     57                                    const PALETTEENTRY *pPaletteData);
     58HRESULT APIENTRY GaDdiSetPalette(HANDLE hDevice, const D3DDDIARG_SETPALETTE *pData);
     59HRESULT APIENTRY GaDdiSetVertexShaderConst(HANDLE hDevice, const D3DDDIARG_SETVERTEXSHADERCONST *pData,
     60                                           const VOID *pRegisters);
     61HRESULT APIENTRY GaDdiMultiplyTransform(HANDLE hDevice, const D3DDDIARG_MULTIPLYTRANSFORM *pData);
     62HRESULT APIENTRY GaDdiSetTransform(HANDLE hDevice, const D3DDDIARG_SETTRANSFORM *pData);
     63HRESULT APIENTRY GaDdiSetViewport(HANDLE hDevice, const D3DDDIARG_VIEWPORTINFO *pData);
     64HRESULT APIENTRY GaDdiSetZRange(HANDLE hDevice, const D3DDDIARG_ZRANGE *pData);
     65HRESULT APIENTRY GaDdiSetMaterial(HANDLE hDevice, const D3DDDIARG_SETMATERIAL *pData);
     66HRESULT APIENTRY GaDdiSetLight(HANDLE hDevice, const D3DDDIARG_SETLIGHT *pData, const D3DDDI_LIGHT *pLightProperties);
     67HRESULT APIENTRY GaDdiCreateLight(HANDLE hDevice, const D3DDDIARG_CREATELIGHT *pData);
     68HRESULT APIENTRY GaDdiDestroyLight(HANDLE hDevice, const D3DDDIARG_DESTROYLIGHT *pData);
     69HRESULT APIENTRY GaDdiSetClipPlane(HANDLE hDevice, const D3DDDIARG_SETCLIPPLANE *pData);
     70HRESULT APIENTRY GaDdiGetInfo(HANDLE hDevice, UINT DevInfoID, VOID *pDevInfoStruct, UINT DevInfoSize);
    3971HRESULT APIENTRY GaDdiLock(HANDLE hDevice, D3DDDIARG_LOCK *pData);
    4072HRESULT APIENTRY GaDdiUnlock(HANDLE hDevice, const D3DDDIARG_UNLOCK *pData);
    41 HRESULT APIENTRY GaDdiCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC *pData, const UINT *pCode);
    42 HRESULT APIENTRY GaDdiCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER *pData, const UINT *pCode);
    4373HRESULT APIENTRY GaDdiCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE *pResource);
    4474HRESULT APIENTRY GaDdiDestroyResource(HANDLE hDevice, HANDLE hResource);
     75HRESULT APIENTRY GaDdiSetDisplayMode(HANDLE hDevice, const D3DDDIARG_SETDISPLAYMODE *pData);
     76HRESULT APIENTRY GaDdiPresent(HANDLE hDevice, const D3DDDIARG_PRESENT *pData);
     77HRESULT APIENTRY GaDdiFlush(HANDLE hDevice);
     78HRESULT APIENTRY GaDdiCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC *pData, const UINT *pCode);
     79HRESULT APIENTRY GaDdiDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle);
     80HRESULT APIENTRY GaDdiSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle);
     81HRESULT APIENTRY GaDdiCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL *pData,
     82                                             const D3DDDIVERTEXELEMENT *pVertexElements);
     83HRESULT APIENTRY GaDdiDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle);
     84HRESULT APIENTRY GaDdiSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle);
     85HRESULT APIENTRY GaDdiSetVertexShaderConstI(HANDLE hDevice, const D3DDDIARG_SETVERTEXSHADERCONSTI *pData,
     86                                            const INT *pRegisters);
     87HRESULT APIENTRY GaDdiSetVertexShaderConstB(HANDLE hDevice, const D3DDDIARG_SETVERTEXSHADERCONSTB *pData,
     88                                            const BOOL *pRegisters);
     89HRESULT APIENTRY GaDdiSetScissorRect(HANDLE hDevice, const RECT *pRect);
     90HRESULT APIENTRY GaDdiSetStreamSource(HANDLE hDevice, const D3DDDIARG_SETSTREAMSOURCE *pData);
     91HRESULT APIENTRY GaDdiSetStreamSourceFreq(HANDLE hDevice, const D3DDDIARG_SETSTREAMSOURCEFREQ *pData);
     92HRESULT APIENTRY GaDdiSetConvolutionKernelMono(HANDLE hDevice, const D3DDDIARG_SETCONVOLUTIONKERNELMONO *pData);
     93HRESULT APIENTRY GaDdiComposeRects(HANDLE hDevice, const D3DDDIARG_COMPOSERECTS *pData);
     94HRESULT APIENTRY GaDdiBlt(HANDLE hDevice, const D3DDDIARG_BLT *pData);
     95HRESULT APIENTRY GaDdiColorFill(HANDLE hDevice, const D3DDDIARG_COLORFILL *pData);
     96HRESULT APIENTRY GaDdiDepthFill(HANDLE hDevice, const D3DDDIARG_DEPTHFILL *pData);
     97HRESULT APIENTRY GaDdiCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY *pData);
     98HRESULT APIENTRY GaDdiDestroyQuery(HANDLE hDevice, HANDLE hQuery);
     99HRESULT APIENTRY GaDdiIssueQuery(HANDLE hDevice, const D3DDDIARG_ISSUEQUERY *pData);
     100HRESULT APIENTRY GaDdiGetQueryData(HANDLE hDevice, const D3DDDIARG_GETQUERYDATA *pData);
     101HRESULT APIENTRY GaDdiSetRenderTarget(HANDLE hDevice, const D3DDDIARG_SETRENDERTARGET *pData);
     102HRESULT APIENTRY GaDdiSetDepthStencil(HANDLE hDevice, const D3DDDIARG_SETDEPTHSTENCIL *pData);
     103HRESULT APIENTRY GaDdiGenerateMipSubLevels(HANDLE hDevice, const D3DDDIARG_GENERATEMIPSUBLEVELS *pData);
     104HRESULT APIENTRY GaDdiSetPixelShaderConstI(HANDLE hDevice, const D3DDDIARG_SETPIXELSHADERCONSTI *pData,
     105                                           const INT *pRegisters);
     106HRESULT APIENTRY GaDdiSetPixelShaderConstB(HANDLE hDevice, const D3DDDIARG_SETPIXELSHADERCONSTB *pData,
     107                                           const BOOL *pRegisters);
     108HRESULT APIENTRY GaDdiCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER *pData, const UINT *pCode);
     109HRESULT APIENTRY GaDdiDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle);
     110HRESULT APIENTRY GaDdiCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE *pData);
     111HRESULT APIENTRY GaDdiDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice);
     112HRESULT APIENTRY GaDdiSetDecodeRenderTarget(HANDLE hDevice, const D3DDDIARG_SETDECODERENDERTARGET *pData);
     113HRESULT APIENTRY GaDdiDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData);
     114HRESULT APIENTRY GaDdiDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData);
     115HRESULT APIENTRY GaDdiDecodeExecute(HANDLE hDevice, const D3DDDIARG_DECODEEXECUTE *pData);
     116HRESULT APIENTRY GaDdiDecodeExtensionExecute(HANDLE hDevice, const D3DDDIARG_DECODEEXTENSIONEXECUTE *pData);
     117HRESULT APIENTRY GaDdiCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE *pData);
     118HRESULT APIENTRY GaDdiDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor);
     119HRESULT APIENTRY GaDdiVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcessor);
     120HRESULT APIENTRY GaDdiVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData);
     121HRESULT APIENTRY GaDdiSetVideoProcessRenderTarget(HANDLE hDevice,
     122                                                  const D3DDDIARG_SETVIDEOPROCESSRENDERTARGET *pData);
     123HRESULT APIENTRY GaDdiVideoProcessBlt(HANDLE hDevice, const D3DDDIARG_VIDEOPROCESSBLT *pData);
     124HRESULT APIENTRY GaDdiCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE *pData);
     125HRESULT APIENTRY GaDdiDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension);
     126HRESULT APIENTRY GaDdiExtensionExecute(HANDLE hDevice, const D3DDDIARG_EXTENSIONEXECUTE *pData);
     127HRESULT APIENTRY GaDdiCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY *pData);
     128HRESULT APIENTRY GaDdiUpdateOverlay(HANDLE hDevice, const D3DDDIARG_UPDATEOVERLAY *pData);
     129HRESULT APIENTRY GaDdiFlipOverlay(HANDLE hDevice, const D3DDDIARG_FLIPOVERLAY *pData);
     130HRESULT APIENTRY GaDdiGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS *pData);
     131HRESULT APIENTRY GaDdiSetOverlayColorControls(HANDLE hDevice, const D3DDDIARG_SETOVERLAYCOLORCONTROLS *pData);
     132HRESULT APIENTRY GaDdiDestroyOverlay(HANDLE hDevice, const D3DDDIARG_DESTROYOVERLAY *pData);
     133HRESULT APIENTRY GaDdiDestroyDevice(HANDLE hDevice);
     134HRESULT APIENTRY GaDdiQueryResourceResidency(HANDLE hDevice, const D3DDDIARG_QUERYRESOURCERESIDENCY *pData);
    45135HRESULT APIENTRY GaDdiOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE *pResource);
     136HRESULT APIENTRY GaDdiGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE *pData);
     137HRESULT APIENTRY GaDdiCaptureToSysMem(HANDLE hDevice, const D3DDDIARG_CAPTURETOSYSMEM *pData);
     138
     139HRESULT APIENTRY GaDdiAdapterGetCaps(HANDLE hAdapter, const D3DDDIARG_GETCAPS *pData);
     140HRESULT APIENTRY GaDdiAdapterCreateDevice(HANDLE hAdapter, D3DDDIARG_CREATEDEVICE *pCreateData);
     141HRESULT APIENTRY GaDdiAdapterCloseAdapter(IN HANDLE hAdapter);
    46142
    47143#endif /* !GA_INCLUDED_SRC_WINNT_Graphics_Video_disp_wddm_gallium_GaDdi_h */
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