9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VBoxVideo Display D3D User mode dll
c7814cf6e1240a519cbec0441e033d0e2470ed00vboxsync * Copyright (C) 2011-2012 Oracle Corporation
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * available from http://www.virtualbox.org. This file is free software;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * you can redistribute it and/or modify it under the terms of the GNU
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * General Public License (GPL) as published by the Free Software
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsyncvolatile uint32_t g_u32VBoxDispProfileFunctionLoggerIndex = 0;
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync/* the number of frames to collect data before doing dump/reset */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync/* uncomment to enable particular logging */
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync/* allows dumping fps + how much time is spent in ddi functions in comparison with the rest time */
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync//# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_ENABLE
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync/* allows dumping time spent in each function and the number of calls made for any given function */
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync VBoxDispProfileDevicePostProcess(PVBOXWDDMDISP_DEVICE pDevice) :
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync m_pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9Finish((IDirect3DDevice9Ex *)m_pDevice->pDevice9If);
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync//static VBoxDispProfileSet g_VBoxDispProfileDDI("D3D_DDI");
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE_DEV(_pObj) VBOXDISPPROFILE_FUNCTION_LOGGER_DEFINE((_pObj)->ProfileDdiFunc, VBoxDispProfileDevicePostProcess, VBoxDispProfileDevicePostProcess(_pObj))
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE_BASE(_pObj) VBOXDISPPROFILE_FUNCTION_LOGGER_DEFINE((_pObj)->ProfileDdiFunc, VBoxDispProfileDummyPostProcess, VBoxDispProfileDummyPostProcess())
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DUMP(_pObj) do {\
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_RESET(_pObj) do {\
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DISABLE_CURRENT() do {\
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXDISPPROFILE_FUNCTION_LOGGER_DISABLE_CURRENT();\
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_LOG_AND_DISABLE_CURRENT() VBOXDISPPROFILE_FUNCTION_LOGGER_LOG_AND_DISABLE_CURRENT()
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_REPORT_FRAME(_pObj) do { \
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync if (!((_pObj)->ProfileDdiFunc.reportIteration() % VBOXDISPPROFILE_DDI_DUMP_FRAME_COUNT) /*&& !VBOXVDBG_IS_DWM()*/) {\
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_RESET(_pObj); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync } while (0)
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE_DEV(_pObj) do {} while(0)
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE_BASE(_pObj) do {} while(0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DUMP(_pObj) do {} while(0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_RESET(_pObj) do {} while(0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_DISABLE_CURRENT() do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_LOG_AND_DISABLE_CURRENT() do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_REPORT_FRAME(_pDev) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync//static VBoxDispProfileFpsCounter g_VBoxDispFpsDDI(64);
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_PROLOGUE(_pObj) VBOXDISPPROFILE_STATISTIC_LOGGER_DEFINE(&(_pObj)->ProfileDdiFps, VBoxDispProfileDummyPostProcess, VBoxDispProfileDummyPostProcess())
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_DISABLE_CURRENT() do {\
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXDISPPROFILE_STATISTIC_LOGGER_DISABLE_CURRENT();\
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_DUMP(_pObj) do { \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync double tup = (_pObj)->ProfileDdiFps.GetTimeProcPercent(); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DUMP(("[0x%p]: fps: %f, cps: %.1f, host %.1f%%", (_pObj), fps, cps, tup)); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_REPORT_FRAME(_pObj) do { \
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync if(!((_pObj)->ProfileDdiFps.GetNumFrames() % VBOXDISPPROFILE_DDI_DUMP_FRAME_COUNT)) \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_DUMP(_pObj); \
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_LOG_AND_DISABLE_CURRENT() VBOXDISPPROFILE_STATISTIC_LOGGER_LOG_AND_DISABLE_CURRENT()
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_PROLOGUE(_pObj) do {} while(0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_DISABLE_CURRENT() do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_LOG_AND_DISABLE_CURRENT() do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_REPORT_FRAME(_pDev) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_DUMP(_pObj) do {} while (0)
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE_DEV(_pObj) \
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE_DEV(_pObj); \
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_PROLOGUE(_pObj);
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE_BASE(_pObj) \
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_PROLOGUE_BASE(_pObj); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_PROLOGUE(_pObj);
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_LOG_AND_DISABLE_CURRENT() \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_LOG_AND_DISABLE_CURRENT(); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_LOG_AND_DISABLE_CURRENT();
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_REPORT_FRAME(_pDev) do {\
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_REPORT_FRAME(_pDev); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_REPORT_FRAME(_pDev); \
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_REPORT_FLUSH(_pDev) do {\
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXDISPPROFILE_DDI_STATISTIC_LOGGER_REPORT_FRAME(_pDev); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_REPORT_FRAME(_pDev); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync } while (0)
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_DDI_REPORT_FLUSH(_pDev) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_INIT_CMN(_pObj, _name, _cEntries) do { \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync (_pObj)->ProfileDdiFps = VBoxDispProfileFpsCounter(); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync (_pObj)->ProfileDdiFunc = VBoxDispProfileSet(_name); \
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_FUNCTION_LOGGER_RESET(_pObj); \
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync } while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_PRINT(_m) VBOXDISPPROFILE_DUMP(_m)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_INIT_GLBL() VBOXDISPPROFILE_DDI_INIT_CMN(&g_VBoxDispProfile, "DDI_Adp", 64)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_INIT_ADP(_pAdp) VBOXDISPPROFILE_DDI_INIT_CMN(_pAdp, "DDI_Adp", 64)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_INIT_DEV(_pDev) VBOXDISPPROFILE_DDI_INIT_CMN(_pDev, "DDI_Dev", 64)
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE_DEV(_pObj) do {} while (0)
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync# define VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE_BASE(_pObj) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_REPORT_FRAME(_pDev) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_REPORT_FLUSH(_pDev) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_INIT_GLBL() do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_INIT_ADP(_pAdp) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_INIT_DEV(_pDev) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_TERM(_pObj) do {} while (0)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync# define VBOXDISPPROFILE_DDI_PRINT(_m) do {} while (0)
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync/* debugging/profiling stuff could go here.
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync * NOP in release */
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE_DEV((PVBOXWDDMDISP_DEVICE)(_hDevice));
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE_BASE((PVBOXWDDMDISP_ADAPTER)(_hAdapter));
7fde7f7bd127420c68c4899ccbafe895a5459b15vboxsync VBOXDISPPROFILE_FUNCTION_DDI_PROLOGUE_BASE(&g_VBoxDispProfile);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//#define VBOXWDDMOVERLAY_TEST
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// D3DDDIQUERYTYPE_OCCLUSION
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#define VBOX_QUERYTYPE_COUNT() RT_ELEMENTS(gVBoxQueryTypes)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#define VBOXDISPCRHGSMI_SCOPE_SET_DEV(_pDev) do {} while(0)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#define VBOXDISPCRHGSMI_SCOPE_SET_GLOBAL() do {} while(0)
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsyncstatic HRESULT vboxWddmNSCAddAlloc(PVBOXWDDMDISP_NSCADD pData, PVBOXWDDMDISP_ALLOCATION pAlloc)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->fEverWritten || pAlloc->pRc->RcDesc.fFlags.SharedResource);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync if (pData->cAllocationList && pData->cPatchLocationList && pData->cbCommandBuffer >= 4)
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync memset(pData->pAllocationList, 0, sizeof (D3DDDI_ALLOCATIONLIST));
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pData->pAllocationList[0].hAllocation = pAlloc->hAllocation;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync memset(pData->pPatchLocationList, 0, sizeof (D3DDDI_PATCHLOCATIONLIST));
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pData->pPatchLocationList[0].PatchOffset = pData->cAllocations*4;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pData->pPatchLocationList[0].AllocationIndex = pData->cAllocations;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pData->pvCommandBuffer = (VOID*)(((uint8_t*)pData->pvCommandBuffer) + 4);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic VOID vboxWddmDalRemove(PVBOXWDDMDISP_ALLOCATION pAlloc)
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsyncstatic HRESULT vboxWddmDalNotifyChange(PVBOXWDDMDISP_DEVICE pDevice)
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync NscAdd.pvCommandBuffer = pDevice->DefaultContext.ContextInfo.pCommandBuffer;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync NscAdd.cbCommandBuffer = pDevice->DefaultContext.ContextInfo.CommandBufferSize;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync NscAdd.pAllocationList = pDevice->DefaultContext.ContextInfo.pAllocationList;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync NscAdd.cAllocationList = pDevice->DefaultContext.ContextInfo.AllocationListSize;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync NscAdd.pPatchLocationList = pDevice->DefaultContext.ContextInfo.pPatchLocationList;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync NscAdd.cPatchLocationList = pDevice->DefaultContext.ContextInfo.PatchLocationListSize;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync Assert(NscAdd.cbCommandBuffer >= sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR));
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync if (NscAdd.cbCommandBuffer < sizeof (VBOXWDDM_DMA_PRIVATEDATA_BASEHDR))
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR pHdr = (PVBOXWDDM_DMA_PRIVATEDATA_BASEHDR)NscAdd.pvCommandBuffer;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync NscAdd.pvCommandBuffer = (VOID*)(((uint8_t*)NscAdd.pvCommandBuffer) + sizeof (*pHdr));
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync RTListForEach(&pDevice->DirtyAllocList, pAlloc, VBOXWDDMDISP_ALLOCATION, DirtyAllocListEntry)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->fEverWritten || pAlloc->pRc->RcDesc.fFlags.SharedResource);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = RTListGetFirst(&pDevice->DirtyAllocList, VBOXWDDMDISP_ALLOCATION, DirtyAllocListEntry);
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsync HRESULT tmpHr = vboxWddmNSCAddAlloc(&NscAdd, pAlloc);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync RenderData.CommandLength = pDevice->DefaultContext.ContextInfo.CommandBufferSize - NscAdd.cbCommandBuffer;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync RenderData.NumAllocations = pDevice->DefaultContext.ContextInfo.AllocationListSize - NscAdd.cAllocationList;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync Assert(RenderData.NumAllocations == NscAdd.cAllocations);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync RenderData.NumPatchLocations = pDevice->DefaultContext.ContextInfo.PatchLocationListSize - NscAdd.cPatchLocationList;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync Assert(RenderData.NumPatchLocations == NscAdd.cAllocations);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync// RenderData.NewCommandBufferSize = sizeof (VBOXVDMACMD) + 4 * (100);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync// RenderData.NewAllocationListSize = 100;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync// RenderData.NewPatchLocationListSize = 100;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync RenderData.hContext = pDevice->DefaultContext.ContextInfo.hContext;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync HRESULT hr = pDevice->RtCallbacks.pfnRenderCb(pDevice->hDevice, &RenderData);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pDevice->DefaultContext.ContextInfo.CommandBufferSize = RenderData.NewCommandBufferSize;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pDevice->DefaultContext.ContextInfo.pCommandBuffer = RenderData.pNewCommandBuffer;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pDevice->DefaultContext.ContextInfo.AllocationListSize = RenderData.NewAllocationListSize;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pDevice->DefaultContext.ContextInfo.pAllocationList = RenderData.pNewAllocationList;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pDevice->DefaultContext.ContextInfo.PatchLocationListSize = RenderData.NewPatchLocationListSize;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync pDevice->DefaultContext.ContextInfo.pPatchLocationList = RenderData.pNewPatchLocationList;
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync } while (1);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic HRESULT vboxWddmDalCheckUnlock(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync if (!pAlloc->fAllocLocked || pAlloc->LockInfo.cLocks)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync HRESULT hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &Unlock);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic HRESULT vboxWddmDalCheckLock(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, D3DDDI_LOCKFLAGS Flags)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync WARN(("vboxWddmDalNotifyChange failed %#x, ignoring", hr));
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &LockData);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync WARN(("pfnLockCb failed %#x, Flags %#x", hr, Flags.Value));
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic BOOLEAN vboxWddmDalCheckNotifyRemove(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc)
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsyncstatic BOOLEAN vboxWddmDalCheckAdd(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOLEAN fWrite)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync if (!pAlloc->hAllocation /* only shared resources matter */
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(!pAlloc->DirtyAllocListEntry.pNext || pAlloc->hSharedHandle /*|| pAlloc->fDirtyWrite*/);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(fWrite || pAlloc->fEverWritten || pAlloc->pRc->RcDesc.fFlags.SharedResource);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync RTListAppend(&pDevice->DirtyAllocList, &pAlloc->DirtyAllocListEntry);
4e17e709fb35d081aa9be29921b24c66d55fb70bvboxsync Assert(pAlloc->fDirtyWrite == fWrite || pAlloc->pRc->RcDesc.fFlags.SharedResource);
24ac539d8837ed5eecea2d6adb57200ad17f037bvboxsyncstatic DECLINLINE(BOOLEAN) vboxWddmDalCheckAddRc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, BOOLEAN fWrite)
24ac539d8837ed5eecea2d6adb57200ad17f037bvboxsync PVBOXWDDMDISP_ALLOCATION pDAlloc = &pRc->aAllocations[i];
24ac539d8837ed5eecea2d6adb57200ad17f037bvboxsync fChanged |= vboxWddmDalCheckAdd(pDevice, pDAlloc, fWrite);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic VOID vboxWddmDalCheckAddDepthStencil(PVBOXWDDMDISP_DEVICE pDevice)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync vboxWddmDalCheckAddRc(pDevice, pDevice->pDepthStencilRc, TRUE);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic VOID vboxWddmDalCheckAddRTs(PVBOXWDDMDISP_DEVICE pDevice)
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsync vboxWddmDalCheckAdd(pDevice, pDevice->apRTs[i], TRUE);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic VOID vboxWddmDalCheckAddSamplers(PVBOXWDDMDISP_DEVICE pDevice)
24ac539d8837ed5eecea2d6adb57200ad17f037bvboxsync for (UINT i = 0, iSampler = 0; iSampler < pDevice->cSamplerTextures; ++i)
24ac539d8837ed5eecea2d6adb57200ad17f037bvboxsync Assert(i < RT_ELEMENTS(pDevice->aSamplerTextures));
24ac539d8837ed5eecea2d6adb57200ad17f037bvboxsync vboxWddmDalCheckAddRc(pDevice, pDevice->aSamplerTextures[i], FALSE);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic VOID vboxWddmDalCheckAddOnDraw(PVBOXWDDMDISP_DEVICE pDevice)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsyncstatic BOOLEAN vboxWddmDalIsEmpty(PVBOXWDDMDISP_DEVICE pDevice)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic bool vboxVhwaIsEnabled(PVBOXWDDMDISP_ADAPTER pAdapter)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAdapter->aHeads[i].Vhwa.Settings.fFlags & VBOXVHWA_F_ENABLED)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return true;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic bool vboxVhwaHasCKeying(PVBOXWDDMDISP_ADAPTER pAdapter)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXVHWA_INFO* pSettings = &pAdapter->aHeads[i].Vhwa.Settings;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return true;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return false;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxResourceFree(PVBOXWDDMDISP_RESOURCE pRc)
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsyncvoid vboxWddmResourceInit(PVBOXWDDMDISP_RESOURCE pRc, UINT cAllocs)
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsync memset(pRc, 0, RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic PVBOXWDDMDISP_RESOURCE vboxResourceAlloc(UINT cAllocs)
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)RTMemAlloc(RT_OFFSETOF(VBOXWDDMDISP_RESOURCE, aAllocations[cAllocs]));
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsyncstatic void vboxWddmDbgSynchMemCheck(PVBOXWDDMDISP_ALLOCATION pAlloc, D3DLOCKED_RECT *pLockInfo)
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync iRc = memcmp(pLockInfo->pBits, pAlloc->pvMem, pAlloc->SurfDesc.cbSize);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync Assert(pAlloc->SurfDesc.pitch <= (UINT)pLockInfo->Pitch);
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync uint32_t cRows = vboxWddmCalcNumRows(0, pAlloc->SurfDesc.height, pAlloc->SurfDesc.format);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsyncstatic VOID vboxWddmDbgRcSynchMemCheck(PVBOXWDDMDISP_RESOURCE pRc)
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync HRESULT hr = VBoxD3DIfLockRect(pRc, i, &Rect, NULL, D3DLOCK_READONLY);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmRenderTargetSet(PVBOXWDDMDISP_DEVICE pDevice, UINT iRt, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bOnSwapchainSynch);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmSwapchainInit(PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pSwapchain, 0, sizeof (VBOXWDDMDISP_SWAPCHAIN));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmSwapchainKmSynch(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DKMT_HANDLE ahAllocs[VBOXWDDMDISP_MAX_SWAPCHAIN_SIZE];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(&Buf.SwapchainInfo, 0, sizeof (Buf.SwapchainInfo));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Buf.SwapchainInfo.EscapeHdr.escapeCode = VBOXESC_SWAPCHAININFO;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Buf.SwapchainInfo.SwapchainInfo.hSwapchainKm = pSwapchain->hSwapchainKm;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Buf.SwapchainInfo.SwapchainInfo.hSwapchainUm = (VBOXDISP_UMHANDLE)pSwapchain;
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync HRESULT hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DSwapchain9GetHostWinID(pSwapchain->pSwapChainIf, &Buf.SwapchainInfo.SwapchainInfo.winHostID);
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync WARN(("pfnVBoxWineExD3DSwapchain9GetHostWinID failed, hr 0x%x", hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Buf.SwapchainInfo.SwapchainInfo.Rect;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Buf.SwapchainInfo.SwapchainInfo.u32Reserved;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Buf.SwapchainInfo.SwapchainInfo.cAllocs = pSwapchain->cRTs;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < Buf.SwapchainInfo.SwapchainInfo.cAllocs; ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pSwapchain->aRTs[i].pAlloc->hAllocation);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Buf.SwapchainInfo.SwapchainInfo.ahAllocs[i] = pSwapchain->aRTs[i].pAlloc->hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(cAllocsKm == Buf.SwapchainInfo.SwapchainInfo.cAllocs || !cAllocsKm);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (cAllocsKm == Buf.SwapchainInfo.SwapchainInfo.cAllocs)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DdiEscape.hContext = pDevice->DefaultContext.ContextInfo.hContext;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // DdiEscape.Flags.Value = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DdiEscape.PrivateDriverDataSize = RT_OFFSETOF(VBOXDISPIFESCAPE_SWAPCHAININFO, SwapchainInfo.ahAllocs[Buf.SwapchainInfo.SwapchainInfo.cAllocs]);
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync hr = pDevice->RtCallbacks.pfnEscapeCb(pDevice->pAdapter->hAdapter, &DdiEscape);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSwapchain->hSwapchainKm = Buf.SwapchainInfo.SwapchainInfo.hSwapchainKm;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmSwapchainKmDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* submit empty swapchain to destroy the KM one */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = vboxWddmSwapchainKmSynch(pDevice, pSwapchain);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmSwapchainDestroyIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmSwapchainClear(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
3c5c04d7b0973be0757addef8ba44b9352b38386vboxsync /* first do a Km destroy to ensure all km->um region submissions are completed */
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsyncVOID vboxWddmSwapchainDestroy(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic VOID vboxWddmSwapchainDestroyAll(PVBOXWDDMDISP_DEVICE pDevice)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pCur = RTListGetFirst(&pDevice->SwapchainList, VBOXWDDMDISP_SWAPCHAIN, ListEntry);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!RTListNodeIsLast(&pDevice->SwapchainList, &pCur->ListEntry))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pNext = RTListNodeGetNext(&pCur->ListEntry, VBOXWDDMDISP_SWAPCHAIN, ListEntry);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainAlloc(PVBOXWDDMDISP_DEVICE pDevice)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pSwapchain = (PVBOXWDDMDISP_SWAPCHAIN)RTMemAllocZ(sizeof (VBOXWDDMDISP_SWAPCHAIN));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync RTListAppend(&pDevice->SwapchainList, &pSwapchain->ListEntry);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmSwapchainRtInit(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRt, PVBOXWDDMDISP_ALLOCATION pAlloc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmSwapchainBbAddTail(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bAssignAsBb)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDMDISP_SWAPCHAIN_FLAGS fOldFlags = pSwapchain->fFlags;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RENDERTGT pRt = &pSwapchain->aRTs[pSwapchain->cRTs];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSwapchain->iBB == VBOXWDDMDISP_INDEX_UNDEFINED);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pSwapchain->cRTs == 2) /* the first one is a frontbuffer */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmSwapchainFlip(PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pSwapchain->iBB = (pSwapchain->iBB + 1) % pSwapchain->cRTs;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(UINT) vboxWddmSwapchainNumRTs(PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(PVBOXWDDMDISP_RENDERTGT) vboxWddmSwapchainRtForAlloc(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pAlloc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSwapchain->aRTs[i].pAlloc->pSwapchain = pSwapchain);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* should never happen */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(UINT) vboxWddmSwapchainRtIndex(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRT)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT offFirst = RT_OFFSETOF(VBOXWDDMDISP_SWAPCHAIN, aRTs);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT offRT = UINT((uintptr_t)pRT - (uintptr_t)pSwapchain);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!((offRT - offFirst) % sizeof (VBOXWDDMDISP_RENDERTGT)));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT iRt = (offRT - offFirst) / sizeof (VBOXWDDMDISP_RENDERTGT);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(VOID) vboxWddmSwapchainRtRemove(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRT)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT iRt = vboxWddmSwapchainRtIndex(pSwapchain, pRT);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsyncDECLINLINE(VOID) vboxWddmSwapchainSetBb(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_RENDERTGT pRT)
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync UINT iRt = vboxWddmSwapchainRtIndex(pSwapchain, pRT);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsyncPVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainFindCreate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc, BOOL *pbNeedPresent)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pSwapchain = pBbAlloc->pSwapchain;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* check if this is what we expect */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainGetBb(pSwapchain);
727fa5661ba0158f74b72e445a8544259b034ab0vboxsync if (pBbAlloc == vboxWddmSwapchainGetFb(pSwapchain)->pAlloc)
727fa5661ba0158f74b72e445a8544259b034ab0vboxsync /* the current front-buffer present is requested, don't do anything */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* bad, @todo: correct the swapchain by either removing the Rt and adding it to another swapchain
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * or by removing the pBbAlloc out of it */
ac7e45442a6e3b7c01faa0cdc1c48daee049ff59vboxsync//@todo: Assert(0);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainRtForAlloc(pSwapchain, pBbAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* first search for the swapchain the alloc might be added to */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pCur = RTListGetFirst(&pDevice->SwapchainList, VBOXWDDMDISP_SWAPCHAIN, ListEntry);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainGetBb(pCur);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && vboxWddmSwapchainRtIndex(pCur, pRt) == 0) /* <- in case we add a rt to the swapchain on present this would mean
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * that the last RT in the swapchain array is now a frontbuffer and
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * thus the aRTs[0] is a backbuffer */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pBbAlloc->SurfDesc.width == pRt->pAlloc->SurfDesc.width
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pBbAlloc->SurfDesc.height == pRt->pAlloc->SurfDesc.height
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync && vboxWddmFmtNoAlphaFormat(pBbAlloc->SurfDesc.format) == vboxWddmFmtNoAlphaFormat(pRt->pAlloc->SurfDesc.format)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pBbAlloc->SurfDesc.VidPnSourceId == pRt->pAlloc->SurfDesc.VidPnSourceId
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (RTListNodeIsLast(&pDevice->SwapchainList, &pCur->ListEntry))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCur = RTListNodeGetNext(&pCur->ListEntry, VBOXWDDMDISP_SWAPCHAIN, ListEntry);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// if (!pSwapchain) need to create a new one (see below)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSwapchainBbAddTail(pSwapchain, pBbAlloc, FALSE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic PVBOXWDDMDISP_SWAPCHAIN vboxWddmSwapchainCreateForRc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainAlloc(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmSwapchainBbAddTail(pSwapchain, &pRc->aAllocations[i], FALSE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncDECLINLINE(UINT) vboxWddmSwapchainIdxBb2Rt(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, uint32_t iBb)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync return iBb != (~0) ? (iBb + pSwapchain->iBB) % pSwapchain->cRTs : vboxWddmSwapchainIdxFb(pSwapchain);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmSwapchainRtSynch(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, uint32_t iBb)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync UINT iRt = vboxWddmSwapchainIdxBb2Rt(pSwapchain, iBb);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RENDERTGT pRt = &pSwapchain->aRTs[iRt];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pSwapchain->pSwapChainIf->GetBackBuffer(iBb, D3DBACKBUFFER_TYPE_MONO, &pD3D9Surf);
8794914231e509ec9364e3c77c7f1cdd1d1192abvboxsync Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync /* since this can be texture, need to do the VBoxD3DIfSurfGet magic */
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9OldSurf);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* get the old surface's swapchain */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync HRESULT tmpHr = pD3D9OldSurf->GetContainer(IID_IDirect3DSwapChain9, &pvSwapchain);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* the swapchain has changed, copy data to the new surface */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* @todo: we can not generally update the render target directly, implement */
cafde3c9008a124039e59720afbbc49002521ebfvboxsync VBOXVDBG_CHECK_SWAPCHAIN_SYNC(hr = pDevice->pDevice9If->StretchRect(pD3D9OldSurf, NULL, pD3D9Surf, NULL, D3DTEXF_NONE); Assert(hr == S_OK),
cafde3c9008a124039e59720afbbc49002521ebfvboxsync pAlloc, pD3D9OldSurf, NULL, pAlloc, pD3D9Surf, NULL);
727fa5661ba0158f74b72e445a8544259b034ab0vboxsync Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync hr = vboxWddmRenderTargetSet(pDevice, i, pAlloc, TRUE);
1a03b2417cfff289a1f02f723e8f357f88111201vboxsync /* only use direct bb if wine is able to handle quick blits bewteen surfaces in one swapchain,
1a03b2417cfff289a1f02f723e8f357f88111201vboxsync * this is FALSE by now :( */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* here we sync the front-buffer with a backbuffer data*/
1a03b2417cfff289a1f02f723e8f357f88111201vboxsync pD3D9Bb = (IDirect3DSurface9*)vboxWddmSwapchainGetBb(pSwapchain)->pAlloc->pD3DIf;
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* we use backbuffer as a rt frontbuffer copy, so release the old one and assign the current bb */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync HRESULT tmpHr = pSwapchain->pSwapChainIf->GetFrontBufferData(pD3D9Bb);
cafde3c9008a124039e59720afbbc49002521ebfvboxsync VBOXVDBG_CHECK_SWAPCHAIN_SYNC(tmpHr = pDevice->pDevice9If->StretchRect(pD3D9Bb, NULL, (IDirect3DSurface9*)vboxWddmSwapchainGetBb(pSwapchain)->pAlloc->pD3DIf, NULL, D3DTEXF_NONE); Assert(tmpHr == S_OK),
cafde3c9008a124039e59720afbbc49002521ebfvboxsync pAlloc, pD3D9Bb, NULL, pAlloc, (IDirect3DSurface9*)vboxWddmSwapchainGetBb(pSwapchain)->pAlloc->pD3DIf, NULL);
d78d67b41c2c5ddb1887fc3e50a1dbf3c9d74ffdvboxsync WARN(("GetFrontBufferData failed, hr (0x%x)", tmpHr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmSwapchainSynch(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (int iBb = -1; iBb < int(pSwapchain->cRTs - 1); ++iBb)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = vboxWddmSwapchainRtSynch(pDevice, pSwapchain, (UINT)iBb);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = vboxWddmSwapchainKmSynch(pDevice, pSwapchain);
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsyncstatic VOID vboxWddmSwapchainFillPresentParams(PVBOXWDDMDISP_SWAPCHAIN pSwapchain, D3DPRESENT_PARAMETERS *pParams)
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsync /* not supported by wine properly, need to use offscreen render targets and blit their data to swapchain RTs*/
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsync PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainGetBb(pSwapchain);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync VBoxD3DIfFillPresentParams(pParams, pRc, pSwapchain->cRTs);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync/* copy current rt data to offscreen render targets */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsyncstatic HRESULT vboxWddmSwapchainSwtichOffscreenRt(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, BOOL fForceCreate)
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsync vboxWddmSwapchainFillPresentParams(pSwapchain, &Params);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync IDirect3DSwapChain9 * pOldIf = pSwapchain->pSwapChainIf;
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = pOldIf->GetBackBuffer(~0, D3DBACKBUFFER_TYPE_MONO, &pD3D9OldFb);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync /* just need a pointer to match */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync PVBOXWDDMDISP_RENDERTGT pRT = &pSwapchain->aRTs[i];
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync if (pRT->pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_SURFACE)
cafde3c9008a124039e59720afbbc49002521ebfvboxsync BOOL fHasSurf = pRT->pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE ?
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync /* since this can be texture, need to do the VBoxD3DIfSurfGet magic */
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync hr = VBoxD3DIfSurfGet(pRT->pAlloc->pRc, pRT->pAlloc->iAlloc, &pD3D9OldSurf);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = pD3D9OldSurf->GetContainer(IID_IDirect3DSwapChain9, &pvSwapchain);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync if (!pvSwapchain) /* no swapchain, it is already offscreen */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync IDirect3DDevice9 *pDevice9If = pDevice->pDevice9If;
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync pRT->pAlloc->hSharedHandle ? &pRT->pAlloc->hSharedHandle : NULL
cafde3c9008a124039e59720afbbc49002521ebfvboxsync VBOXVDBG_CHECK_SWAPCHAIN_SYNC(hr = pDevice9If->StretchRect(pD3D9OldSurf, NULL, pD3D9NewSurf, NULL, D3DTEXF_NONE); Assert(hr == S_OK),
cafde3c9008a124039e59720afbbc49002521ebfvboxsync pRT->pAlloc, pD3D9OldSurf, NULL, pRT->pAlloc, pD3D9NewSurf, NULL);
cafde3c9008a124039e59720afbbc49002521ebfvboxsync Assert(pRT->pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync * @return old RtReportingPresent state
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsyncstatic HRESULT vboxWddmSwapchainSwtichRtPresent(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = vboxWddmSwapchainSwtichOffscreenRt(pDevice, pSwapchain,
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync TRUE /* force offscreen surface creation right away. This way we ensure the swapchain data
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync * is always uptodate which allows making the vboxWddmSwapchainRtSynch behave as a nop */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync /* ensure we update device RTs to offscreen ones we just created */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync PVBOXWDDMDISP_ALLOCATION pRtAlloc = pDevice->apRTs[i];
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = pSwapchain->aRTs[j].pAlloc;
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = vboxWddmRenderTargetSet(pDevice, i, pAlloc, TRUE);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsyncHRESULT vboxWddmSwapchainChkCreateIf(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!pSwapchain->fFlags.bChanged && pSwapchain->pSwapChainIf)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* preserve the old one */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DSwapChain9 * pOldIf = pSwapchain->pSwapChainIf;
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync if (pSwapchain->fFlags.bSwitchReportingPresent || pSwapchain->cRTs > VBOXWDDMDISP_MAX_DIRECT_RTS)
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync pSwapchain->fFlags.bSwitchReportingPresent = FALSE;
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync /* indicae switch to Render Target Reporting Present mode is needed */
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync// vboxWddmSwapchainSwtichRtPresent(pDevice, pSwapchain);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync if (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_SURFACE
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync && (pSwapchain->aRTs[i].pAlloc->enmD3DIfType != VBOXDISP_D3DIFTYPE_UNDEFINED
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync || pSwapchain->aRTs[i].pAlloc->enmType != VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* check if we need to re-create the swapchain */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync /* the number of swapchain backbuffers does not matter */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync if (OldParams.BackBufferCount == pSwapchain->cRTs-1)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* first create the new one */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsync vboxWddmSwapchainFillPresentParams(pSwapchain, &Params.Base);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DWORD fFlags = D3DCREATE_HARDWARE_VERTEXPROCESSING;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: it seems there should be a way to detect this correctly since
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.EnableAutoDepthStencil = FALSE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.Flags;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.FullScreen_RefreshRateInHz;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.FullScreen_PresentationInterval;
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync hr = pAdapter->D3D.pD3D9If->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, fFlags, &Params.Base, &pDevice9If);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync /* need to copy data to offscreen rt to ensure the data is preserved
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync * since the swapchain data may become invalid once we create a new swapchain
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync * and pass the current swapchain's window to it
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync * thus vboxWddmSwapchainSynch will not be able to do synchronization */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = vboxWddmSwapchainSwtichOffscreenRt(pDevice, pSwapchain, FALSE);
bf7ab711aa3580b3a587dcbc4653fe78c99fff37vboxsync /* re-use swapchain window
bf7ab711aa3580b3a587dcbc4653fe78c99fff37vboxsync * this will invalidate the previusly used swapchain */
89bc55bf0a6b0d34d55c02ca2a0c1082fe598cdcvboxsync hr = pDevice->pDevice9If->CreateAdditionalSwapChain(&Params.Base, &pNewIf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* to ensure the swapchain is not deleted once we release the pOldIf */
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync hr = vboxWddmSwapchainSwtichRtPresent(pDevice, pSwapchain);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync# if defined(VBOXDISP_WITH_WINE_BB_WORKAROUND) && defined(VBOX_WINE_WITH_FAST_INTERSWAPCHAIN_BLT)
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync /* if wine is able to do fast fb->bb blits, we will use backbuffer directly,
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync * this is NOT possible currently */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync /* we will assign it to wine backbuffer on a swapchain synch */
dce32b5ab44d19932db4c40310f864dab2b5df26vboxsync vboxWddmSwapchainFillPresentParams(pSwapchain, &Params);
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync /* ignore any subsequen failures */
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync PVBOXWDDMDISP_RENDERTGT pRt = &pSwapchain->aRTs[i];
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync Assert(pRt->pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync || pRt->pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE);
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync Assert(pRt->pAlloc->pRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
a316239ff79e32378f26a4c9b77b5906d4653850vboxsync Assert(!pSwapchain->fFlags.bSwitchReportingPresent);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmSwapchainCreateIfForRc(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, PVBOXWDDMDISP_SWAPCHAIN *ppSwapchain)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainCreateForRc(pDevice, pRc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = vboxWddmSwapchainChkCreateIf(pDevice, pSwapchain);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsyncstatic HRESULT vboxWddmSwapchainPresentPerform(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain);
a75f8ad0dcb9e130a53d2b13ddc9f8349ab3caf5vboxsyncstatic HRESULT vboxWddmSwapchainBbUpdate(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pBbAlloc)
a75f8ad0dcb9e130a53d2b13ddc9f8349ab3caf5vboxsync PVBOXWDDMDISP_ALLOCATION pCurBb = vboxWddmSwapchainGetBb(pSwapchain)->pAlloc;
a75f8ad0dcb9e130a53d2b13ddc9f8349ab3caf5vboxsync HRESULT hr = vboxWddmSwapchainPresentPerform(pDevice, pSwapchain);
a75f8ad0dcb9e130a53d2b13ddc9f8349ab3caf5vboxsync WARN(("vboxWddmSwapchainPresentPerform failed, hr (0x%x)", hr));
a75f8ad0dcb9e130a53d2b13ddc9f8349ab3caf5vboxsync AssertMsgFailed(("the given allocation not par of the swapchain\n"));
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync/* get the surface for the specified allocation in the swapchain */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsyncstatic HRESULT vboxWddmSwapchainSurfGet(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, PVBOXWDDMDISP_ALLOCATION pAlloc, IDirect3DSurface9 **ppSurf)
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync && vboxWddmSwapchainGetFb(pSwapchain)->pAlloc == pAlloc
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync && vboxWddmSwapchainNumRTs(pSwapchain) != 1 /* for swapchains w/o a backbuffer the alloc will contain the back-buffer actually */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* this is a front-buffer */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync IDirect3DSurface9 *pSurf = pSwapchain->pRenderTargetFbCopy;
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync HRESULT hr = pSwapchain->pSwapChainIf->GetFrontBufferData(pSurf);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync WARN(("GetFrontBufferData failed, hr (0x%x)", hr));
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* if this is not a front-buffer - just return the surface associated with the allocation */
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync return VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, ppSurf);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsyncstatic HRESULT vboxWddmSwapchainRtSurfGet(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain, UINT iRt, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bOnSwapchainSynch, IDirect3DSurface9 **ppSurf)
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync /* do the necessary swapchain synchronization first,
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync * not needed on swapchain synch since it is done already and we're called here just to set RTs */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync /* iRt != 0 is untested here !! */
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = vboxWddmSwapchainBbUpdate(pDevice, pSwapchain, pAlloc);
c865ce0230a2fe5a804d1f71e4bdf9b38f669d42vboxsync WARN(("vboxWddmSwapchainBbUpdate failed, hr(0x%x)",hr));
ac7e45442a6e3b7c01faa0cdc1c48daee049ff59vboxsync//@todo: Assert(!pSwapchain->fFlags.bChanged);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync hr = vboxWddmSwapchainChkCreateIf(pDevice, pSwapchain);
c865ce0230a2fe5a804d1f71e4bdf9b38f669d42vboxsync WARN(("vboxWddmSwapchainChkCreateIf failed, hr(0x%x)",hr));
ac7e45442a6e3b7c01faa0cdc1c48daee049ff59vboxsync//@todo: Assert(vboxWddmSwapchainGetBb(pSwapchain)->pAlloc == pAlloc || iRt != 0);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync hr = vboxWddmSwapchainSurfGet(pDevice, pSwapchain, pAlloc, &pSurf);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync WARN(("vboxWddmSwapchainSurfGet failed, hr(0x%x)", hr));
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsyncstatic HRESULT vboxWddmSwapchainPresentPerform(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_SWAPCHAIN pSwapchain)
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = pSwapchain->pSwapChainIf->Present(NULL, NULL, NULL, NULL, 0);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync PVBOXWDDMDISP_ALLOCATION pCurBb = vboxWddmSwapchainGetBb(pSwapchain)->pAlloc;
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync hr = vboxWddmSwapchainSurfGet(pDevice, pSwapchain, pCurBb, &pSurf);
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DSwapchain9Present(pSwapchain->pSwapChainIf, pSurf);
40bd0fc692d21a6d579862d7ccdc20c2ccf361a5vboxsync Assert(!pSwapchain->fFlags.bSwitchReportingPresent);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmSwapchainPresent(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pBbAlloc)
cf5a77c331ff5d2e6851345fef307d6ceee73097vboxsync /* we currently *assume* that presenting shared resource is only possible when 3d app is rendering with composited desktop on,
cf5a77c331ff5d2e6851345fef307d6ceee73097vboxsync * no need to do anything else since dwm will present everything for us */
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync HRESULT hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9Flush((IDirect3DDevice9Ex*)pDevice->pDevice9If);
727fa5661ba0158f74b72e445a8544259b034ab0vboxsync PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainFindCreate(pDevice, pBbAlloc, &bNeedPresent);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = vboxWddmSwapchainChkCreateIf(pDevice, pSwapchain);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = vboxWddmSwapchainPresentPerform(pDevice, pSwapchain);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync#if 0 //def DEBUG
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmDbgRenderTargetUpdateCheckSurface(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_ALLOCATION pAlloc, uint32_t iBBuf)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = pDevice->aScreens[pDevice->iPrimaryScreen].pDevice9If;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->GetBackBuffer(0 /*UINT iSwapChain*/,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmDbgRenderTargetCheck(PVBOXWDDMDISP_DEVICE pDevice, PVBOXWDDMDISP_RESOURCE pRc, uint32_t iNewRTFB)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 1; i < pRc->cAllocations; ++i, ++iBBuf)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDbgRenderTargetUpdateCheckSurface(pDevice, pAlloc, iBBuf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDbgRenderTargetUpdateCheckSurface(pDevice, pAlloc, ~0UL /* <- for the frontbuffer */);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert((!pAlloc->pD3DIf) == (pRc->cAllocations > 1));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert((!pAlloc->pD3DIf) == (pRc->cAllocations > 1));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAllocJ = &pRc->aAllocations[j];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync# define VBOXVDBG_RTGT_STATECHECK(_pDev) (vboxWddmDbgRenderTargetCheck((_pDev), (_pDev)->aScreens[(_pDev)->iPrimaryScreen].pRenderTargetRc, (_pDev)->aScreens[(_pDev)->iPrimaryScreen].iRenderTargetFrontBuf))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync# define VBOXVDBG_RTGT_STATECHECK(_pDev) do{}while(0)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT vboxWddmRenderTargetSet(PVBOXWDDMDISP_DEVICE pDevice, UINT iRt, PVBOXWDDMDISP_ALLOCATION pAlloc, BOOL bOnSwapchainSynch)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainForAlloc(pAlloc);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync hr = vboxWddmSwapchainRtSurfGet(pDevice, pSwapchain, iRt, pAlloc, bOnSwapchainSynch, &pD3D9Surf);
c865ce0230a2fe5a804d1f71e4bdf9b38f669d42vboxsync WARN(("vboxWddmSwapchainRtSurfGet failed, hr(0x%x)",hr));
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync hr = VBoxD3DIfSurfGet(pAlloc->pRc, pAlloc->iAlloc, &pD3D9Surf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * DLL entry point.
9811e5280582debe26aac8a3b5e30d489450014avboxsync// rc = VbglR3Init();
9811e5280582debe26aac8a3b5e30d489450014avboxsync// AssertRC(rc);
9811e5280582debe26aac8a3b5e30d489450014avboxsync// if (RT_SUCCESS(rc))
9811e5280582debe26aac8a3b5e30d489450014avboxsync// VbglR3Term();
9811e5280582debe26aac8a3b5e30d489450014avboxsync// VbglR3Term();
7b6926b2bf44f326f40e1d9d1ce33a4dff0a2c67vboxsync /// @todo RTR3Term();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync // pCaps->Caps2 |= DDRAW_CAPS2_FLIPNOVSYNC;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->DataSize == sizeof (DDRAW_MODE_SPECIFIC_CAPS));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync DDRAW_MODE_SPECIFIC_CAPS * pCaps = (DDRAW_MODE_SPECIFIC_CAPS*)pData->pData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(&pCaps->Caps /* do not cleanup the first "Head" field,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync zero starting with the one following "Head", i.e. Caps */,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS) - RT_OFFSETOF(DDRAW_MODE_SPECIFIC_CAPS, Caps));
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync VBOXVHWA_INFO *pSettings = &pAdapter->aHeads[pCaps->Head].Vhwa.Settings;
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync pCaps->Caps |= MODE_CAPS_OVERLAY | MODE_CAPS_OVERLAYSTRETCH;
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync pCaps->MaxVisibleOverlays = pSettings->cOverlaysSupported;
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync WARN(("D3DDDICAPS_DDRAW_MODE_SPECIFIC query for D3D mode!"));
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync *((uint32_t*)pData->pData) = pAdapter->Formats.cFormstOps;
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync Assert(pData->DataSize == pAdapter->Formats.cFormstOps * sizeof (FORMATOP));
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync memcpy(pData->pData, pAdapter->Formats.paFormstOps, pAdapter->Formats.cFormstOps * sizeof (FORMATOP));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync *((uint32_t*)pData->pData) = VBOX_QUERYTYPE_COUNT();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->DataSize == VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(pData->pData, gVBoxQueryTypes, VBOX_QUERYTYPE_COUNT() * sizeof (D3DDDIQUERYTYPE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->DataSize == sizeof (D3DHAL_GLOBALDRIVERDATA));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DHAL_GLOBALDRIVERDATA *pCaps = (D3DHAL_GLOBALDRIVERDATA *)pData->pData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset (pCaps, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->hwCaps.dwDevCaps = D3DDEVCAPS_CANRENDERAFTERFLIP
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// | D3DDEVCAPS_DRAWPRIMTLVERTEX
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// | D3DDEVCAPS_FLOATTLVERTEX
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// | D3DDEVCAPS_HWTRANSFORMANDLIGHT
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// | D3DDEVCAPS_TLVERTEXSYSTEMMEMORY
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// | D3DDEVCAPS_TEXTUREVIDEOMEMORY
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->hwCaps.dtcTransformCaps.dwSize = sizeof (D3DTRANSFORMCAPS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->hwCaps.dlcLightingCaps.dwSize = sizeof (D3DLIGHTINGCAPS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->hwCaps.dpcLineCaps.dwSize = sizeof (D3DPRIMCAPS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->hwCaps.dpcLineCaps.dwTextureAddressCaps = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->hwCaps.dpcTriCaps.dwSize = sizeof (D3DPRIMCAPS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->hwCaps.dwDeviceRenderBitDepth = DDBD_8 | DDBD_16 | DDBD_24 | DDBD_32;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->dwNumTextureFormats = 0;//pAdapter->cSurfDescs;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCaps->lpTextureFormats = NULL;//pAdapter->paSurfDescs;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->DataSize == sizeof (D3DHAL_D3DEXTENDEDCAPS));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DHAL_D3DEXTENDEDCAPS *pCaps = (D3DHAL_D3DEXTENDEDCAPS*)pData->pData;
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync memcpy(pData->pData, &pAdapter->D3D.Caps, sizeof (D3DCAPS9));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->DataSize == RT_OFFSETOF(D3DCAPS9, DevCaps2));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pData->DataSize == RT_OFFSETOF(D3DCAPS9, DevCaps2))
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync memcpy(pData->pData, &pAdapter->D3D.Caps, RT_OFFSETOF(D3DCAPS9, DevCaps2));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetRenderState(vboxDDI2D3DRenderStateType(pData->State), pData->Value);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: check if it's ok to always return success */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint((__FUNCTION__": @todo: check if it's ok to always return success\n"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDMDISP_TSS_LOOKUP lookup = vboxDDI2D3DTestureStageStateType(pData->State);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->SetTextureStageState(pData->Stage, D3DTEXTURESTAGESTATETYPE(lookup.dType), pData->Value);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->SetSamplerState(pData->Stage, D3DSAMPLERSTATETYPE(lookup.dType), pData->Value);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hTexture;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pRc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pD3DIfTex = (IDirect3DTexture9*)pRc->aAllocations[0].pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pD3DIfTex = (IDirect3DCubeTexture9*)pRc->aAllocations[0].pD3DIf;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync pD3DIfTex = (IDirect3DVolumeTexture9*)pRc->aAllocations[0].pD3DIf;
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync Assert(pDevice->cSamplerTextures < RT_ELEMENTS(pDevice->aSamplerTextures));
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync Assert(idx < RT_ELEMENTS(pDevice->aSamplerTextures));
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync WARN(("non-zero special sampler index not tested!\n"));
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync Assert(pDevice->cSamplerTextures < RT_ELEMENTS(pDevice->aSamplerTextures));
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync Assert(pDevice->cSamplerTextures < RT_ELEMENTS(pDevice->aSamplerTextures));
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync Assert(idx < RT_ELEMENTS(pDevice->aSamplerTextures));
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync Assert(pDevice->cSamplerTextures < RT_ELEMENTS(pDevice->aSamplerTextures));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetTexture(Stage, pD3DIfTex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetPixelShaderConstantF(pData->Register, pRegisters, pData->Count);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->Stream < RT_ELEMENTS(pDevice->aStreamSourceUm));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_STREAMSOURCEUM pStrSrcUm = &pDevice->aStreamSourceUm[pData->Stream];
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync Assert(pDevice->cStreamSourcesUm <= RT_ELEMENTS(pDevice->aStreamSourceUm));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice->pDevice9If->SetStreamSource(pData->Stream, NULL, 0, 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hIndexBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pIndexBuffer = (IDirect3DIndexBuffer9*)pAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
f6361f85d18460ad7be5c08575ef176465558bafvboxsync for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
f6361f85d18460ad7be5c08575ef176465558bafvboxsync for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
f6361f85d18460ad7be5c08575ef176465558bafvboxsync hr = pDevice9If->DrawPrimitiveUP(pData->PrimitiveType,
f6361f85d18460ad7be5c08575ef176465558bafvboxsync ((uint8_t*)pDevice->aStreamSourceUm[i].pvBuffer) + pData->VStart * pDevice->aStreamSourceUm[i].cbStride,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* todo: impl */
f6361f85d18460ad7be5c08575ef176465558bafvboxsync WARN(("multiple user stream sources (%d) not implemented!!", pDevice->cStreamSourcesUm));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSource); ++i)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pDevice->aStreamSource[i]->LockInfo.cLocks);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->DrawPrimitive(pData->PrimitiveType,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxVDbgMpPrintF((pDevice, __FUNCTION__": DrawPrimitive\n"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSource); ++i)
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync Assert(!pDevice->aStreamSource[i]->LockInfo.cLocks);
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync Assert(!pDevice->IndiciesInfo.pIndicesAlloc->LockInfo.cLocks);
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync WARN(("DrawIndexedPrimitive failed hr = 0x%x", hr));
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync Assert(pDevice->IndiciesInfo.uiStride == 2 || pDevice->IndiciesInfo.uiStride == 4);
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync pvIndexBuffer = (const uint8_t*)pDevice->IndiciesInfo.pIndicesAlloc->pvMem;
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync pvIndexBuffer = (const uint8_t*)pDevice->IndiciesInfo.pvIndicesUm;
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync for (UINT i = 0; i < RT_ELEMENTS(pDevice->aStreamSourceUm); ++i)
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync hr = pDevice9If->DrawIndexedPrimitiveUP(pData->PrimitiveType,
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync pvIndexBuffer + pDevice->IndiciesInfo.uiStride * pData->StartIndex,
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync pDevice->IndiciesInfo.uiStride == 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32,
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync HRESULT tmpHr = pDevice9If->SetIndices((IDirect3DIndexBuffer9*)pDevice->IndiciesInfo.pIndicesAlloc->pD3DIf);
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync WARN(("DrawIndexedPrimitiveUP failed hr = 0x%x", hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (stream=0; stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS; ++stream)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pDevice->aStreamSource[stream] && pDevice->aStreamSource[stream]->LockInfo.cLocks)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDMDISP_LOCKINFO *pLock = &pDevice->aStreamSource[stream]->LockInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard || pLock->fFlags.NoOverwrite))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pD3D9VBuf->Lock(pLock->Range.Offset, pLock->Range.Size,
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync VBoxD3DIfLockUnlockMemSynch(pDevice->aStreamSource[stream], &pLock->LockedRect, &r, true /*bool bToLockInfo*/);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset, pData->PrimitiveCount);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync for (stream=0; stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS; ++stream)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(stream==0); /*only stream 0 should be accessed here*/
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pDevice->StreamSourceInfo[stream].uiStride!=0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDMDISP_LOCKINFO *pLock = &pDevice->aStreamSource[stream]->LockInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxVDbgMpPrintF((pDevice, __FUNCTION__": DrawPrimitiveUP\n"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pLock->fFlags.MightDrawFromLocked && (pLock->fFlags.Discard || pLock->fFlags.NoOverwrite));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->DrawPrimitiveUP(pData->PrimitiveType, pData->PrimitiveCount,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync (void*)((uintptr_t)pDevice->aStreamSource[stream]->pvMem+pDevice->StreamSourceInfo[stream].uiOffset+pData->FirstVertexOffset),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->SetStreamSource(stream, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[stream]->pD3DIf, pDevice->StreamSourceInfo[stream].uiOffset, pDevice->StreamSourceInfo[stream].uiStride);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxVDbgMpPrintF((pDevice, __FUNCTION__": DrawPrimitive\n"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->DrawPrimitive(pData->PrimitiveType, pData->FirstVertexOffset/pDevice->StreamSourceInfo[stream].uiStride, pData->PrimitiveCount);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync WARN(("unsupported dwIndicesSize %d", dwIndicesSize));
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync pvVertexBuffer = (const uint8_t *)pDevice->aStreamSourceUm[0].pvBuffer;
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync cbVertexStride = pDevice->aStreamSourceUm[0].cbStride;
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = pDevice->aStreamSource[0];
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync pvVertexBuffer = ((const uint8_t *)pAlloc->pvMem) + pDevice->StreamSourceInfo[0].uiOffset;
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync cbVertexStride = pDevice->StreamSourceInfo[0].uiStride;
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync pvVertexBuffer = pvVertexBuffer + pData->BaseVertexOffset /* * cbVertexStride */;
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync hr = pDevice9If->DrawIndexedPrimitiveUP(pData->PrimitiveType,
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync ((uint8_t*)pIndexBuffer) + dwIndicesSize * pData->StartIndexOffset,
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync dwIndicesSize == 2 ? D3DFMT_INDEX16 : D3DFMT_INDEX32,
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync WARN(("DrawIndexedPrimitiveUP failed hr = 0x%x", hr));
2ccbe02f72045517701ce7bb25641fea5c6cfaaavboxsync HRESULT tmpHr = pDevice9If->SetStreamSource(0, (IDirect3DVertexBuffer9*)pDevice->aStreamSource[0]->pD3DIf, pDevice->StreamSourceInfo[0].uiOffset, pDevice->StreamSourceInfo[0].uiStride);
13842f48d0de2e673cc64b45bc7a48074b7fb67cvboxsync HRESULT tmpHr = pDevice9If->SetIndices((IDirect3DIndexBuffer9*)pDevice->IndiciesInfo.pIndicesAlloc->pD3DIf);
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(sizeof (D3DDDIBOX) == sizeof (VBOXBOX3D));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(VBOXBOX3D, Left));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(VBOXBOX3D, Top));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(VBOXBOX3D, Right));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(VBOXBOX3D, Bottom));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(VBOXBOX3D, Front));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(VBOXBOX3D, Back));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(VBOXBOX3D, Left));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(VBOXBOX3D, Top));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(VBOXBOX3D, Right));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(VBOXBOX3D, Bottom));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(VBOXBOX3D, Front));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(VBOXBOX3D, Back));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync /* requirements for D3DDevice9::UpdateTexture */
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync IDirect3DVolumeTexture9 * pSrcTex = (IDirect3DVolumeTexture9*)pSrcRc->aAllocations[0].pD3DIf;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync IDirect3DVolumeTexture9 * pDstTex = (IDirect3DVolumeTexture9*)pDstRc->aAllocations[0].pD3DIf;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync HRESULT hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9VolTexBlt((IDirect3DDevice9Ex*)pDevice9If, pSrcTex, pDstTex,
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync WARN(("pfnVBoxWineExD3DDev9VolTexBlt failed hr 0x%x", hr));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsync// @todo: vboxWddmDalCheckAdd(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* requirements for D3DDevice9::UpdateTexture */
21591edad86f2635638801986bc8786661041b56vboxsync Assert(pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
21591edad86f2635638801986bc8786661041b56vboxsync Assert(pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync || pSrcRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync || pDstRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pSrcRc->aAllocations[0].enmD3DIfType == pDstRc->aAllocations[0].enmD3DIfType);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSrcRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pDstRc->RcDesc.enmPool != D3DDDIPOOL_SYSTEMMEM);
9441dbf0fb711026d58d0c64d61a6dcfc3c6784dvboxsync if (pSrcRc->aAllocations[0].SurfDesc.d3dWidth == pDstRc->aAllocations[0].SurfDesc.d3dWidth
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pSrcRc->aAllocations[0].SurfDesc.height == pDstRc->aAllocations[0].SurfDesc.height
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pSrcRc->RcDesc.enmFormat == pDstRc->RcDesc.enmFormat
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pData->SrcRect.left == 0 && pData->SrcRect.top == 0
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pData->SrcRect.right - pData->SrcRect.left == pSrcRc->aAllocations[0].SurfDesc.width
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync && pData->SrcRect.bottom - pData->SrcRect.top == pSrcRc->aAllocations[0].SurfDesc.height)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DBaseTexture9 *pD3DIfSrcTex = (IDirect3DBaseTexture9*)pSrcRc->aAllocations[0].pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DBaseTexture9 *pD3DIfDstTex = (IDirect3DBaseTexture9*)pDstRc->aAllocations[0].pD3DIf;
ac7e45442a6e3b7c01faa0cdc1c48daee049ff59vboxsync hr = pDevice9If->UpdateTexture(pD3DIfSrcTex, pD3DIfDstTex); Assert(hr == S_OK),
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pDstRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pSrcRc->aAllocations[0].enmD3DIfType != VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmRectMoved(&DstRect, &pData->SrcRect, pData->DstPoint.x, pData->DstPoint.y);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync RECT tstRect = {0,0, pDstRc->aAllocations[0].SurfDesc.width, pDstRc->aAllocations[0].SurfDesc.height};
ac7e45442a6e3b7c01faa0cdc1c48daee049ff59vboxsync hr = pDevice9If->StretchRect(pSrcSurfIf, &pData->SrcRect, pDstSurfIf, &DstRect, D3DTEXF_NONE); Assert(hr == S_OK),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(D3DRECT, x1));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(D3DRECT, x2));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(D3DRECT, y1));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DRECT, y2));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DRECT, x1));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DRECT, x2));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DRECT, y1));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DRECT, y2));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->Clear(NumRect, (D3DRECT*)pRect /* see AssertCompile above */,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetViewport(&pDevice->ViewPort);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetViewport(&pDevice->ViewPort);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetClipPlane(pData->Index, pData->Plane);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// VBOXDISPCRHGSMI_SCOPE_SET_DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(DevInfoSize == sizeof (D3DDDIDEVINFO_VCACHE));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DDDIDEVINFO_VCACHE *pVCache = (D3DDDIDEVINFO_VCACHE*)pDevInfoStruct;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pVCache->OptMethod = 0 /* D3DXMESHOPT_STRIPREORDER */;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(sizeof (D3DDDIBOX) == sizeof (D3DBOX));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Left) == RT_SIZEOFMEMB(D3DBOX, Left));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Top) == RT_SIZEOFMEMB(D3DBOX, Top));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Right) == RT_SIZEOFMEMB(D3DBOX, Right));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Bottom) == RT_SIZEOFMEMB(D3DBOX, Bottom));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Front) == RT_SIZEOFMEMB(D3DBOX, Front));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIBOX, Back) == RT_SIZEOFMEMB(D3DBOX, Back));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Left) == RT_OFFSETOF(D3DBOX, Left));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Top) == RT_OFFSETOF(D3DBOX, Top));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Right) == RT_OFFSETOF(D3DBOX, Right));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Bottom) == RT_OFFSETOF(D3DBOX, Bottom));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Front) == RT_OFFSETOF(D3DBOX, Front));
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsyncAssertCompile(RT_OFFSETOF(D3DDDIBOX, Back) == RT_OFFSETOF(D3DBOX, Back));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(pRc != pScreen->pRenderTargetRc || pScreen->iRenderTargetFrontBuf != pData->SubResourceIndex);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync hr = vboxWddmDalCheckLock(pDevice, pAlloc, pData->Flags);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pTexAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DSurface9 *pD3DIfSurface = (IDirect3DSurface9*)pTexAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* else - we lock the entire texture, pRect == NULL */
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.fFlags.AreaValid == pData->Flags.AreaValid);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync if (pAlloc->LockInfo.fFlags.AreaValid && pData->Flags.AreaValid)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Area.left == pData->Area.left);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Area.top == pData->Area.top);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Area.right == pData->Area.right);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Area.bottom == pData->Area.bottom);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert((pAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync if (pAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pD3DIfCubeTex->LockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex),
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync hr = pD3DIfSurface->LockRect(&pAlloc->LockInfo.LockedRect,
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync pData->pSurfData = pAlloc->LockInfo.LockedRect.pBits;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync /* else - we lock the entire texture, pBox == NULL */
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.fFlags.BoxValid == pData->Flags.BoxValid);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync if (pAlloc->LockInfo.fFlags.BoxValid && pData->Flags.BoxValid)
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Box.Left == pData->Box.Left);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Box.Top == pData->Box.Top);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Box.Right == pData->Box.Right);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Box.Bottom == pData->Box.Bottom);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Box.Front == pData->Box.Front);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert(pAlloc->LockInfo.Box.Back == pData->Box.Back);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync Assert((pAlloc->LockInfo.fFlags.Value & ~1) == (pData->Flags.Value & ~1)); /* <- 1 is "ReadOnly" flag */
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync if (pAlloc->LockInfo.fFlags.ReadOnly && !pData->Flags.ReadOnly)
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync pData->pSurfData = pAlloc->LockInfo.LockedBox.pBits;
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync pData->Pitch = pAlloc->LockInfo.LockedBox.RowPitch;
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync pData->SlicePitch = pAlloc->LockInfo.LockedBox.SlicePitch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VERTEXBUFFER)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* else - we lock the entire vertex buffer, pRect == NULL */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!pData->Flags.MightDrawFromLocked || (!pData->Flags.Discard && !pData->Flags.NoOverwrite))
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync Assert(pAlloc->SurfDesc.pitch == pAlloc->SurfDesc.width);
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAlloc->LockInfo.LockedRect.Pitch = pAlloc->SurfDesc.pitch;
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync// Assert(pAlloc->LockInfo.fFlags.Value == 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pAlloc->LockInfo.fFlags.RangeValid = 1;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pAlloc->LockInfo.fFlags.RangeValid = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->LockInfo.fFlags.RangeValid == pData->Flags.RangeValid);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAlloc->LockInfo.fFlags.RangeValid && pData->Flags.RangeValid)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->LockInfo.Range.Offset == pData->Range.Offset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->LockInfo.Range.Size == pData->Range.Size);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pData->pSurfData = pAlloc->LockInfo.LockedRect.pBits;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_INDEXBUFFER)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* else - we lock the entire vertex buffer, pRect == NULL */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!pData->Flags.MightDrawFromLocked || (!pData->Flags.Discard && !pData->Flags.NoOverwrite))
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync Assert(pAlloc->SurfDesc.pitch == pAlloc->SurfDesc.width);
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAlloc->LockInfo.LockedRect.Pitch = pAlloc->SurfDesc.pitch;
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync// Assert(pAlloc->LockInfo.fFlags.Value == 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pAlloc->LockInfo.fFlags.RangeValid = 1;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// pAlloc->LockInfo.fFlags.RangeValid = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->LockInfo.fFlags.RangeValid == pData->Flags.RangeValid);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAlloc->LockInfo.fFlags.RangeValid && pData->Flags.RangeValid)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->LockInfo.Range.Offset == pData->Range.Offset);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pAlloc->LockInfo.Range.Size == pData->Range.Size);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pData->pSurfData = pAlloc->LockInfo.LockedRect.pBits;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->RcDesc.enmPool == D3DDDIPOOL_SYSTEMMEM);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect, pr, false /*bool bToLockInfo*/);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync WARN(("not implemented %d", pRc->aAllocations[0].enmD3DIfType));
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync else /* if !VBOXDISPMODE_IS_3D(pDevice->pAdapter) */
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync offset = vboxWddmCalcOffXYrd(pData->Area.left, pData->Area.top, pAlloc->SurfDesc.pitch, pAlloc->SurfDesc.format);
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync vboxVDbgPrintF((__FUNCTION__": Implement Box area"));
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &LockData);
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync Assert(hr == S_OK || (hr == D3DERR_WASSTILLDRAWING && pData->Flags.DoNotWait));
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync pData->pSurfData = ((uint8_t*)LockData.pData) + offset;
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync /* check if the surface was renamed */
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync /* else - d3d may create sysmem render targets and call our Present callbacks for those
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync * to make it work properly we need to create a VRAM surface corresponding to sysmem one
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync * and copy stuff to VRAM on lock/unlock
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync * so we don't do any locking here, but still track the lock info here
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync * and do lock-memcopy-unlock to VRAM surface on sysmem surface unlock
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync vboxWddmDirtyRegionAddRect(&pAlloc->DirtyRegion, &pData->Area);
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync vboxWddmDirtyRegionAddRect(&pAlloc->DirtyRegion, NULL); /* <- NULL means the entire surface */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(%d)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_TEXTURE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_CUBE_TEXTURE
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_SURFACE)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DTexture9 *pD3DIfTex = (IDirect3DTexture9*)pTexAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pD3DIfTex->UnlockRect(pData->SubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DCubeTexture9 *pD3DIfCubeTex = (IDirect3DCubeTexture9*)pTexAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pD3DIfCubeTex->UnlockRect(VBOXDISP_CUBEMAP_INDEX_TO_FACE(pRc, pData->SubResourceIndex),
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXDISP_CUBEMAP_INDEX_TO_LEVEL(pRc, pData->SubResourceIndex));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DSurface9 *pD3DIfSurf = (IDirect3DSurface9*)pTexAlloc->pD3DIf;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VOLUME_TEXTURE)
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync PVBOXWDDMDISP_ALLOCATION pTexAlloc = &pRc->aAllocations[0];
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync IDirect3DVolumeTexture9 *pD3DIfTex = (IDirect3DVolumeTexture9*)pTexAlloc->pD3DIf;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync hr = pD3DIfTex->UnlockBox(pData->SubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_VERTEXBUFFER)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || (!pAlloc->LockInfo.fFlags.Discard && !pAlloc->LockInfo.fFlags.NoOverwrite)))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(!pAlloc->LockInfo.cLocks);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DVertexBuffer9 *pD3D9VBuf = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is a sysmem texture, update */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAlloc->pvMem && !pAlloc->LockInfo.fFlags.ReadOnly)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync r.right = pAlloc->LockInfo.Range.Offset + pAlloc->LockInfo.Range.Size;
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync true /*bool bToLockInfo*/);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (pRc->aAllocations[0].enmD3DIfType == VBOXDISP_D3DIFTYPE_INDEXBUFFER)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync || (!pAlloc->LockInfo.fFlags.Discard && !pAlloc->LockInfo.fFlags.NoOverwrite)))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(!pAlloc->LockInfo.cLocks);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DIndexBuffer9 *pD3D9IBuf = (IDirect3DIndexBuffer9*)pAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is a sysmem texture, update */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pAlloc->pvMem && !pAlloc->LockInfo.fFlags.ReadOnly)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync r.right = pAlloc->LockInfo.Range.Offset + pAlloc->LockInfo.Range.Size;
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync VBoxD3DIfLockUnlockMemSynch(pAlloc, &pAlloc->LockInfo.LockedRect,
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync true /*bool bToLockInfo*/);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync WARN(("Unlock unsupported %d", pRc->aAllocations[0].enmD3DIfType));
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync hr = pDevice->RtCallbacks.pfnLockCb(pDevice->hDevice, &LockData);
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync LRect.Pitch = ((pAlloc->SurfDesc.bpp * pAlloc->SurfDesc.width) + 7) >> 3;
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync Assert(pAlloc->DirtyRegion.fFlags & VBOXWDDM_DIRTYREGION_F_VALID);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync VBoxD3DIfLockUnlockMemSynch(pAlloc, &LRect, &pAlloc->DirtyRegion.Rect, TRUE /* bool bToLockInfo*/);
46737b2c6b2da473108a7670c3682d88474bd8b9vboxsync hr = pDevice->RtCallbacks.pfnUnlockCb(pDevice->hDevice, &Unlock);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic void vboxWddmRequestAllocFree(D3DDDICB_ALLOCATE* pAlloc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic D3DDDICB_ALLOCATE* vboxWddmRequestAllocAlloc(D3DDDIARG_CREATERESOURCE* pResource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* allocate buffer for D3DDDICB_ALLOCATE + D3DDDI_ALLOCATIONINFO * numAllocs + PVBOXWDDM_RCINFO with aAllocInfos[numAllocs] */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbDdiAllocInfos = sizeof (D3DDDI_ALLOCATIONINFO) * pResource->SurfCount;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cbAllocInfos = sizeof (VBOXWDDM_ALLOCINFO) * pResource->SurfCount;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DDDICB_ALLOCATE* pAlloc = (D3DDDICB_ALLOCATE*)pvBuf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAlloc->pAllocationInfo = (D3DDDI_ALLOCATIONINFO*)(pvBuf + offDdiAllocInfos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)(pvBuf + offRcInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCINFO pAllocInfos = (PVBOXWDDM_ALLOCINFO)(pvBuf + offAllocInfos);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DDDI_ALLOCATIONINFO* pDdiAllocInfo = &pAlloc->pAllocationInfo[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDdiAllocInfo->PrivateDriverDataSize = sizeof (VBOXWDDM_ALLOCINFO);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pResource->SurfCount);
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pRc->RcDesc.enmMultisampleType = pResource->MultisampleType;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pRc->RcDesc.MultisampleQuality = pResource->MultisampleQuality;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pRc->RcDesc.VidPnSourceId = pResource->VidPnSourceId;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAllocation->SurfDesc.slicePitch = pSurf->SysMemSlicePitch;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAllocation->SurfDesc.bpp = vboxWddmCalcBitsPerPixel(pResource->Format);
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAllocation->SurfDesc.pitch = vboxWddmCalcPitch(pSurf->Width, pResource->Format);
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAllocation->SurfDesc.cbSize = vboxWddmCalcSize(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.height, pAllocation->SurfDesc.format);
b19e8ad6294ebaac06a4aed5133c818ae86fa46bvboxsync pAllocation->SurfDesc.VidPnSourceId = pResource->VidPnSourceId;
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync UINT minPitch = vboxWddmCalcPitch(pAllocation->SurfDesc.width, pAllocation->SurfDesc.format);
9441dbf0fb711026d58d0c64d61a6dcfc3c6784dvboxsync pAllocation->SurfDesc.d3dWidth = vboxWddmCalcWidthForPitch(pAllocation->SurfDesc.pitch, pAllocation->SurfDesc.format);
20bc7269cdb015fe47a9a4a0511470f3b26660f8vboxsync Assert(VBOXWDDMDISP_IS_TEXTURE(pRc->RcDesc.fFlags) && !pRc->RcDesc.fFlags.CubeMap); /* <- tested for textures only! */
9441dbf0fb711026d58d0c64d61a6dcfc3c6784dvboxsync Assert(pAllocation->SurfDesc.d3dWidth >= pAllocation->SurfDesc.width);
9441dbf0fb711026d58d0c64d61a6dcfc3c6784dvboxsync Assert(pAllocation->SurfDesc.d3dWidth == pAllocation->SurfDesc.width);
510b103ed7818a1e4b8628c3992a7881aa195996vboxsync if (pRc->RcDesc.fFlags.RenderTarget || pRc->RcDesc.fFlags.Primary)
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync WARN(("VBoxD3DIfCreateForRc failed, hr 0x%x", hr));
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync bIssueCreateResource = (pResource->Pool != D3DDDIPOOL_SYSTEMMEM) || pResource->Flags.RenderTarget;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync D3DDDICB_ALLOCATE *pDdiAllocate = vboxWddmRequestAllocAlloc(pResource);
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync Assert(pDdiAllocate->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync PVBOXWDDM_RCINFO pRcInfo = (PVBOXWDDM_RCINFO)pDdiAllocate->pPrivateDriverData;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync D3DDDI_ALLOCATIONINFO *pDdiAllocI = &pDdiAllocate->pAllocationInfo[i];
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync Assert(pDdiAllocI->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocI->pPrivateDriverData;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync Assert((!!(pSurf->pSysMem)) == (pResource->Pool == D3DDDIPOOL_SYSTEMMEM));
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pDdiAllocI->VidPnSourceId = pResource->VidPnSourceId;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAllocInfo->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync pAllocInfo->hSharedHandle = (uint64_t)pAllocation->hSharedHandle;
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync hr = pAdapter->D3D.D3D.pfnVBoxWineExD3DSurf9GetHostId(pSurfIf, &pAllocInfo->hostID);
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync WARN(("pfnVBoxWineExD3DSurf9GetHostId failed, hr 0x%x", hr));
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsync// Assert(!pRc->fFlags.KmResource);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pDdiAllocate);
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync || pResource->Flags.SharedResource /* for some reason shared resources
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync * are created with zero km resource handle on Win7+ */
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync D3DDDI_ALLOCATIONINFO *pDdiAllocIBase = pDdiAllocate->pAllocationInfo;
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync pDdiAllocate->pAllocationInfo = &pDdiAllocIBase[i];
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync hr = pDevice->RtCallbacks.pfnAllocateCb(pDevice->hDevice, pDdiAllocate);
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync Assert(pDdiAllocate->pAllocationInfo->hAllocation);
ca6db47466081ed9ecacc53249d192ed7a740e97vboxsync for (UINT j = 0; j < i; ++j)
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync HRESULT tmpHr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync D3DDDI_ALLOCATIONINFO *pDdiAllocI = &pDdiAllocate->pAllocationInfo[i];
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocI->pPrivateDriverData;
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync CONST D3DDDI_SURFACEINFO* pSurf = &pResource->pSurfList[i];
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync pAllocation->hAllocation = pDdiAllocI->hAllocation;
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync pAllocation->enmType = VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC;
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared CREATED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), "
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync "Handle(0x%x), (0n%d) \n***********\n\n",
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync pAllocation, pRc->hKMResource, pAllocation->hAllocation,
1e8407a779e6ce2d2326f9b62c7cb82e3ab7b49avboxsync pAllocation->hSharedHandle, pAllocation->hSharedHandle
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)hResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared DESTROYED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), "
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync "Handle(0x%x), (0n%d) \n***********\n\n",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pSwapchain = vboxWddmSwapchainForAlloc(pAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RENDERTGT pRt = vboxWddmSwapchainRtForAlloc(pSwapchain, pAlloc);
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync /* according to the docs the below two are ignored in case we set the hResource */
3a343ca21a267ec3c54e2317e2ed18fe99b8ebbbvboxsync hr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Dealloc.HandleList = &pRc->aAllocations[j].hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT tmpHr = pDevice->RtCallbacks.pfnDeallocateCb(pDevice->hDevice, &Dealloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->cAllocations > pData->SubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice->RtCallbacks.pfnSetDisplayModeCb(pDevice->hDevice, &DdiDm);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncint vboxUhgsmiTst(PVBOXUHGSMI pUhgsmi, uint32_t cbBuf, uint32_t cNumCals, uint64_t * pTimeMs);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// VBOXDISPPROFILE_DDI_CHKDUMPRESET(pDevice);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync PVBOXWDDMDISP_RESOURCE pSrcRc = NULL, pDstRc = NULL;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync PVBOXWDDMDISP_ALLOCATION pSrcAlloc = NULL, pDstAlloc = NULL;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync Assert(pSrcRc->cAllocations > pData->SrcSubResourceIndex);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pSrcAlloc = &pSrcRc->aAllocations[pData->SrcSubResourceIndex];
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync Assert(pDstRc->cAllocations > pData->DstSubResourceIndex);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pDstAlloc = &pDstRc->aAllocations[pData->DstSubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync int rc = vboxUhgsmiTst(&pDevice->Uhgsmi.Base, cbData, cCals, &TimeMs);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync uint32_t cCPS = (((uint64_t)cCals) * 1000ULL)/TimeMs;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync if (pAdapter->u32VBox3DCaps & CR_VBOX_CAP_TEX_PRESENT)
66aed3bb8df40ea21faa032bb04c1cdab35840davboxsync hr = VBoxD3DIfSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pAdapter->D3D.D3D.pfnVBoxWineExD3DSurf9SyncToHost(pSrcSurfIf);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9FlushToHost((IDirect3DDevice9Ex*)pDevice->pDevice9If);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9FlushToHost((IDirect3DDevice9Ex*)pDevice->pDevice9If);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->cAllocations > pData->SrcSubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SrcSubResourceIndex];
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync DdiPresent.hSrcAllocation = pSrcAlloc->hAllocation;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync DdiPresent.hDstAllocation = pDstAlloc->hAllocation;
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync DdiPresent.hContext = pDevice->DefaultContext.ContextInfo.hContext;
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync#if 0 //def VBOX_WDDMDISP_WITH_PROFILE
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync VBoxDispProfileScopeLogger<VBoxDispProfileEntry> profilePresentCbLogger(pDevice->ProfileDdiPresentCb.alloc("pfnPresentCb"));
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync vboxVDbgTimerStart(pDevice->hTimerQueue, &hTimer, 1000);
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync hr = pDevice->RtCallbacks.pfnPresentCb(pDevice->hDevice, &DdiPresent);
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync#if 0 //def VBOX_WDDMDISP_WITH_PROFILE
a7ba3d5f31ca70d04a3933e570374e5ec5eff84avboxsync if (pDevice->ProfileDdiPresentCb.getNumEntries() == 64)
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync hr = pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9Flush((IDirect3DDevice9Ex*)pDevice->pDevice9If);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(sizeof (D3DDDIVERTEXELEMENT) == sizeof (D3DVERTEXELEMENT9));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Stream) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Stream));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Offset) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Offset));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Type) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Method) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Method));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, Usage) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, Usage));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(D3DDDIVERTEXELEMENT, UsageIndex) == RT_SIZEOFMEMB(D3DVERTEXELEMENT9, UsageIndex));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Stream) == RT_OFFSETOF(D3DVERTEXELEMENT9, Stream));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Offset) == RT_OFFSETOF(D3DVERTEXELEMENT9, Offset));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Type) == RT_OFFSETOF(D3DVERTEXELEMENT9, Type));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Method) == RT_OFFSETOF(D3DVERTEXELEMENT9, Method));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, Usage) == RT_OFFSETOF(D3DVERTEXELEMENT9, Usage));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(D3DDDIVERTEXELEMENT, UsageIndex) == RT_OFFSETOF(D3DVERTEXELEMENT9, UsageIndex));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if(memcmp(&DeclEnd, &pVertexElements[pData->NumVertexElements], sizeof (DeclEnd)))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pVe = (D3DVERTEXELEMENT9*)RTMemAlloc(sizeof (D3DVERTEXELEMENT9) * (pData->NumVertexElements + 1));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync memcpy(pVe, pVertexElements, sizeof (D3DVERTEXELEMENT9) * pData->NumVertexElements);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)hShaderHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetVertexDeclaration(pDecl);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DVertexDeclaration9 *pDecl = (IDirect3DVertexDeclaration9*)hShaderHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(*((UINT*)((uint8_t*)pCode + pData->Size-4)) == 0x0000FFFF /* end token */);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->CreateVertexShader((const DWORD *)pCode, &pShader);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DVertexShader9 *pShader = (IDirect3DVertexShader9*)hShaderHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetVertexShaderConstantI(pData->Register, pRegisters, pData->Count);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetVertexShaderConstantB(pData->Register, pRegisters, pData->Count);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hVertexBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pStreamData = (IDirect3DVertexBuffer9*)pAlloc->pD3DIf;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetStreamSource(pData->Stream, pStreamData, pData->Offset, pData->Stride);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->Stream<VBOXWDDMDISP_MAX_VERTEX_STREAMS);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pDevice->aStreamSource[pData->Stream] && !pAlloc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync else if (!pDevice->aStreamSource[pData->Stream] && pAlloc)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pDevice->cStreamSources <= RT_ELEMENTS(pDevice->aStreamSource));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevice->StreamSourceInfo[pData->Stream].uiOffset = pData->Offset;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevice->StreamSourceInfo[pData->Stream].uiStride = pData->Stride;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_STREAMSOURCEUM pStrSrcUm = &pDevice->aStreamSourceUm[pData->Stream];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync HRESULT hr = pDevice9If->SetStreamSourceFreq(pData->Stream, pData->Divider);
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync /* test it more */
53df0e82d39a90814d16b3df01ca0687e6ced2dfvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// PVBOXWDDMDISP_SCREEN pScreen = &pDevice->aScreens[pDevice->iPrimaryScreen];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pDstRc = (PVBOXWDDMDISP_RESOURCE)pData->hDstResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pSrcRc = (PVBOXWDDMDISP_RESOURCE)pData->hSrcResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pDstRc->cAllocations > pData->DstSubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pSrcRc->cAllocations > pData->SrcSubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pSrcAlloc = &pSrcRc->aAllocations[pData->SrcSubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pDstAlloc = &pDstRc->aAllocations[pData->DstSubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pSrcSwapchain = vboxWddmSwapchainForAlloc(pSrcAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_SWAPCHAIN pDstSwapchain = vboxWddmSwapchainForAlloc(pDstAlloc);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* try StretchRect */
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync Assert(!pDstSwapchain || vboxWddmSwapchainGetFb(pDstSwapchain)->pAlloc != pDstAlloc || vboxWddmSwapchainNumRTs(pDstSwapchain) == 1);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync hr = VBoxD3DIfSurfGet(pDstRc, pData->DstSubResourceIndex, &pDstSurfIf);
eb2d4958f7faf812c3bdb2d7587d815022f0bd55vboxsync hr = vboxWddmSwapchainSurfGet(pDevice, pSrcSwapchain, pSrcAlloc, &pSrcSurfIf);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync hr = VBoxD3DIfSurfGet(pSrcRc, pData->SrcSubResourceIndex, &pSrcSurfIf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we support only Point & Linear, we ignore [Begin|Continue|End]PresentToDwm */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert((pData->Flags.Value & (~(0x00000100 | 0x00000200 | 0x00000400 | 0x00000001 | 0x00000002))) == 0);
ac7e45442a6e3b7c01faa0cdc1c48daee049ff59vboxsync VBOXVDBG_CHECK_BLT(hr = pDevice9If->StretchRect(pSrcSurfIf, &pData->SrcRect, pDstSurfIf, &pData->DstRect, vboxDDI2D3DBltFlags(pData->Flags)); Assert(hr == S_OK),
ac7e45442a6e3b7c01faa0cdc1c48daee049ff59vboxsync pSrcAlloc, pSrcSurfIf, &pData->SrcRect, pDstAlloc, pDstSurfIf, &pData->DstRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* todo: fallback to memcpy or whatever ? */
9cdd4d805ecb43126372f7cf12e4032836cb738avboxsync PVBOXWDDMDISP_ALLOCATION pDAlloc = &pDstRc->aAllocations[pData->DstSubResourceIndex];
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsync pDAlloc = &pSrcRc->aAllocations[pData->SrcSubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hResource;
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync HRESULT hr = VBoxD3DIfSurfGet(pRc, pData->SubResourceIndex, &pSurfIf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice9If->ColorFill(pSurfIf, &pData->DstRect, pData->Color);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: check what need to do when PresentToDwm flag is set */
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsync PVBOXWDDMDISP_ALLOCATION pDAlloc = &pRc->aAllocations[pData->SubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
2ecff1c2f70f10cf06821afc18116b764c53fb5evboxsync//@todo: vboxWddmDalCheckAdd(pDevice, pDAlloc, TRUE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)RTMemAllocZ(sizeof (VBOXWDDMDISP_QUERY));
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync hr = pDevice9If->CreateQuery(vboxDDI2D3DQueryType(pData->QueryType), &pQuery->pQueryIf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)hQuery;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)pData->hQuery;
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync hr = pQuery->pQueryIf->Issue(vboxDDI2D3DIssueQueryFlags(pData->Flags));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_QUERY pQuery = (PVBOXWDDMDISP_QUERY)pData->hQuery;
fc50d11e45d83ecb4fbb2a6761d1adb5d6cc268fvboxsync hr = pQuery->pQueryIf->GetData(pData->pData, cbData, 0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hRenderTarget;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->SubResourceIndex < pRc->cAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = vboxWddmRenderTargetSet(pDevice, pData->RenderTargetIndex, pAlloc, FALSE);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hZBuffer;
2eed70acbc887ff6ba5bcc935cb50f46cf834b5avboxsync hr = pDevice9If->SetDepthStencilSurface(pD3D9Surf);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetPixelShaderConstantI(pData->Register, pRegisters, pData->Count);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->SetPixelShaderConstantB(pData->Register, pRegisters, pData->Count);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DDevice9 * pDevice9If = VBOXDISP_D3DEV(pDevice);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(*((UINT*)((uint8_t*)pCode + pData->CodeSize-4)) == 0x0000FFFF /* end token */);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice9If->CreatePixelShader((const DWORD *)pCode, &pShader);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync IDirect3DPixelShader9 *pShader = (IDirect3DPixelShader9*)hShaderHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p), hr(0x%x)\n", hDevice, hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync VBOXDISPPROFILE_DDI_PRINT(("Dumping on DestroyDevice: 0x%p", pDevice));
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync DeleteTimerQueueEx(pDevice->hTimerQueue, INVALID_HANDLE_VALUE /* see term */);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = pDevice->pAdapter;
71d34382c90482c97bd863ad9e814c511e6a3cdbvboxsync /* ensure the device is destroyed in any way.
71d34382c90482c97bd863ad9e814c511e6a3cdbvboxsync * Release may not work in case of some leaking, which will leave the crOgl context refering the destroyed VBOXUHGSMI */
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync pDevice->pAdapter->D3D.D3D.pfnVBoxWineExD3DDev9Term((IDirect3DDevice9Ex *)pDevice->pDevice9If);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = vboxDispCmCtxDestroy(pDevice, &pDevice->DefaultContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(sizeof (RECT) == sizeof (D3DDDIRECT));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, left) == RT_SIZEOFMEMB(D3DDDIRECT, left));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, right) == RT_SIZEOFMEMB(D3DDDIRECT, right));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, top) == RT_SIZEOFMEMB(D3DDDIRECT, top));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_SIZEOFMEMB(RECT, bottom) == RT_SIZEOFMEMB(D3DDDIRECT, bottom));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, left) == RT_OFFSETOF(D3DDDIRECT, left));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, right) == RT_OFFSETOF(D3DDDIRECT, right));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, top) == RT_OFFSETOF(D3DDDIRECT, top));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncAssertCompile(RT_OFFSETOF(RECT, bottom) == RT_OFFSETOF(D3DDDIRECT, bottom));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->cAllocations > pData->OverlayInfo.SubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)RTMemAllocZ(sizeof (VBOXWDDMDISP_OVERLAY));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.DstRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.DstRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.SrcRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.SrcRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice->RtCallbacks.pfnCreateOverlayCb(pDevice->hDevice, &OverInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we have reported the dirty rect, may clear it if no locks are pending currently */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->OverlayInfo.hResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRc->cAllocations > pData->OverlayInfo.SubResourceIndex);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->OverlayInfo.SubResourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.DstColorKeyLow = pData->OverlayInfo.DstColorKeyLow;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.DstColorKeyHigh = pData->OverlayInfo.DstColorKeyHigh;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.SrcColorKeyLow = pData->OverlayInfo.SrcColorKeyLow;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.SrcColorKeyHigh = pData->OverlayInfo.SrcColorKeyHigh;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OurInfo.OverlayDesc.fFlags = pData->OverlayInfo.Flags.Value;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.hAllocation = pAlloc->hAllocation;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.DstRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.DstRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.SrcRect = *(D3DDDIRECT*)((void*)&pData->OverlayInfo.SrcRect);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.pPrivateDriverData = &OurInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync OverInfo.OverlayInfo.PrivateDriverDataSize = sizeof (OurInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice->RtCallbacks.pfnUpdateOverlayCb(pDevice->hDevice, &OverInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we have reported the dirty rect, may clear it if no locks are pending currently */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->hSource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[pData->SourceIndex];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxWddmDirtyRegionUnite(&OurInfo.DirtyRegion, &pAlloc->DirtyRegion);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pDevice->RtCallbacks.pfnFlipOverlayCb(pDevice->hDevice, &OverInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* we have reported the dirty rect, may clear it if no locks are pending currently */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_OVERLAY pOverlay = (PVBOXWDDMDISP_OVERLAY)pData->hOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT hr = pDevice->RtCallbacks.pfnDestroyOverlayCb(pDevice->hDevice, &OverInfo);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo check residency for the "real" allocations */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = (PVBOXWDDMDISP_RESOURCE)pData->pHandleList[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_RESOURCE pRc = vboxResourceAlloc(pData->NumAllocations);
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync PVBOXWDDMDISP_ALLOCATION pAllocation = &pRc->aAllocations[i];
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync D3DDDI_OPENALLOCATIONINFO* pOAI = pData->pOpenAllocationInfo;
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync Assert(pOAI->PrivateDriverDataSize == sizeof (VBOXWDDM_ALLOCINFO));
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync if (pOAI->PrivateDriverDataSize != sizeof (VBOXWDDM_ALLOCINFO))
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pOAI->pPrivateDriverData;
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync pAllocation->hSharedHandle = (HANDLE)pAllocInfo->hSharedHandle;
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync Assert(!pAllocation->hSharedHandle == (pAllocation->enmType == VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE));
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync vboxVDbgPrint(("\n\n********\n(0x%x:0n%d)Shared OPENNED pAlloc(0x%p), hRc(0x%p), hAl(0x%p), "
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync "Handle(0x%x), (0n%d) \n***********\n\n",
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync pAllocation, pRc->hKMResource, pAllocation->hAllocation,
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync pAllocation->hSharedHandle, pAllocation->hSharedHandle
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (!pData->pPrivateDriverData || !pData->PrivateDriverDataSize)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is a "standard" allocation resource */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* both should be actually zero */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(!pData->pPrivateDriverData && !pData->PrivateDriverDataSize);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRc->RcDesc.enmMultisampleType = D3DDDIMULTISAMPLE_NONE;
1c0d3d017f9a45748b4839bf6622b53e83a4f1f8vboxsync /*pRc->RcDesc.Fvf;*/
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync WARN(("NumAllocations is expected to be 1, but was %d", pData->NumAllocations));
dc4c9f05c58012e8b1f0bfdd12b2e14fc2f228devboxsync PVBOXWDDMDISP_ALLOCATION pAlloc = &pRc->aAllocations[i];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync D3DDDI_OPENALLOCATIONINFO* pDdiAllocInfo = &pData->pOpenAllocationInfo[0];
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pDdiAllocInfo->pPrivateDriverData && pDdiAllocInfo->PrivateDriverDataSize >= sizeof (VBOXWDDM_ALLOCINFO))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDM_ALLOCINFO pAllocInfo = (PVBOXWDDM_ALLOCINFO)pDdiAllocInfo->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRc->RcDesc.enmFormat = pAllocInfo->SurfDesc.format;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRc->RcDesc.VidPnSourceId = pAllocInfo->SurfDesc.VidPnSourceId;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pRc->RcDesc.RefreshRate = pAllocInfo->SurfDesc.RefreshRate;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* this is a "generic" resource whose creation is initiated by the UMD */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync if (pData->PrivateDriverDataSize == sizeof (VBOXWDDM_RCINFO))
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync VBOXWDDM_RCINFO *pRcInfo = (VBOXWDDM_RCINFO*)pData->pPrivateDriverData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync Assert(pRcInfo->cAllocInfos == pData->NumAllocations);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintR((__FUNCTION__": vboxResourceAlloc failed for hDevice(0x%p), NumAllocations(%d)\n", hDevice, pData->NumAllocations));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)hDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), Interface(%d), Version(%d)\n", hAdapter, pCreateData->Interface, pCreateData->Version));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// Assert(0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_DEVICE, apRTs[pAdapter->D3D.cMaxSimRTs]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* Set Viewport to some default values */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
b9e12f78cf07f58665c0e0b2b0abba1ce7f02a5dvboxsync pDevice->ProfileDdiPresentCb = VBoxDispProfileSet("pfnPresentCb");
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = vboxDispCmCtxCreate(pDevice, &pDevice->DefaultContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.BackBufferWidth = 640;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.BackBufferHeight = 480;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.BackBufferCount = 0;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.hDeviceWindow = hWnd;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* @todo: it seems there should be a way to detect this correctly since
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync * our vboxWddmDDevSetDisplayMode will be called in case we are using full-screen */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.EnableAutoDepthStencil = FALSE;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.AutoDepthStencilFormat = D3DFMT_UNKNOWN;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.Flags;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.FullScreen_RefreshRateInHz;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync // params.FullScreen_PresentationInterval;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = vboxWddmD3DDeviceCreate(pDevice, 0, pRc, ¶ms, TRUE /*BOOL bLockable*/);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync//# define VBOXDISP_TEST_SWAPCHAIN
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync HRESULT tmpHr = vboxDispCmCtxDestroy(pDevice, &pDevice->DefaultContext);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d), AllocationListSize(%d)\n",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pCreateData->PatchLocationListSize, pCreateData->AllocationListSize));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync //pCreateData->pAllocationList = ??
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
91457726912962e04a49fec67f20c0c16dfafff4vboxsync if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS,
91457726912962e04a49fec67f20c0c16dfafff4vboxsync WARN(("GetModuleHandleEx failed winEr %d, ignoring", winEr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsyncstatic HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync VBoxDispD3DGlobalClose(&pAdapter->D3D, &pAdapter->Formats);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync#define VBOXDISP_IS_MODULE_FUNC(_pvModule, _cbModule, _pfn) ( \
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync (((uintptr_t)(_pfn)) >= ((uintptr_t)(_pvModule))) \
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync && (((uintptr_t)(_pfn)) < (((uintptr_t)(_pvModule)) + ((DWORD)(_cbModule)))) \
d96688617f02ce5b9fcd681610cd048057f1027bvboxsyncstatic BOOL vboxDispIsDDraw(__inout D3DDDIARG_OPENADAPTER* pOpenData)
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync /*if we are loaded by ddraw module, the Interface version should be 7
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync * and pAdapterCallbacks should be ddraw-supplied, i.e. reside in ddraw module */
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync if (!GetModuleInformation(hProcess, hDDraw, &ModuleInfo, sizeof (ModuleInfo)))
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync if (VBOXDISP_IS_MODULE_FUNC(ModuleInfo.lpBaseOfDll, ModuleInfo.SizeOfImage, pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb))
d96688617f02ce5b9fcd681610cd048057f1027bvboxsync if (VBOXDISP_IS_MODULE_FUNC(ModuleInfo.lpBaseOfDll, ModuleInfo.SizeOfImage, pOpenData->pAdapterCallbacks->pfnGetMultisampleMethodListCb))
d64aa881df34a86dd70ab0e1b7b94ffa41be9731vboxsyncHRESULT APIENTRY OpenAdapter(__inout D3DDDIARG_OPENADAPTER* pOpenData)
7c0d72e9b85a62859b5fff2c7c8a072ba63141e1vboxsync#if 0 //def DEBUG_misha
cafde3c9008a124039e59720afbbc49002521ebfvboxsync dwMajorVersion = (DWORD)(LOBYTE(LOWORD(dwVersion)));
cafde3c9008a124039e59720afbbc49002521ebfvboxsync dwMinorVersion = (DWORD)(HIBYTE(LOWORD(dwVersion)));
cafde3c9008a124039e59720afbbc49002521ebfvboxsync if (dwMajorVersion == 6 && dwMinorVersion <= 1 && VBOXVDBG_IS_DWM())
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxDispLock();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync hr = pOpenData->pAdapterCallbacks->pfnQueryAdapterInfoCb(pOpenData->hAdapter, &DdiQuery);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintR((__FUNCTION__": pfnQueryAdapterInfoCb failed, hr (%d)\n", hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* check the miniport version match display version */
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintR((__FUNCTION__": miniport version mismatch, expected (%d), but was (%d)\n",
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(RT_OFFSETOF(VBOXWDDMDISP_ADAPTER, aHeads[Query.cInfos]));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync /* try enable the 3D */
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync hr = VBoxDispD3DGlobalOpen(&pAdapter->D3D, &pAdapter->Formats);
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync LOG(("SUCCESS 3D Enabled, pAdapter (0x%p)", pAdapter));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync pAdapter->aHeads[i].Vhwa.Settings = Query.aInfos[i];
476e82bf26ef67545d5c97b8226d0679be2974fevboxsync WARN(("VBoxDispD3DGlobal2DFormatsInit failed hr 0x%x", hr));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync } while (0);
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync// vboxDispUnlock();
9055f61bb57d2a625c6434d55beac7565c3b3c0dvboxsync vboxVDbgPrint(("<== "__FUNCTION__", hr (%d)\n", hr));