VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Display/wddm/VBoxDispD3D.cpp@ 29452

Last change on this file since 29452 was 29452, checked in by vboxsync, 15 years ago

wddm/3d: make wine directly use VBoxOGL.dll instead of opengl32.dll
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 46.1 KB
Line 
1/** @file
2 *
3 * VBoxVideo Display D3D User mode dll
4 *
5 * Copyright (C) 2010 Oracle Corporation
6 *
7 * This file is part of VirtualBox Open Source Edition (OSE), as
8 * available from http://www.virtualbox.org. This file is free software;
9 * you can redistribute it and/or modify it under the terms of the GNU
10 * General Public License (GPL) as published by the Free Software
11 * Foundation, in version 2 as it comes in the "COPYING" file of the
12 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
13 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
14 */
15#include <windows.h>
16#include <d3d9types.h>
17//#include <d3dtypes.h>
18#include <D3dumddi.h>
19#include <d3dhal.h>
20
21
22#include <iprt/initterm.h>
23#include <iprt/log.h>
24#include <iprt/mem.h>
25
26#include <VBox/Log.h>
27
28#include <VBox/VBoxGuestLib.h>
29
30#include "VBoxDispD3D.h"
31#include "VBoxDispD3DCmn.h"
32
33#ifdef VBOXWDDMDISP_DEBUG
34# include <stdio.h>
35#endif
36
37/**
38 * DLL entry point.
39 */
40BOOL WINAPI DllMain(HINSTANCE hInstance,
41 DWORD dwReason,
42 LPVOID lpReserved)
43{
44 switch (dwReason)
45 {
46 case DLL_PROCESS_ATTACH:
47 {
48 RTR3Init();
49
50 vboxVDbgPrint(("VBoxDispD3D: DLL loaded.\n"));
51
52// VbglR3Init();
53 break;
54 }
55
56 case DLL_PROCESS_DETACH:
57 {
58 vboxVDbgPrint(("VBoxDispD3D: DLL unloaded.\n"));
59// VbglR3Term();
60 /// @todo RTR3Term();
61 break;
62 }
63
64 default:
65 break;
66 }
67 return TRUE;
68}
69
70static HRESULT APIENTRY vboxWddmDispGetCaps (HANDLE hAdapter, CONST D3DDDIARG_GETCAPS* pData)
71{
72 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
73
74 HRESULT hr = S_OK;
75
76 switch (pData->Type)
77 {
78 case D3DDDICAPS_DDRAW:
79 Assert(pData->DataSize >= sizeof (DDRAW_CAPS));
80 if (pData->DataSize >= sizeof (DDRAW_CAPS))
81 memset(pData->pData, 0, sizeof (DDRAW_CAPS));
82 else
83 hr = E_INVALIDARG;
84 break;
85 case D3DDDICAPS_DDRAW_MODE_SPECIFIC:
86 Assert(pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS));
87 if (pData->DataSize >= sizeof (DDRAW_MODE_SPECIFIC_CAPS))
88 memset(pData->pData, 0, sizeof (DDRAW_MODE_SPECIFIC_CAPS));
89 else
90 hr = E_INVALIDARG;
91 break;
92 case D3DDDICAPS_GETFORMATCOUNT:
93 *((uint32_t*)pData->pData) = 0;
94 break;
95 case D3DDDICAPS_GETFORMATDATA:
96 /* TODO: fill the array of FORMATOP structures of size reported with D3DDDICAPS_GETFORMATCOUNT (currently 0) */
97 break;
98 case D3DDDICAPS_GETD3DQUERYCOUNT:
99 *((uint32_t*)pData->pData) = 0;
100 break;
101 case D3DDDICAPS_GETD3D3CAPS:
102 Assert(pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA));
103 if (pData->DataSize >= sizeof (D3DHAL_GLOBALDRIVERDATA))
104 memset (pData->pData, 0, sizeof (D3DHAL_GLOBALDRIVERDATA));
105 else
106 hr = E_INVALIDARG;
107 break;
108 case D3DDDICAPS_GETD3D7CAPS:
109 Assert(pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS));
110 if (pData->DataSize >= sizeof (D3DHAL_D3DEXTENDEDCAPS))
111 memset(pData->pData, 0, sizeof (D3DHAL_D3DEXTENDEDCAPS));
112 else
113 hr = E_INVALIDARG;
114 break;
115 case D3DDDICAPS_GETD3D9CAPS:
116 Assert(pData->DataSize >= sizeof (D3DCAPS9));
117 if (pData->DataSize >= sizeof (D3DCAPS9))
118 memset(pData->pData, 0, sizeof (D3DCAPS9));
119 else
120 hr = E_INVALIDARG;
121 break;
122 case D3DDDICAPS_GETGAMMARAMPCAPS:
123 *((uint32_t*)pData->pData) = 0;
124 break;
125 case D3DDDICAPS_GETMULTISAMPLEQUALITYLEVELS:
126 case D3DDDICAPS_GETD3DQUERYDATA:
127 case D3DDDICAPS_GETD3D5CAPS:
128 case D3DDDICAPS_GETD3D6CAPS:
129 case D3DDDICAPS_GETD3D8CAPS:
130 case D3DDDICAPS_GETDECODEGUIDCOUNT:
131 case D3DDDICAPS_GETDECODEGUIDS:
132 case D3DDDICAPS_GETDECODERTFORMATCOUNT:
133 case D3DDDICAPS_GETDECODERTFORMATS:
134 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFOCOUNT:
135 case D3DDDICAPS_GETDECODECOMPRESSEDBUFFERINFO:
136 case D3DDDICAPS_GETDECODECONFIGURATIONCOUNT:
137 case D3DDDICAPS_GETDECODECONFIGURATIONS:
138 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDCOUNT:
139 case D3DDDICAPS_GETVIDEOPROCESSORDEVICEGUIDS:
140 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATCOUNT:
141 case D3DDDICAPS_GETVIDEOPROCESSORRTFORMATS:
142 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATCOUNT:
143 case D3DDDICAPS_GETVIDEOPROCESSORRTSUBSTREAMFORMATS:
144 case D3DDDICAPS_GETVIDEOPROCESSORCAPS:
145 case D3DDDICAPS_GETPROCAMPRANGE:
146 case D3DDDICAPS_FILTERPROPERTYRANGE:
147 case D3DDDICAPS_GETEXTENSIONGUIDCOUNT:
148 case D3DDDICAPS_GETEXTENSIONGUIDS:
149 case D3DDDICAPS_GETEXTENSIONCAPS:
150 vboxVDbgPrint((__FUNCTION__": unimplemented caps type(%d)\n", pData->Type));
151 AssertBreakpoint();
152 if (pData->pData && pData->DataSize)
153 memset(pData->pData, 0, pData->DataSize);
154 break;
155 default:
156 vboxVDbgPrint((__FUNCTION__": unknown caps type(%d)\n", pData->Type));
157 AssertBreakpoint();
158 }
159
160 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p), caps type(%d)\n", hAdapter, pData->Type));
161
162 return S_OK;
163}
164
165static HRESULT APIENTRY vboxWddmDDevSetRenderState(HANDLE hDevice, CONST D3DDDIARG_RENDERSTATE* pData)
166{
167 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
168 AssertBreakpoint();
169 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
170 return E_FAIL;
171}
172
173static HRESULT APIENTRY vboxWddmDDevUpdateWInfo(HANDLE hDevice, CONST D3DDDIARG_WINFO* pData)
174{
175 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
176 AssertBreakpoint();
177 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
178 return E_FAIL;
179}
180
181static HRESULT APIENTRY vboxWddmDDevValidateDevice(HANDLE hDevice, D3DDDIARG_VALIDATETEXTURESTAGESTATE* pData)
182{
183 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
184 AssertBreakpoint();
185 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
186 return E_FAIL;
187}
188
189static HRESULT APIENTRY vboxWddmDDevSetTextureStageState(HANDLE hDevice, CONST D3DDDIARG_TEXTURESTAGESTATE* pData)
190{
191 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
192 AssertBreakpoint();
193 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
194 return E_FAIL;
195}
196
197static HRESULT APIENTRY vboxWddmDDevSetTexture(HANDLE hDevice, UINT Stage, HANDLE hTexture)
198{
199 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
200 AssertBreakpoint();
201 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
202 return E_FAIL;
203}
204
205static HRESULT APIENTRY vboxWddmDDevSetPixelShader(HANDLE hDevice, HANDLE hShaderHandle)
206{
207 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
208 AssertBreakpoint();
209 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
210 return E_FAIL;
211}
212
213static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONST* pData, CONST FLOAT* pRegisters)
214{
215 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
216 AssertBreakpoint();
217 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
218 return E_FAIL;
219}
220
221static HRESULT APIENTRY vboxWddmDDevSetStreamSourceUm(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEUM* pData, CONST VOID* pUMBuffer )
222{
223 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
224 AssertBreakpoint();
225 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
226 return E_FAIL;
227}
228
229static HRESULT APIENTRY vboxWddmDDevSetIndices(HANDLE hDevice, CONST D3DDDIARG_SETINDICES* pData)
230{
231 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
232 AssertBreakpoint();
233 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
234 return E_FAIL;
235}
236
237static HRESULT APIENTRY vboxWddmDDevSetIndicesUm(HANDLE hDevice, UINT IndexSize, CONST VOID* pUMBuffer)
238{
239 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
240 AssertBreakpoint();
241 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
242 return E_FAIL;
243}
244
245static HRESULT APIENTRY vboxWddmDDevDrawPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE* pData, CONST UINT* pFlagBuffer)
246{
247 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
248 AssertBreakpoint();
249 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
250 return E_FAIL;
251}
252
253static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE* pData)
254{
255 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
256 AssertBreakpoint();
257 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
258 return E_FAIL;
259}
260
261static HRESULT APIENTRY vboxWddmDDevDrawRectPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWRECTPATCH* pData, CONST D3DDDIRECTPATCH_INFO* pInfo, CONST FLOAT* pPatch)
262{
263 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
264 AssertBreakpoint();
265 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
266 return E_FAIL;
267}
268
269static HRESULT APIENTRY vboxWddmDDevDrawTriPatch(HANDLE hDevice, CONST D3DDDIARG_DRAWTRIPATCH* pData, CONST D3DDDITRIPATCH_INFO* pInfo, CONST FLOAT* pPatch)
270{
271 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
272 AssertBreakpoint();
273 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
274 return E_FAIL;
275}
276
277static HRESULT APIENTRY vboxWddmDDevDrawPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWPRIMITIVE2* pData)
278{
279 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
280 AssertBreakpoint();
281 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
282 return E_FAIL;
283}
284
285static HRESULT APIENTRY vboxWddmDDevDrawIndexedPrimitive2(HANDLE hDevice, CONST D3DDDIARG_DRAWINDEXEDPRIMITIVE2* pData, UINT dwIndicesSize, CONST VOID* pIndexBuffer, CONST UINT* pFlagBuffer)
286{
287 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
288 AssertBreakpoint();
289 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
290 return E_FAIL;
291}
292
293static HRESULT APIENTRY vboxWddmDDevVolBlt(HANDLE hDevice, CONST D3DDDIARG_VOLUMEBLT* pData)
294{
295 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
296 AssertBreakpoint();
297 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
298 return E_FAIL;
299}
300
301static HRESULT APIENTRY vboxWddmDDevBufBlt(HANDLE hDevice, CONST D3DDDIARG_BUFFERBLT* pData)
302{
303 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
304 AssertBreakpoint();
305 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
306 return E_FAIL;
307}
308
309static HRESULT APIENTRY vboxWddmDDevTexBlt(HANDLE hDevice, CONST D3DDDIARG_TEXBLT* pData)
310{
311 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
312 AssertBreakpoint();
313 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
314 return E_FAIL;
315}
316
317static HRESULT APIENTRY vboxWddmDDevStateSet(HANDLE hDevice, D3DDDIARG_STATESET* pData)
318{
319 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
320 AssertBreakpoint();
321 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
322 return E_FAIL;
323}
324static HRESULT APIENTRY vboxWddmDDevSetPriority(HANDLE hDevice, CONST D3DDDIARG_SETPRIORITY* pData)
325{
326 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
327 AssertBreakpoint();
328 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
329 return E_FAIL;
330}
331static HRESULT APIENTRY vboxWddmDDevClear(HANDLE hDevice, CONST D3DDDIARG_CLEAR* pData, UINT NumRect, CONST RECT* pRect)
332{
333 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
334 AssertBreakpoint();
335 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
336 return E_FAIL;
337}
338static HRESULT APIENTRY vboxWddmDDevUpdatePalette(HANDLE hDevice, CONST D3DDDIARG_UPDATEPALETTE* pData, CONST PALETTEENTRY* pPaletteData)
339{
340 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
341 AssertBreakpoint();
342 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
343 return E_FAIL;
344}
345
346static HRESULT APIENTRY vboxWddmDDevSetPalette(HANDLE hDevice, CONST D3DDDIARG_SETPALETTE* pData)
347{
348 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
349 AssertBreakpoint();
350 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
351 return E_FAIL;
352}
353
354static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConst(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONST* pData , CONST VOID* pRegisters)
355{
356 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
357 AssertBreakpoint();
358 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
359 return E_FAIL;
360}
361static HRESULT APIENTRY vboxWddmDDevMultiplyTransform(HANDLE hDevice, CONST D3DDDIARG_MULTIPLYTRANSFORM* pData)
362{
363 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
364 AssertBreakpoint();
365 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
366 return E_FAIL;
367}
368static HRESULT APIENTRY vboxWddmDDevSetTransform(HANDLE hDevice, CONST D3DDDIARG_SETTRANSFORM* pData)
369{
370 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
371 AssertBreakpoint();
372 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
373 return E_FAIL;
374}
375static HRESULT APIENTRY vboxWddmDDevSetViewport(HANDLE hDevice, CONST D3DDDIARG_VIEWPORTINFO* pData)
376{
377 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
378 AssertBreakpoint();
379 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
380 return E_FAIL;
381}
382static HRESULT APIENTRY vboxWddmDDevSetZRange(HANDLE hDevice, CONST D3DDDIARG_ZRANGE* pData)
383{
384 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
385 AssertBreakpoint();
386 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
387 return E_FAIL;
388}
389static HRESULT APIENTRY vboxWddmDDevSetMaterial(HANDLE hDevice, CONST D3DDDIARG_SETMATERIAL* pData)
390{
391 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
392 AssertBreakpoint();
393 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
394 return E_FAIL;
395}
396static HRESULT APIENTRY vboxWddmDDevSetLight(HANDLE hDevice, CONST D3DDDIARG_SETLIGHT* pData, CONST D3DDDI_LIGHT* pLightProperties)
397{
398 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
399 AssertBreakpoint();
400 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
401 return E_FAIL;
402}
403static HRESULT APIENTRY vboxWddmDDevCreateLight(HANDLE hDevice, CONST D3DDDIARG_CREATELIGHT* pData)
404{
405 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
406 AssertBreakpoint();
407 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
408 return E_FAIL;
409}
410static HRESULT APIENTRY vboxWddmDDevDestroyLight(HANDLE hDevice, CONST D3DDDIARG_DESTROYLIGHT* pData)
411{
412 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
413 AssertBreakpoint();
414 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
415 return E_FAIL;
416}
417static HRESULT APIENTRY vboxWddmDDevSetClipPlane(HANDLE hDevice, CONST D3DDDIARG_SETCLIPPLANE* pData)
418{
419 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
420 AssertBreakpoint();
421 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
422 return E_FAIL;
423}
424
425static HRESULT APIENTRY vboxWddmDDevGetInfo(HANDLE hDevice, UINT DevInfoID, VOID* pDevInfoStruct, UINT DevInfoSize)
426{
427 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
428 AssertBreakpoint();
429 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
430 return E_NOTIMPL;
431}
432
433static HRESULT APIENTRY vboxWddmDDevLock(HANDLE hDevice, D3DDDIARG_LOCK* pData)
434{
435 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
436 AssertBreakpoint();
437 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
438 return E_FAIL;
439}
440static HRESULT APIENTRY vboxWddmDDevUnlock(HANDLE hDevice, CONST D3DDDIARG_UNLOCK* pData)
441{
442 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
443 AssertBreakpoint();
444 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
445 return E_FAIL;
446}
447static HRESULT APIENTRY vboxWddmDDevLockAsync(HANDLE hDevice, D3DDDIARG_LOCKASYNC* pData)
448{
449 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
450 AssertBreakpoint();
451 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
452 return E_FAIL;
453}
454static HRESULT APIENTRY vboxWddmDDevUnlockAsync(HANDLE hDevice, CONST D3DDDIARG_UNLOCKASYNC* pData)
455{
456 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
457 AssertBreakpoint();
458 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
459 return E_FAIL;
460}
461static HRESULT APIENTRY vboxWddmDDevRename(HANDLE hDevice, CONST D3DDDIARG_RENAME* pData)
462{
463 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
464 AssertBreakpoint();
465 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
466 return E_FAIL;
467}
468static HRESULT APIENTRY vboxWddmDDevCreateResource(HANDLE hDevice, D3DDDIARG_CREATERESOURCE* pResource)
469{
470 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
471 AssertBreakpoint();
472 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
473 return E_FAIL;
474}
475static HRESULT APIENTRY vboxWddmDDevDestroyResource(HANDLE hDevice, HANDLE hResource)
476{
477 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
478 AssertBreakpoint();
479 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
480 return E_FAIL;
481}
482static HRESULT APIENTRY vboxWddmDDevSetDisplayMode(HANDLE hDevice, CONST D3DDDIARG_SETDISPLAYMODE* pData)
483{
484 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
485 AssertBreakpoint();
486 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
487 return E_FAIL;
488}
489static HRESULT APIENTRY vboxWddmDDevPresent(HANDLE hDevice, CONST D3DDDIARG_PRESENT* pData)
490{
491 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
492 AssertBreakpoint();
493 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
494 return E_FAIL;
495}
496static HRESULT APIENTRY vboxWddmDDevFlush(HANDLE hDevice)
497{
498 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
499 AssertBreakpoint();
500 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
501 return E_FAIL;
502}
503static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderDecl(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERDECL* pData, CONST D3DDDIVERTEXELEMENT* pVertexElements)
504{
505 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
506 AssertBreakpoint();
507 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
508 return E_FAIL;
509}
510static HRESULT APIENTRY vboxWddmDDevSetVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
511{
512 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
513 AssertBreakpoint();
514 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
515 return E_FAIL;
516}
517static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderDecl(HANDLE hDevice, HANDLE hShaderHandle)
518{
519 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
520 AssertBreakpoint();
521 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
522 return E_FAIL;
523}
524static HRESULT APIENTRY vboxWddmDDevCreateVertexShaderFunc(HANDLE hDevice, D3DDDIARG_CREATEVERTEXSHADERFUNC* pData, CONST UINT* pCode)
525{
526 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
527 AssertBreakpoint();
528 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
529 return E_FAIL;
530}
531static HRESULT APIENTRY vboxWddmDDevSetVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
532{
533 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
534 AssertBreakpoint();
535 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
536 return E_FAIL;
537}
538static HRESULT APIENTRY vboxWddmDDevDeleteVertexShaderFunc(HANDLE hDevice, HANDLE hShaderHandle)
539{
540 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
541 AssertBreakpoint();
542 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
543 return E_FAIL;
544}
545static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTI* pData, CONST INT* pRegisters)
546{
547 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
548 AssertBreakpoint();
549 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
550 return E_FAIL;
551}
552static HRESULT APIENTRY vboxWddmDDevSetVertexShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETVERTEXSHADERCONSTB* pData, CONST BOOL* pRegisters)
553{
554 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
555 AssertBreakpoint();
556 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
557 return E_FAIL;
558}
559static HRESULT APIENTRY vboxWddmDDevSetScissorRect(HANDLE hDevice, CONST RECT* pRect)
560{
561 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
562 AssertBreakpoint();
563 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
564 return E_FAIL;
565}
566static HRESULT APIENTRY vboxWddmDDevSetStreamSource(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCE* pData)
567{
568 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
569 AssertBreakpoint();
570 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
571 return E_FAIL;
572}
573static HRESULT APIENTRY vboxWddmDDevSetStreamSourceFreq(HANDLE hDevice, CONST D3DDDIARG_SETSTREAMSOURCEFREQ* pData)
574{
575 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
576 AssertBreakpoint();
577 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
578 return E_FAIL;
579}
580static HRESULT APIENTRY vboxWddmDDevSetConvolutionKernelMono(HANDLE hDevice, CONST D3DDDIARG_SETCONVOLUTIONKERNELMONO* pData)
581{
582 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
583 AssertBreakpoint();
584 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
585 return E_FAIL;
586}
587static HRESULT APIENTRY vboxWddmDDevComposeRects(HANDLE hDevice, CONST D3DDDIARG_COMPOSERECTS* pData)
588{
589 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
590 AssertBreakpoint();
591 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
592 return E_FAIL;
593}
594static HRESULT APIENTRY vboxWddmDDevBlt(HANDLE hDevice, CONST D3DDDIARG_BLT* pData)
595{
596 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
597 AssertBreakpoint();
598 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
599 return E_FAIL;
600}
601static HRESULT APIENTRY vboxWddmDDevColorFill(HANDLE hDevice, CONST D3DDDIARG_COLORFILL* pData)
602{
603 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
604 AssertBreakpoint();
605 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
606 return E_FAIL;
607}
608static HRESULT APIENTRY vboxWddmDDevDepthFill(HANDLE hDevice, CONST D3DDDIARG_DEPTHFILL* pData)
609{
610 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
611 AssertBreakpoint();
612 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
613 return E_FAIL;
614}
615static HRESULT APIENTRY vboxWddmDDevCreateQuery(HANDLE hDevice, D3DDDIARG_CREATEQUERY* pData)
616{
617 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
618 AssertBreakpoint();
619 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
620 return E_FAIL;
621}
622static HRESULT APIENTRY vboxWddmDDevDestroyQuery(HANDLE hDevice, HANDLE hQuery)
623{
624 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
625 AssertBreakpoint();
626 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
627 return E_FAIL;
628}
629static HRESULT APIENTRY vboxWddmDDevIssueQuery(HANDLE hDevice, CONST D3DDDIARG_ISSUEQUERY* pData)
630{
631 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
632 AssertBreakpoint();
633 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
634 return E_FAIL;
635}
636static HRESULT APIENTRY vboxWddmDDevGetQueryData(HANDLE hDevice, CONST D3DDDIARG_GETQUERYDATA* pData)
637{
638 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
639 AssertBreakpoint();
640 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
641 return E_FAIL;
642}
643static HRESULT APIENTRY vboxWddmDDevSetRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETRENDERTARGET* pData)
644{
645 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
646 AssertBreakpoint();
647 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
648 return E_FAIL;
649}
650static HRESULT APIENTRY vboxWddmDDevSetDepthStencil(HANDLE hDevice, CONST D3DDDIARG_SETDEPTHSTENCIL* pData)
651{
652 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
653 AssertBreakpoint();
654 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
655 return E_FAIL;
656}
657static HRESULT APIENTRY vboxWddmDDevGenerateMipSubLevels(HANDLE hDevice, CONST D3DDDIARG_GENERATEMIPSUBLEVELS* pData)
658{
659 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
660 AssertBreakpoint();
661 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
662 return E_FAIL;
663}
664static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstI(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTI* pData, CONST INT* pRegisters)
665{
666 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
667 AssertBreakpoint();
668 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
669 return E_FAIL;
670}
671static HRESULT APIENTRY vboxWddmDDevSetPixelShaderConstB(HANDLE hDevice, CONST D3DDDIARG_SETPIXELSHADERCONSTB* pData, CONST BOOL* pRegisters)
672{
673 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
674 AssertBreakpoint();
675 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
676 return E_FAIL;
677}
678static HRESULT APIENTRY vboxWddmDDevCreatePixelShader(HANDLE hDevice, D3DDDIARG_CREATEPIXELSHADER* pData, CONST UINT* pCode)
679{
680 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
681 AssertBreakpoint();
682 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
683 return E_FAIL;
684}
685static HRESULT APIENTRY vboxWddmDDevDeletePixelShader(HANDLE hDevice, HANDLE hShaderHandle)
686{
687 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
688 AssertBreakpoint();
689 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
690 return E_FAIL;
691}
692static HRESULT APIENTRY vboxWddmDDevCreateDecodeDevice(HANDLE hDevice, D3DDDIARG_CREATEDECODEDEVICE* pData)
693{
694 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
695 AssertBreakpoint();
696 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
697 return E_FAIL;
698}
699static HRESULT APIENTRY vboxWddmDDevDestroyDecodeDevice(HANDLE hDevice, HANDLE hDecodeDevice)
700{
701 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
702 AssertBreakpoint();
703 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
704 return E_FAIL;
705}
706static HRESULT APIENTRY vboxWddmDDevSetDecodeRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETDECODERENDERTARGET* pData)
707{
708 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
709 AssertBreakpoint();
710 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
711 return E_FAIL;
712}
713static HRESULT APIENTRY vboxWddmDDevDecodeBeginFrame(HANDLE hDevice, D3DDDIARG_DECODEBEGINFRAME* pData)
714{
715 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
716 AssertBreakpoint();
717 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
718 return E_FAIL;
719}
720static HRESULT APIENTRY vboxWddmDDevDecodeEndFrame(HANDLE hDevice, D3DDDIARG_DECODEENDFRAME* pData)
721{
722 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
723 AssertBreakpoint();
724 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
725 return E_FAIL;
726}
727static HRESULT APIENTRY vboxWddmDDevDecodeExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXECUTE* pData)
728{
729 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
730 AssertBreakpoint();
731 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
732 return E_FAIL;
733}
734static HRESULT APIENTRY vboxWddmDDevDecodeExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_DECODEEXTENSIONEXECUTE* pData)
735{
736 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
737 AssertBreakpoint();
738 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
739 return E_FAIL;
740}
741static HRESULT APIENTRY vboxWddmDDevCreateVideoProcessDevice(HANDLE hDevice, D3DDDIARG_CREATEVIDEOPROCESSDEVICE* pData)
742{
743 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
744 AssertBreakpoint();
745 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
746 return E_FAIL;
747}
748static HRESULT APIENTRY vboxWddmDDevDestroyVideoProcessDevice(HANDLE hDevice, HANDLE hVideoProcessor)
749{
750 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
751 AssertBreakpoint();
752 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
753 return E_FAIL;
754}
755static HRESULT APIENTRY vboxWddmDDevVideoProcessBeginFrame(HANDLE hDevice, HANDLE hVideoProcess)
756{
757 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
758 AssertBreakpoint();
759 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
760 return E_FAIL;
761}
762static HRESULT APIENTRY vboxWddmDDevVideoProcessEndFrame(HANDLE hDevice, D3DDDIARG_VIDEOPROCESSENDFRAME* pData)
763{
764 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
765 AssertBreakpoint();
766 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
767 return E_FAIL;
768}
769static HRESULT APIENTRY vboxWddmDDevSetVideoProcessRenderTarget(HANDLE hDevice, CONST D3DDDIARG_SETVIDEOPROCESSRENDERTARGET* pData)
770{
771 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
772 AssertBreakpoint();
773 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
774 return E_FAIL;
775}
776static HRESULT APIENTRY vboxWddmDDevVideoProcessBlt(HANDLE hDevice, CONST D3DDDIARG_VIDEOPROCESSBLT* pData)
777{
778 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
779 AssertBreakpoint();
780 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
781 return E_FAIL;
782}
783static HRESULT APIENTRY vboxWddmDDevCreateExtensionDevice(HANDLE hDevice, D3DDDIARG_CREATEEXTENSIONDEVICE* pData)
784{
785 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
786 AssertBreakpoint();
787 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
788 return E_FAIL;
789}
790static HRESULT APIENTRY vboxWddmDDevDestroyExtensionDevice(HANDLE hDevice, HANDLE hExtension)
791{
792 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
793 AssertBreakpoint();
794 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
795 return E_FAIL;
796}
797static HRESULT APIENTRY vboxWddmDDevExtensionExecute(HANDLE hDevice, CONST D3DDDIARG_EXTENSIONEXECUTE* pData)
798{
799 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
800 AssertBreakpoint();
801 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
802 return E_FAIL;
803}
804static HRESULT APIENTRY vboxWddmDDevDestroyDevice(IN HANDLE hDevice)
805{
806 RTMemFree(hDevice);
807 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
808 AssertBreakpoint();
809 RTMemFree(hDevice);
810 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
811 return S_OK;
812}
813static HRESULT APIENTRY vboxWddmDDevCreateOverlay(HANDLE hDevice, D3DDDIARG_CREATEOVERLAY* pData)
814{
815 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
816 AssertBreakpoint();
817 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
818 return E_FAIL;
819}
820static HRESULT APIENTRY vboxWddmDDevUpdateOverlay(HANDLE hDevice, CONST D3DDDIARG_UPDATEOVERLAY* pData)
821{
822 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
823 AssertBreakpoint();
824 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
825 return E_FAIL;
826}
827static HRESULT APIENTRY vboxWddmDDevFlipOverlay(HANDLE hDevice, CONST D3DDDIARG_FLIPOVERLAY* pData)
828{
829 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
830 AssertBreakpoint();
831 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
832 return E_FAIL;
833}
834static HRESULT APIENTRY vboxWddmDDevGetOverlayColorControls(HANDLE hDevice, D3DDDIARG_GETOVERLAYCOLORCONTROLS* pData)
835{
836 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
837 AssertBreakpoint();
838 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
839 return E_FAIL;
840}
841static HRESULT APIENTRY vboxWddmDDevSetOverlayColorControls(HANDLE hDevice, CONST D3DDDIARG_SETOVERLAYCOLORCONTROLS* pData)
842{
843 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
844 AssertBreakpoint();
845 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
846 return E_FAIL;
847}
848static HRESULT APIENTRY vboxWddmDDevDestroyOverlay(HANDLE hDevice, CONST D3DDDIARG_DESTROYOVERLAY* pData)
849{
850 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
851 AssertBreakpoint();
852 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
853 return E_FAIL;
854}
855static HRESULT APIENTRY vboxWddmDDevQueryResourceResidency(HANDLE hDevice, CONST D3DDDIARG_QUERYRESOURCERESIDENCY* pData)
856{
857 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
858 AssertBreakpoint();
859 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
860 return E_FAIL;
861}
862static HRESULT APIENTRY vboxWddmDDevOpenResource(HANDLE hDevice, D3DDDIARG_OPENRESOURCE* pData)
863{
864 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
865 AssertBreakpoint();
866 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
867 return E_FAIL;
868}
869static HRESULT APIENTRY vboxWddmDDevGetCaptureAllocationHandle(HANDLE hDevice, D3DDDIARG_GETCAPTUREALLOCATIONHANDLE* pData)
870{
871 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
872 AssertBreakpoint();
873 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
874 return E_FAIL;
875}
876
877static HRESULT APIENTRY vboxWddmDDevCaptureToSysMem(HANDLE hDevice, CONST D3DDDIARG_CAPTURETOSYSMEM* pData)
878{
879 vboxVDbgPrintF(("<== "__FUNCTION__", hDevice(0x%p)\n", hDevice));
880 AssertBreakpoint();
881 vboxVDbgPrintF(("==> "__FUNCTION__", hDevice(0x%p)\n", hDevice));
882 return E_FAIL;
883}
884
885static HRESULT APIENTRY vboxWddmDispCreateDevice (IN HANDLE hAdapter, IN D3DDDIARG_CREATEDEVICE* pCreateData)
886{
887 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
888
889// AssertBreakpoint();
890
891 PVBOXWDDMDISP_DEVICE pDevice = (PVBOXWDDMDISP_DEVICE)RTMemAllocZ(sizeof (VBOXWDDMDISP_DEVICE));
892 if (!pDevice)
893 {
894 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
895 return E_OUTOFMEMORY;
896 }
897
898 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
899
900 pDevice->hDevice = pCreateData->hDevice;
901 pDevice->pAdapter = pAdapter;
902 pDevice->u32IfVersion = pCreateData->Interface;
903 pDevice->uRtVersion = pCreateData->Version;
904 pDevice->RtCallbacks = *pCreateData->pCallbacks;
905 pDevice->pvCmdBuffer = pCreateData->pCommandBuffer;
906 pDevice->cbCmdBuffer = pCreateData->CommandBufferSize;
907 pDevice->fFlags = pCreateData->Flags;
908 Assert(!pCreateData->AllocationListSize);
909 if (pCreateData->AllocationListSize)
910 {
911 vboxVDbgPrintR((__FUNCTION__": Not implemented: AllocationListSize(%d)\n", pCreateData->AllocationListSize));
912 //pCreateData->pAllocationList = ??
913 return E_FAIL;
914 }
915
916 Assert(!pCreateData->PatchLocationListSize);
917 if (pCreateData->PatchLocationListSize)
918 {
919 vboxVDbgPrintR((__FUNCTION__": Not implemented: PatchLocationListSize(%d)\n", pCreateData->PatchLocationListSize));
920 //pCreateData->pPatchLocationList = ??
921 return E_FAIL;
922 }
923
924 pCreateData->pDeviceFuncs->pfnSetRenderState = vboxWddmDDevSetRenderState;
925 pCreateData->pDeviceFuncs->pfnUpdateWInfo = vboxWddmDDevUpdateWInfo;
926 pCreateData->pDeviceFuncs->pfnValidateDevice = vboxWddmDDevValidateDevice;
927 pCreateData->pDeviceFuncs->pfnSetTextureStageState = vboxWddmDDevSetTextureStageState;
928 pCreateData->pDeviceFuncs->pfnSetTexture = vboxWddmDDevSetTexture;
929 pCreateData->pDeviceFuncs->pfnSetPixelShader = vboxWddmDDevSetPixelShader;
930 pCreateData->pDeviceFuncs->pfnSetPixelShaderConst = vboxWddmDDevSetPixelShaderConst;
931 pCreateData->pDeviceFuncs->pfnSetStreamSourceUm = vboxWddmDDevSetStreamSourceUm;
932 pCreateData->pDeviceFuncs->pfnSetIndices = vboxWddmDDevSetIndices;
933 pCreateData->pDeviceFuncs->pfnSetIndicesUm = vboxWddmDDevSetIndicesUm;
934 pCreateData->pDeviceFuncs->pfnDrawPrimitive = vboxWddmDDevDrawPrimitive;
935 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive = vboxWddmDDevDrawIndexedPrimitive;
936 pCreateData->pDeviceFuncs->pfnDrawRectPatch = vboxWddmDDevDrawRectPatch;
937 pCreateData->pDeviceFuncs->pfnDrawTriPatch = vboxWddmDDevDrawTriPatch;
938 pCreateData->pDeviceFuncs->pfnDrawPrimitive2 = vboxWddmDDevDrawPrimitive2;
939 pCreateData->pDeviceFuncs->pfnDrawIndexedPrimitive2 = vboxWddmDDevDrawIndexedPrimitive2;
940 pCreateData->pDeviceFuncs->pfnVolBlt = vboxWddmDDevVolBlt;
941 pCreateData->pDeviceFuncs->pfnBufBlt = vboxWddmDDevBufBlt;
942 pCreateData->pDeviceFuncs->pfnTexBlt = vboxWddmDDevTexBlt;
943 pCreateData->pDeviceFuncs->pfnStateSet = vboxWddmDDevStateSet;
944 pCreateData->pDeviceFuncs->pfnSetPriority = vboxWddmDDevSetPriority;
945 pCreateData->pDeviceFuncs->pfnClear = vboxWddmDDevClear;
946 pCreateData->pDeviceFuncs->pfnUpdatePalette = vboxWddmDDevUpdatePalette;
947 pCreateData->pDeviceFuncs->pfnSetPalette = vboxWddmDDevSetPalette;
948 pCreateData->pDeviceFuncs->pfnSetVertexShaderConst = vboxWddmDDevSetVertexShaderConst;
949 pCreateData->pDeviceFuncs->pfnMultiplyTransform = vboxWddmDDevMultiplyTransform;
950 pCreateData->pDeviceFuncs->pfnSetTransform = vboxWddmDDevSetTransform;
951 pCreateData->pDeviceFuncs->pfnSetViewport = vboxWddmDDevSetViewport;
952 pCreateData->pDeviceFuncs->pfnSetZRange = vboxWddmDDevSetZRange;
953 pCreateData->pDeviceFuncs->pfnSetMaterial = vboxWddmDDevSetMaterial;
954 pCreateData->pDeviceFuncs->pfnSetLight = vboxWddmDDevSetLight;
955 pCreateData->pDeviceFuncs->pfnCreateLight = vboxWddmDDevCreateLight;
956 pCreateData->pDeviceFuncs->pfnDestroyLight = vboxWddmDDevDestroyLight;
957 pCreateData->pDeviceFuncs->pfnSetClipPlane = vboxWddmDDevSetClipPlane;
958 pCreateData->pDeviceFuncs->pfnGetInfo = vboxWddmDDevGetInfo;
959 pCreateData->pDeviceFuncs->pfnLock = vboxWddmDDevLock;
960 pCreateData->pDeviceFuncs->pfnUnlock = vboxWddmDDevUnlock;
961 pCreateData->pDeviceFuncs->pfnCreateResource = vboxWddmDDevCreateResource;
962 pCreateData->pDeviceFuncs->pfnDestroyResource = vboxWddmDDevDestroyResource;
963 pCreateData->pDeviceFuncs->pfnSetDisplayMode = vboxWddmDDevSetDisplayMode;
964 pCreateData->pDeviceFuncs->pfnPresent = vboxWddmDDevPresent;
965 pCreateData->pDeviceFuncs->pfnFlush = vboxWddmDDevFlush;
966 pCreateData->pDeviceFuncs->pfnCreateVertexShaderFunc = vboxWddmDDevCreateVertexShaderFunc;
967 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderFunc = vboxWddmDDevDeleteVertexShaderFunc;
968 pCreateData->pDeviceFuncs->pfnSetVertexShaderFunc = vboxWddmDDevSetVertexShaderFunc;
969 pCreateData->pDeviceFuncs->pfnCreateVertexShaderDecl = vboxWddmDDevCreateVertexShaderDecl;
970 pCreateData->pDeviceFuncs->pfnDeleteVertexShaderDecl = vboxWddmDDevDeleteVertexShaderDecl;
971 pCreateData->pDeviceFuncs->pfnSetVertexShaderDecl = vboxWddmDDevSetVertexShaderDecl;
972 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstI = vboxWddmDDevSetVertexShaderConstI;
973 pCreateData->pDeviceFuncs->pfnSetVertexShaderConstB = vboxWddmDDevSetVertexShaderConstB;
974 pCreateData->pDeviceFuncs->pfnSetScissorRect = vboxWddmDDevSetScissorRect;
975 pCreateData->pDeviceFuncs->pfnSetStreamSource = vboxWddmDDevSetStreamSource;
976 pCreateData->pDeviceFuncs->pfnSetStreamSourceFreq = vboxWddmDDevSetStreamSourceFreq;
977 pCreateData->pDeviceFuncs->pfnSetConvolutionKernelMono = vboxWddmDDevSetConvolutionKernelMono;
978 pCreateData->pDeviceFuncs->pfnComposeRects = vboxWddmDDevComposeRects;
979 pCreateData->pDeviceFuncs->pfnBlt = vboxWddmDDevBlt;
980 pCreateData->pDeviceFuncs->pfnColorFill = vboxWddmDDevColorFill;
981 pCreateData->pDeviceFuncs->pfnDepthFill = vboxWddmDDevDepthFill;
982 pCreateData->pDeviceFuncs->pfnCreateQuery = vboxWddmDDevCreateQuery;
983 pCreateData->pDeviceFuncs->pfnDestroyQuery = vboxWddmDDevDestroyQuery;
984 pCreateData->pDeviceFuncs->pfnIssueQuery = vboxWddmDDevIssueQuery;
985 pCreateData->pDeviceFuncs->pfnGetQueryData = vboxWddmDDevGetQueryData;
986 pCreateData->pDeviceFuncs->pfnSetRenderTarget = vboxWddmDDevSetRenderTarget;
987 pCreateData->pDeviceFuncs->pfnSetDepthStencil = vboxWddmDDevSetDepthStencil;
988 pCreateData->pDeviceFuncs->pfnGenerateMipSubLevels = vboxWddmDDevGenerateMipSubLevels;
989 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstI = vboxWddmDDevSetPixelShaderConstI;
990 pCreateData->pDeviceFuncs->pfnSetPixelShaderConstB = vboxWddmDDevSetPixelShaderConstB;
991 pCreateData->pDeviceFuncs->pfnCreatePixelShader = vboxWddmDDevCreatePixelShader;
992 pCreateData->pDeviceFuncs->pfnDeletePixelShader = vboxWddmDDevDeletePixelShader;
993 pCreateData->pDeviceFuncs->pfnCreateDecodeDevice = vboxWddmDDevCreateDecodeDevice;
994 pCreateData->pDeviceFuncs->pfnDestroyDecodeDevice = vboxWddmDDevDestroyDecodeDevice;
995 pCreateData->pDeviceFuncs->pfnSetDecodeRenderTarget = vboxWddmDDevSetDecodeRenderTarget;
996 pCreateData->pDeviceFuncs->pfnDecodeBeginFrame = vboxWddmDDevDecodeBeginFrame;
997 pCreateData->pDeviceFuncs->pfnDecodeEndFrame = vboxWddmDDevDecodeEndFrame;
998 pCreateData->pDeviceFuncs->pfnDecodeExecute = vboxWddmDDevDecodeExecute;
999 pCreateData->pDeviceFuncs->pfnDecodeExtensionExecute = vboxWddmDDevDecodeExtensionExecute;
1000 pCreateData->pDeviceFuncs->pfnCreateVideoProcessDevice = vboxWddmDDevCreateVideoProcessDevice;
1001 pCreateData->pDeviceFuncs->pfnDestroyVideoProcessDevice = vboxWddmDDevDestroyVideoProcessDevice;
1002 pCreateData->pDeviceFuncs->pfnVideoProcessBeginFrame = vboxWddmDDevVideoProcessBeginFrame;
1003 pCreateData->pDeviceFuncs->pfnVideoProcessEndFrame = vboxWddmDDevVideoProcessEndFrame;
1004 pCreateData->pDeviceFuncs->pfnSetVideoProcessRenderTarget = vboxWddmDDevSetVideoProcessRenderTarget;
1005 pCreateData->pDeviceFuncs->pfnVideoProcessBlt = vboxWddmDDevVideoProcessBlt;
1006 pCreateData->pDeviceFuncs->pfnCreateExtensionDevice = vboxWddmDDevCreateExtensionDevice;
1007 pCreateData->pDeviceFuncs->pfnDestroyExtensionDevice = vboxWddmDDevDestroyExtensionDevice;
1008 pCreateData->pDeviceFuncs->pfnExtensionExecute = vboxWddmDDevExtensionExecute;
1009 pCreateData->pDeviceFuncs->pfnCreateOverlay = vboxWddmDDevCreateOverlay;
1010 pCreateData->pDeviceFuncs->pfnUpdateOverlay = vboxWddmDDevUpdateOverlay;
1011 pCreateData->pDeviceFuncs->pfnFlipOverlay = vboxWddmDDevFlipOverlay;
1012 pCreateData->pDeviceFuncs->pfnGetOverlayColorControls = vboxWddmDDevGetOverlayColorControls;
1013 pCreateData->pDeviceFuncs->pfnSetOverlayColorControls = vboxWddmDDevSetOverlayColorControls;
1014 pCreateData->pDeviceFuncs->pfnDestroyOverlay = vboxWddmDDevDestroyOverlay;
1015 pCreateData->pDeviceFuncs->pfnDestroyDevice = vboxWddmDDevDestroyDevice;
1016 pCreateData->pDeviceFuncs->pfnQueryResourceResidency = vboxWddmDDevQueryResourceResidency;
1017 pCreateData->pDeviceFuncs->pfnOpenResource = vboxWddmDDevOpenResource;
1018 pCreateData->pDeviceFuncs->pfnGetCaptureAllocationHandle = vboxWddmDDevGetCaptureAllocationHandle;
1019 pCreateData->pDeviceFuncs->pfnCaptureToSysMem = vboxWddmDDevCaptureToSysMem;
1020 pCreateData->pDeviceFuncs->pfnLockAsync = NULL; //vboxWddmDDevLockAsync;
1021 pCreateData->pDeviceFuncs->pfnUnlockAsync = NULL; //vboxWddmDDevUnlockAsync;
1022 pCreateData->pDeviceFuncs->pfnRename = NULL; //vboxWddmDDevRename;
1023
1024 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1025
1026 return S_OK;
1027}
1028
1029static HRESULT APIENTRY vboxWddmDispCloseAdapter (IN HANDLE hAdapter)
1030{
1031 vboxVDbgPrint(("==> "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1032
1033// AssertBreakpoint();
1034
1035 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)hAdapter;
1036 if (pAdapter->pD3D9If)
1037 {
1038 HRESULT hr = pAdapter->pD3D9If->Release();
1039 Assert(hr == S_OK);
1040 VBoxDispD3DClose(&pAdapter->D3D);
1041 }
1042
1043 RTMemFree(pAdapter);
1044
1045 vboxVDbgPrint(("<== "__FUNCTION__", hAdapter(0x%p)\n", hAdapter));
1046
1047 return S_OK;
1048}
1049
1050HRESULT APIENTRY OpenAdapter (__inout D3DDDIARG_OPENADAPTER* pOpenData)
1051{
1052 vboxVDbgPrint(("==> "__FUNCTION__"\n"));
1053
1054// AssertBreakpoint();
1055
1056 HRESULT hr = S_OK;
1057 PVBOXWDDMDISP_ADAPTER pAdapter = (PVBOXWDDMDISP_ADAPTER)RTMemAllocZ(sizeof (VBOXWDDMDISP_ADAPTER));
1058 Assert(pAdapter);
1059 if (pAdapter)
1060 {
1061 pAdapter->hAdapter = pOpenData->hAdapter;
1062 pAdapter->uIfVersion = pOpenData->Interface;
1063 pAdapter->uRtVersion= pOpenData->Version;
1064 pAdapter->RtCallbacks = *pOpenData->pAdapterCallbacks;
1065
1066 pOpenData->hAdapter = pAdapter;
1067 pOpenData->pAdapterFuncs->pfnGetCaps = vboxWddmDispGetCaps;
1068 pOpenData->pAdapterFuncs->pfnCreateDevice = vboxWddmDispCreateDevice;
1069 pOpenData->pAdapterFuncs->pfnCloseAdapter = vboxWddmDispCloseAdapter;
1070 pOpenData->DriverVersion = D3D_UMD_INTERFACE_VERSION;
1071
1072 /* try enable the 3D */
1073 hr = VBoxDispD3DOpen(&pAdapter->D3D);
1074 Assert(hr == S_OK);
1075 if (hr == S_OK)
1076 {
1077 hr = pAdapter->D3D.pfnDirect3DCreate9Ex(D3D_SDK_VERSION, &pAdapter->pD3D9If);
1078 Assert(hr == S_OK);
1079 if (hr == S_OK)
1080 {
1081 vboxVDbgPrint(("<== "__FUNCTION__", SUCCESS 3D Enabled, pAdapter (0x%p)\n", pAdapter));
1082 return S_OK;
1083 }
1084 else
1085 vboxVDbgPrintR((__FUNCTION__": pfnDirect3DCreate9Ex failed, hr (%d)\n", hr));
1086 }
1087 else
1088 vboxVDbgPrintR((__FUNCTION__": VBoxDispD3DOpen failed, hr (%d)\n", hr));
1089
1090 vboxVDbgPrint(("<== "__FUNCTION__", SUCCESS 3D DISABLED, pAdapter (0x%p)\n", pAdapter));
1091 return S_OK;
1092// RTMemFree(pAdapter);
1093 }
1094 else
1095 {
1096 vboxVDbgPrintR((__FUNCTION__": RTMemAllocZ returned NULL\n"));
1097 hr = E_OUTOFMEMORY;
1098 }
1099
1100 vboxVDbgPrint(("<== "__FUNCTION__", FAILURE, hr (%d)\n", hr));
1101
1102 return hr;
1103}
1104
1105#ifdef VBOXWDDMDISP_DEBUG
1106VOID vboxVDbgDoPrint(LPCSTR szString, ...)
1107{
1108 char szBuffer[1024] = {0};
1109 va_list pArgList;
1110 va_start(pArgList, szString);
1111 _vsnprintf(szBuffer, sizeof(szBuffer) / sizeof(szBuffer[0]), szString, pArgList);
1112 va_end(pArgList);
1113
1114 OutputDebugStringA(szBuffer);
1115}
1116#endif
Note: See TracBrowser for help on using the repository browser.

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