DevVGA-SVGA3d-win.cpp@ 82609

Last change on this file since 82609 was 82609, checked in by vboxsync, 5 years ago
Devices/Graphics: pThis -> pThisCC.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 247.3 KB

Line
1	/* $Id: DevVGA-SVGA3d-win.cpp 82609 2019-12-17 17:07:20Z vboxsync $ */
2	/** @file
3	* DevVMWare - VMWare SVGA device
4	*/
5
6	/*
7	* Copyright (C) 2013-2019 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
23	#include <VBox/vmm/pdmdev.h>
24	#include <VBox/version.h>
25	#include <VBox/err.h>
26	#include <VBox/log.h>
27	#include <VBox/vmm/pgm.h>
28	#include <VBox/AssertGuest.h>
29
30	#include <iprt/assert.h>
31	#include <iprt/semaphore.h>
32	#include <iprt/uuid.h>
33	#include <iprt/mem.h>
34	#include <iprt/avl.h>
35
36	#include <VBoxVideo.h> /* required by DevVGA.h */
37
38	/* should go BEFORE any other DevVGA include to make all DevVGA.h config defines be visible */
39	#include "DevVGA.h"
40
41	#include "DevVGA-SVGA.h"
42	#include "DevVGA-SVGA3d.h"
43	#include "DevVGA-SVGA3d-internal.h"
44
45	/* Enable to disassemble defined shaders. */
46	#if defined(DEBUG) && 0 /* Disabled as we don't have the DirectX SDK avaible atm. */
47	#define DUMP_SHADER_DISASSEMBLY
48	#endif
49
50	#ifdef DUMP_SHADER_DISASSEMBLY
51	#include <d3dx9shader.h>
52	#endif
53
54
55	/*********************************************************************************************************************************
56	* Defined Constants And Macros *
57	*********************************************************************************************************************************/
58
59	#define FOURCC_INTZ (D3DFORMAT)MAKEFOURCC('I', 'N', 'T', 'Z')
60	#define FOURCC_NULL (D3DFORMAT)MAKEFOURCC('N', 'U', 'L', 'L')
61
62
63	/*********************************************************************************************************************************
64	* Structures and Typedefs *
65	*********************************************************************************************************************************/
66
67	typedef struct
68	{
69	DWORD Usage;
70	D3DRESOURCETYPE ResourceType;
71	SVGA3dFormatOp FormatOp;
72	} VMSVGA3DFORMATSUPPORT;
73
74
75	/*********************************************************************************************************************************
76	* Global Variables *
77	*********************************************************************************************************************************/
78	static VMSVGA3DFORMATSUPPORT const g_aFormatSupport[] =
79	{
80	{
81	0,
82	D3DRTYPE_SURFACE,
83	SVGA3DFORMAT_OP_OFFSCREENPLAIN,
84	},
85	{
86	D3DUSAGE_RENDERTARGET,
87	D3DRTYPE_SURFACE,
88	(SVGA3dFormatOp) (SVGA3DFORMAT_OP_OFFSCREEN_RENDERTARGET \| SVGA3DFORMAT_OP_SAME_FORMAT_RENDERTARGET),
89	},
90	{
91	D3DUSAGE_AUTOGENMIPMAP,
92	D3DRTYPE_TEXTURE,
93	SVGA3DFORMAT_OP_AUTOGENMIPMAP,
94	},
95	{
96	D3DUSAGE_DMAP,
97	D3DRTYPE_TEXTURE,
98	SVGA3DFORMAT_OP_DMAP,
99	},
100	{
101	0,
102	D3DRTYPE_TEXTURE,
103	SVGA3DFORMAT_OP_TEXTURE,
104	},
105	{
106	0,
107	D3DRTYPE_CUBETEXTURE,
108	SVGA3DFORMAT_OP_CUBETEXTURE,
109	},
110	{
111	0,
112	D3DRTYPE_VOLUMETEXTURE,
113	SVGA3DFORMAT_OP_VOLUMETEXTURE,
114	},
115	{
116	D3DUSAGE_QUERY_VERTEXTEXTURE,
117	D3DRTYPE_TEXTURE,
118	SVGA3DFORMAT_OP_VERTEXTEXTURE,
119	},
120	{
121	D3DUSAGE_QUERY_LEGACYBUMPMAP,
122	D3DRTYPE_TEXTURE,
123	SVGA3DFORMAT_OP_BUMPMAP,
124	},
125	{
126	D3DUSAGE_QUERY_SRGBREAD,
127	D3DRTYPE_TEXTURE,
128	SVGA3DFORMAT_OP_SRGBREAD,
129	},
130	{
131	D3DUSAGE_QUERY_SRGBWRITE,
132	D3DRTYPE_TEXTURE,
133	SVGA3DFORMAT_OP_SRGBWRITE,
134	}
135	};
136
137	static VMSVGA3DFORMATSUPPORT const g_aFeatureReject[] =
138	{
139	{
140	D3DUSAGE_QUERY_WRAPANDMIP,
141	D3DRTYPE_TEXTURE,
142	SVGA3DFORMAT_OP_NOTEXCOORDWRAPNORMIP
143	},
144	{
145	D3DUSAGE_QUERY_FILTER,
146	D3DRTYPE_TEXTURE,
147	SVGA3DFORMAT_OP_NOFILTER
148	},
149	{
150	D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING,
151	D3DRTYPE_TEXTURE, /* ?? */
152	SVGA3DFORMAT_OP_NOALPHABLEND
153	},
154	};
155
156
157	/*********************************************************************************************************************************
158	* Internal Functions *
159	*********************************************************************************************************************************/
160	static void vmsvgaDumpD3DCaps(D3DCAPS9 pCaps, D3DADAPTER_IDENTIFIER9 const pai9);
161
162
163	int vmsvga3dInit(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
164	{
165	RT_NOREF(pDevIns, pThis);
166
167	PVMSVGA3DSTATE pState;
168	pThisCC->svga.p3dState = pState = (PVMSVGA3DSTATE)RTMemAllocZ(sizeof(VMSVGA3DSTATE));
169	AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
170
171	/* Create event semaphore. */
172	int rc = RTSemEventCreate(&pState->WndRequestSem);
173	if (RT_FAILURE(rc))
174	{
175	Log(("%s: Failed to create event semaphore for window handling.\n", __FUNCTION__));
176	return rc;
177	}
178
179	/* Create the async IO thread. */
180	rc = RTThreadCreate(&pState->pWindowThread, vmsvga3dWindowThread, pState->WndRequestSem, 0, RTTHREADTYPE_GUI, 0, "VMSVGA3DWND");
181	if (RT_FAILURE(rc))
182	{
183	AssertMsgFailed(("%s: Async IO Thread creation for 3d window handling failed rc=%d\n", __FUNCTION__, rc));
184	return rc;
185	}
186
187	return VINF_SUCCESS;
188	}
189
190	int vmsvga3dPowerOn(PPDMDEVINS pDevIns, PVGASTATE pThis, PVGASTATECC pThisCC)
191	{
192	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
193	AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
194	HRESULT hr;
195	RT_NOREF(pDevIns, pThis);
196
197	if (pState->pD3D9)
198	return VINF_SUCCESS; /* already initialized (load state) */
199
200	#ifdef VBOX_VMSVGA3D_WITH_WINE_OPENGL
201	pState->pD3D9 = Direct3DCreate9(D3D_SDK_VERSION);
202	AssertReturn(pState->pD3D9, VERR_INTERNAL_ERROR);
203	#else
204	/* Direct3DCreate9Ex was introduced in Vista, so resolve it dynamically. */
205	typedef HRESULT (WINAPI PFNDIRECT3DCREATE9EX)(UINT, IDirect3D9Ex *);
206	PFNDIRECT3DCREATE9EX pfnDirect3dCreate9Ex = (PFNDIRECT3DCREATE9EX)RTLdrGetSystemSymbol("d3d9.dll", "Direct3DCreate9Ex");
207	if (!pfnDirect3dCreate9Ex)
208	return PDMDevHlpVMSetError(pDevIns, VERR_SYMBOL_NOT_FOUND, RT_SRC_POS,
209	"vmsvga3d: Unable to locate Direct3DCreate9Ex. This feature requires Vista and later.");
210	hr = pfnDirect3dCreate9Ex(D3D_SDK_VERSION, &pState->pD3D9);
211	AssertReturn(hr == D3D_OK, VERR_INTERNAL_ERROR);
212	#endif
213	D3DADAPTER_IDENTIFIER9 ai9;
214	hr = pState->pD3D9->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &ai9);
215	AssertReturnStmt(hr == D3D_OK, D3D_RELEASE(pState->pD3D9), VERR_INTERNAL_ERROR);
216
217	hr = pState->pD3D9->GetDeviceCaps(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, &pState->caps);
218	AssertReturnStmt(hr == D3D_OK, D3D_RELEASE(pState->pD3D9), VERR_INTERNAL_ERROR);
219
220	vmsvgaDumpD3DCaps(&pState->caps, &ai9);
221
222	if (!D3D9CheckDeviceFormat(pState->pD3D9, 0, D3DRTYPE_TEXTURE, FOURCC_INTZ))
223	{
224	/* INTZ support is essential to support depth surfaces used as textures. */
225	LogRel(("VMSVGA: texture format INTZ not supported!!!\n"));
226	}
227	else
228	pState->fSupportedSurfaceINTZ = true;
229
230	if (!D3D9CheckDeviceFormat(pState->pD3D9, D3DUSAGE_RENDERTARGET, D3DRTYPE_SURFACE, FOURCC_NULL))
231	{
232	/* NULL is a dummy surface which can be used as a render target to save memory. */
233	LogRel(("VMSVGA: surface format NULL not supported!!!\n"));
234	}
235	else
236	pState->fSupportedSurfaceNULL = true;
237
238	/* Check if DX9 depth stencil textures are supported */
239	if (!D3D9CheckDeviceFormat(pState->pD3D9, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, D3DFMT_D16))
240	{
241	LogRel(("VMSVGA: texture format D3DFMT_D16 not supported\n"));
242	}
243
244	if (!D3D9CheckDeviceFormat(pState->pD3D9, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, D3DFMT_D24X8))
245	{
246	LogRel(("VMSVGA: texture format D3DFMT_D24X8 not supported\n"));
247	}
248
249	if (!D3D9CheckDeviceFormat(pState->pD3D9, D3DUSAGE_DEPTHSTENCIL, D3DRTYPE_TEXTURE, D3DFMT_D24S8))
250	{
251	LogRel(("VMSVGA: texture format D3DFMT_D24S8 not supported\n"));
252	}
253
254	/* Check some formats must be emulated. */
255	if (D3D9CheckDeviceFormat(pState->pD3D9, 0, D3DRTYPE_TEXTURE, D3DFMT_UYVY))
256	{
257	/* Native UYVY support has better performance. */
258	LogRel(("VMSVGA: texture format D3DFMT_UYVY supported\n"));
259	pState->fSupportedFormatUYVY = true;
260	}
261
262	if (D3D9CheckDeviceFormat(pState->pD3D9, 0, D3DRTYPE_TEXTURE, D3DFMT_YUY2))
263	{
264	/* Native YUY2 support has better performance. */
265	LogRel(("VMSVGA: texture format D3DFMT_YUY2 supported\n"));
266	pState->fSupportedFormatYUY2 = true;
267	}
268
269	if (D3D9CheckDeviceFormat(pState->pD3D9, D3DUSAGE_RENDERTARGET, D3DRTYPE_TEXTURE, D3DFMT_A8B8G8R8))
270	{
271	/* Native A8B8G8R8 support is good for OpenGL application in the guest. */
272	LogRel(("VMSVGA: texture format D3DFMT_A8B8G8R8 supported\n"));
273	pState->fSupportedFormatA8B8G8R8 = true;
274	}
275
276	return VINF_SUCCESS;
277	}
278
279	int vmsvga3dReset(PVGASTATECC pThisCC)
280	{
281	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
282	AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
283
284	/* Destroy all leftover surfaces. */
285	for (uint32_t i = 0; i < pState->cSurfaces; i++)
286	{
287	if (pState->papSurfaces[i]->id != SVGA3D_INVALID_ID)
288	vmsvga3dSurfaceDestroy(pThisCC, pState->papSurfaces[i]->id);
289	}
290
291	/* Destroy all leftover contexts. */
292	for (uint32_t i = 0; i < pState->cContexts; i++)
293	{
294	if (pState->papContexts[i]->id != SVGA3D_INVALID_ID)
295	vmsvga3dContextDestroy(pThisCC, pState->papContexts[i]->id);
296	}
297	return VINF_SUCCESS;
298	}
299
300	int vmsvga3dTerminate(PVGASTATECC pThisCC)
301	{
302	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
303	AssertReturn(pThisCC->svga.p3dState, VERR_NO_MEMORY);
304
305	int rc = vmsvga3dReset(pThisCC);
306	AssertRCReturn(rc, rc);
307
308	/* Terminate the window creation thread. */
309	rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_EXIT, 0, 0);
310	AssertRCReturn(rc, rc);
311
312	RTSemEventDestroy(pState->WndRequestSem);
313
314	D3D_RELEASE(pState->pD3D9);
315
316	return VINF_SUCCESS;
317	}
318
319	void vmsvga3dUpdateHostScreenViewport(PVGASTATECC pThisCC, uint32_t idScreen, VMSVGAVIEWPORT const *pOldViewport)
320	{
321	/** @todo Scroll the screen content without requiring the guest to redraw. */
322	RT_NOREF(pThisCC, idScreen, pOldViewport);
323	}
324
325	static uint32_t vmsvga3dGetSurfaceFormatSupport(PVMSVGA3DSTATE pState3D, uint32_t idx3dCaps, D3DFORMAT format)
326	{
327	NOREF(idx3dCaps);
328	HRESULT hr;
329	uint32_t result = 0;
330
331	/* Try if the format can be used for the primary display. */
332	hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
333	D3DDEVTYPE_HAL,
334	format,
335	0,
336	D3DRTYPE_SURFACE,
337	format);
338
339	for (unsigned i = 0; i < RT_ELEMENTS(g_aFormatSupport); i++)
340	{
341	hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
342	D3DDEVTYPE_HAL,
343	D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
344	g_aFormatSupport[i].Usage,
345	g_aFormatSupport[i].ResourceType,
346	format);
347	if (hr == D3D_OK)
348	result \|= g_aFormatSupport[i].FormatOp;
349	}
350
351	/* Check for features only if the format is supported in any form. */
352	if (result)
353	{
354	for (unsigned i = 0; i < RT_ELEMENTS(g_aFeatureReject); i++)
355	{
356	hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
357	D3DDEVTYPE_HAL,
358	D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
359	g_aFeatureReject[i].Usage,
360	g_aFeatureReject[i].ResourceType,
361	format);
362	if (hr != D3D_OK)
363	result \|= g_aFeatureReject[i].FormatOp;
364	}
365	}
366
367	/** @todo missing:
368	*
369	* SVGA3DFORMAT_OP_PIXELSIZE
370	*/
371
372	switch (idx3dCaps)
373	{
374	case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
375	case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
376	case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
377	result \|= SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB
378	\| SVGA3DFORMAT_OP_CONVERT_TO_ARGB
379	\| SVGA3DFORMAT_OP_DISPLAYMODE /* Should not be set for alpha formats. */
380	\| SVGA3DFORMAT_OP_3DACCELERATION; /* implies OP_DISPLAYMODE */
381	break;
382
383	case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
384	case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
385	case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
386	case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
387	result \|= SVGA3DFORMAT_OP_MEMBEROFGROUP_ARGB
388	\| SVGA3DFORMAT_OP_CONVERT_TO_ARGB
389	\| SVGA3DFORMAT_OP_SAME_FORMAT_UP_TO_ALPHA_RENDERTARGET;
390	break;
391	/* These formats can't be used as textures on AMD drivers (Intel works).
392	* Still report them as textures to the guest and emulate them in the device.
393	*/
394	case SVGA3D_DEVCAP_SURFACEFMT_UYVY:
395	case SVGA3D_DEVCAP_SURFACEFMT_YUY2:
396	result \|= SVGA3DFORMAT_OP_TEXTURE;
397	break;
398	}
399	Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
400
401	return result;
402	}
403
404	static uint32_t vmsvga3dGetDepthFormatSupport(PVMSVGA3DSTATE pState3D, uint32_t idx3dCaps, D3DFORMAT format)
405	{
406	RT_NOREF(idx3dCaps);
407	HRESULT hr;
408	uint32_t result = 0;
409
410	hr = pState3D->pD3D9->CheckDeviceFormat(D3DADAPTER_DEFAULT,
411	D3DDEVTYPE_HAL,
412	D3DFMT_X8R8G8B8, /* assume standard 32-bit display mode */
413	D3DUSAGE_DEPTHSTENCIL,
414	D3DRTYPE_SURFACE,
415	format);
416	if (hr == D3D_OK)
417	result = SVGA3DFORMAT_OP_ZSTENCIL
418	\| SVGA3DFORMAT_OP_ZSTENCIL_WITH_ARBITRARY_COLOR_DEPTH
419	\| SVGA3DFORMAT_OP_TEXTURE /* Necessary for Ubuntu Unity */;
420
421	Log(("CAPS: %s =\n%s\n", vmsvga3dGetCapString(idx3dCaps), vmsvga3dGet3dFormatString(result)));
422	return result;
423	}
424
425
426	int vmsvga3dQueryCaps(PVGASTATECC pThisCC, uint32_t idx3dCaps, uint32_t *pu32Val)
427	{
428	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
429	AssertReturn(pState, VERR_NO_MEMORY);
430	D3DCAPS9 *pCaps = &pState->caps;
431	int rc = VINF_SUCCESS;
432
433	*pu32Val = 0;
434
435	switch (idx3dCaps)
436	{
437	case SVGA3D_DEVCAP_3D:
438	pu32Val = 1; / boolean? */
439	break;
440
441	case SVGA3D_DEVCAP_MAX_LIGHTS:
442	*pu32Val = pCaps->MaxActiveLights;
443	break;
444
445	case SVGA3D_DEVCAP_MAX_TEXTURES:
446	*pu32Val = pCaps->MaxSimultaneousTextures;
447	break;
448
449	case SVGA3D_DEVCAP_MAX_CLIP_PLANES:
450	*pu32Val = pCaps->MaxUserClipPlanes;
451	break;
452
453	case SVGA3D_DEVCAP_VERTEX_SHADER_VERSION:
454	switch (pCaps->VertexShaderVersion)
455	{
456	case D3DVS_VERSION(1,1):
457	*pu32Val = SVGA3DVSVERSION_11;
458	break;
459	case D3DVS_VERSION(2,0):
460	*pu32Val = SVGA3DVSVERSION_20;
461	break;
462	case D3DVS_VERSION(3,0):
463	*pu32Val = SVGA3DVSVERSION_30;
464	break;
465	case D3DVS_VERSION(4,0):
466	*pu32Val = SVGA3DVSVERSION_40;
467	break;
468	default:
469	LogRel(("VMSVGA: Unsupported vertex shader version %x\n", pCaps->VertexShaderVersion));
470	break;
471	}
472	break;
473
474	case SVGA3D_DEVCAP_VERTEX_SHADER:
475	/* boolean? */
476	*pu32Val = 1;
477	break;
478
479	case SVGA3D_DEVCAP_FRAGMENT_SHADER_VERSION:
480	switch (pCaps->PixelShaderVersion)
481	{
482	case D3DPS_VERSION(1,1):
483	*pu32Val = SVGA3DPSVERSION_11;
484	break;
485	case D3DPS_VERSION(1,2):
486	*pu32Val = SVGA3DPSVERSION_12;
487	break;
488	case D3DPS_VERSION(1,3):
489	*pu32Val = SVGA3DPSVERSION_13;
490	break;
491	case D3DPS_VERSION(1,4):
492	*pu32Val = SVGA3DPSVERSION_14;
493	break;
494	case D3DPS_VERSION(2,0):
495	*pu32Val = SVGA3DPSVERSION_20;
496	break;
497	case D3DPS_VERSION(3,0):
498	*pu32Val = SVGA3DPSVERSION_30;
499	break;
500	case D3DPS_VERSION(4,0):
501	*pu32Val = SVGA3DPSVERSION_40;
502	break;
503	default:
504	LogRel(("VMSVGA: Unsupported pixel shader version %x\n", pCaps->PixelShaderVersion));
505	break;
506	}
507	break;
508
509	case SVGA3D_DEVCAP_FRAGMENT_SHADER:
510	/* boolean? */
511	*pu32Val = 1;
512	break;
513
514	case SVGA3D_DEVCAP_S23E8_TEXTURES:
515	case SVGA3D_DEVCAP_S10E5_TEXTURES:
516	/* Must be obsolete by now; surface format caps specify the same thing. */
517	rc = VERR_INVALID_PARAMETER;
518	break;
519
520	case SVGA3D_DEVCAP_MAX_FIXED_VERTEXBLEND:
521	break;
522
523	/*
524	* 2. The BUFFER_FORMAT capabilities are deprecated, and they always
525	* return TRUE. Even on physical hardware that does not support
526	* these formats natively, the SVGA3D device will provide an emulation
527	* which should be invisible to the guest OS.
528	*/
529	case SVGA3D_DEVCAP_D16_BUFFER_FORMAT:
530	case SVGA3D_DEVCAP_D24S8_BUFFER_FORMAT:
531	case SVGA3D_DEVCAP_D24X8_BUFFER_FORMAT:
532	*pu32Val = 1;
533	break;
534
535	case SVGA3D_DEVCAP_QUERY_TYPES:
536	break;
537
538	case SVGA3D_DEVCAP_TEXTURE_GRADIENT_SAMPLING:
539	break;
540
541	case SVGA3D_DEVCAP_MAX_POINT_SIZE:
542	AssertCompile(sizeof(uint32_t) == sizeof(float));
543	(float )pu32Val = pCaps->MaxPointSize;
544	break;
545
546	case SVGA3D_DEVCAP_MAX_SHADER_TEXTURES:
547	/** @todo ?? */
548	rc = VERR_INVALID_PARAMETER;
549	break;
550
551	case SVGA3D_DEVCAP_MAX_TEXTURE_WIDTH:
552	*pu32Val = pCaps->MaxTextureWidth;
553	break;
554
555	case SVGA3D_DEVCAP_MAX_TEXTURE_HEIGHT:
556	*pu32Val = pCaps->MaxTextureHeight;
557	break;
558
559	case SVGA3D_DEVCAP_MAX_VOLUME_EXTENT:
560	*pu32Val = pCaps->MaxVolumeExtent;
561	break;
562
563	case SVGA3D_DEVCAP_MAX_TEXTURE_REPEAT:
564	*pu32Val = pCaps->MaxTextureRepeat;
565	break;
566
567	case SVGA3D_DEVCAP_MAX_TEXTURE_ASPECT_RATIO:
568	*pu32Val = pCaps->MaxTextureAspectRatio;
569	break;
570
571	case SVGA3D_DEVCAP_MAX_TEXTURE_ANISOTROPY:
572	*pu32Val = pCaps->MaxAnisotropy;
573	break;
574
575	case SVGA3D_DEVCAP_MAX_PRIMITIVE_COUNT:
576	*pu32Val = pCaps->MaxPrimitiveCount;
577	break;
578
579	case SVGA3D_DEVCAP_MAX_VERTEX_INDEX:
580	*pu32Val = pCaps->MaxVertexIndex;
581	break;
582
583	case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_INSTRUCTIONS:
584	*pu32Val = pCaps->MaxVertexShader30InstructionSlots;
585	break;
586
587	case SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_INSTRUCTIONS:
588	*pu32Val = pCaps->MaxPixelShader30InstructionSlots;
589	break;
590
591	case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEMPS:
592	*pu32Val = pCaps->VS20Caps.NumTemps;
593	break;
594
595	case SVGA3D_DEVCAP_MAX_FRAGMENT_SHADER_TEMPS:
596	*pu32Val = pCaps->PS20Caps.NumTemps;
597	break;
598
599	case SVGA3D_DEVCAP_TEXTURE_OPS:
600	break;
601
602	case SVGA3D_DEVCAP_MULTISAMPLE_NONMASKABLESAMPLES:
603	break;
604
605	case SVGA3D_DEVCAP_MULTISAMPLE_MASKABLESAMPLES:
606	break;
607
608	case SVGA3D_DEVCAP_ALPHATOCOVERAGE:
609	break;
610
611	case SVGA3D_DEVCAP_SUPERSAMPLE:
612	break;
613
614	case SVGA3D_DEVCAP_AUTOGENMIPMAPS:
615	*pu32Val = !!(pCaps->Caps2 & D3DCAPS2_CANAUTOGENMIPMAP);
616	break;
617
618	case SVGA3D_DEVCAP_MAX_VERTEX_SHADER_TEXTURES:
619	break;
620
621	case SVGA3D_DEVCAP_MAX_RENDER_TARGETS: /** @todo same thing? */
622	case SVGA3D_DEVCAP_MAX_SIMULTANEOUS_RENDER_TARGETS:
623	*pu32Val = pCaps->NumSimultaneousRTs;
624	break;
625
626	/*
627	* This is the maximum number of SVGA context IDs that the guest
628	* can define using SVGA_3D_CMD_CONTEXT_DEFINE.
629	*/
630	case SVGA3D_DEVCAP_MAX_CONTEXT_IDS:
631	*pu32Val = SVGA3D_MAX_CONTEXT_IDS;
632	break;
633
634	/*
635	* This is the maximum number of SVGA surface IDs that the guest
636	* can define using SVGA_3D_CMD_SURFACE_DEFINE*.
637	*/
638	case SVGA3D_DEVCAP_MAX_SURFACE_IDS:
639	*pu32Val = SVGA3D_MAX_SURFACE_IDS;
640	break;
641
642	/* Supported surface formats. */
643	case SVGA3D_DEVCAP_SURFACEFMT_X8R8G8B8:
644	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_X8R8G8B8);
645	break;
646
647	case SVGA3D_DEVCAP_SURFACEFMT_A8R8G8B8:
648	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A8R8G8B8);
649	break;
650
651	case SVGA3D_DEVCAP_SURFACEFMT_A2R10G10B10:
652	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A2R10G10B10);
653	break;
654
655	case SVGA3D_DEVCAP_SURFACEFMT_X1R5G5B5:
656	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_X1R5G5B5);
657	break;
658
659	case SVGA3D_DEVCAP_SURFACEFMT_A1R5G5B5:
660	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A1R5G5B5);
661	break;
662
663	case SVGA3D_DEVCAP_SURFACEFMT_A4R4G4B4:
664	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A4R4G4B4);
665	break;
666
667	case SVGA3D_DEVCAP_SURFACEFMT_R5G6B5:
668	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A4R4G4B4);
669	break;
670
671	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE16:
672	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_L16);
673	break;
674
675	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8_ALPHA8:
676	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A8L8);
677	break;
678
679	case SVGA3D_DEVCAP_SURFACEFMT_ALPHA8:
680	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A8);
681	break;
682
683	case SVGA3D_DEVCAP_SURFACEFMT_LUMINANCE8:
684	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_L8);
685	break;
686
687	case SVGA3D_DEVCAP_SURFACEFMT_Z_D16:
688	*pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D16);
689	break;
690
691	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8:
692	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24S8_INT: /** @todo not correct */
693	*pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D24S8);
694	break;
695
696	case SVGA3D_DEVCAP_SURFACEFMT_Z_D24X8:
697	*pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D24X8);
698	break;
699
700	case SVGA3D_DEVCAP_SURFACEFMT_Z_DF16:
701	/** @todo supposed to be floating-point, but unable to find a match for D3D9... */
702	*pu32Val = 0;
703	break;
704
705	case SVGA3D_DEVCAP_SURFACEFMT_Z_DF24:
706	*pu32Val = vmsvga3dGetDepthFormatSupport(pState, idx3dCaps, D3DFMT_D24FS8);
707	break;
708
709	case SVGA3D_DEVCAP_SURFACEFMT_DXT1:
710	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT1);
711	break;
712
713	case SVGA3D_DEVCAP_SURFACEFMT_DXT2:
714	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT2);
715	break;
716
717	case SVGA3D_DEVCAP_SURFACEFMT_DXT3:
718	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT3);
719	break;
720
721	case SVGA3D_DEVCAP_SURFACEFMT_DXT4:
722	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT4);
723	break;
724
725	case SVGA3D_DEVCAP_SURFACEFMT_DXT5:
726	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_DXT5);
727	break;
728
729	case SVGA3D_DEVCAP_SURFACEFMT_BUMPX8L8V8U8:
730	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_X8L8V8U8);
731	break;
732
733	case SVGA3D_DEVCAP_SURFACEFMT_A2W10V10U10:
734	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A2W10V10U10);
735	break;
736
737	case SVGA3D_DEVCAP_SURFACEFMT_BUMPU8V8:
738	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_V8U8);
739	break;
740
741	case SVGA3D_DEVCAP_SURFACEFMT_Q8W8V8U8:
742	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_Q8W8V8U8);
743	break;
744
745	case SVGA3D_DEVCAP_SURFACEFMT_CxV8U8:
746	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_CxV8U8);
747	break;
748
749	case SVGA3D_DEVCAP_SURFACEFMT_R_S10E5:
750	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_R16F);
751	break;
752
753	case SVGA3D_DEVCAP_SURFACEFMT_R_S23E8:
754	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_R32F);
755	break;
756
757	case SVGA3D_DEVCAP_SURFACEFMT_RG_S10E5:
758	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_G16R16F);
759	break;
760
761	case SVGA3D_DEVCAP_SURFACEFMT_RG_S23E8:
762	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_G32R32F);
763	break;
764
765	case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S10E5:
766	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A16B16G16R16F);
767	break;
768
769	case SVGA3D_DEVCAP_SURFACEFMT_ARGB_S23E8:
770	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A32B32G32R32F);
771	break;
772
773	case SVGA3D_DEVCAP_SURFACEFMT_V16U16:
774	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_V16U16);
775	break;
776
777	case SVGA3D_DEVCAP_SURFACEFMT_G16R16:
778	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_G16R16);
779	break;
780
781	case SVGA3D_DEVCAP_SURFACEFMT_A16B16G16R16:
782	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_A16B16G16R16);
783	break;
784
785	case SVGA3D_DEVCAP_SURFACEFMT_UYVY:
786	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_UYVY);
787	break;
788
789	case SVGA3D_DEVCAP_SURFACEFMT_YUY2:
790	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, D3DFMT_YUY2);
791	break;
792
793	case SVGA3D_DEVCAP_SURFACEFMT_NV12:
794	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2'));
795	break;
796
797	case SVGA3D_DEVCAP_SURFACEFMT_AYUV:
798	*pu32Val = vmsvga3dGetSurfaceFormatSupport(pState, idx3dCaps, (D3DFORMAT)MAKEFOURCC('A', 'Y', 'U', 'V'));
799	break;
800
801	case SVGA3D_DEVCAP_SURFACEFMT_BC4_UNORM:
802	case SVGA3D_DEVCAP_SURFACEFMT_BC5_UNORM:
803	/* Unknown; only in DX10 & 11 */
804	Log(("CAPS: Unknown CAP %s\n", vmsvga3dGetCapString(idx3dCaps)));
805	rc = VERR_INVALID_PARAMETER;
806	*pu32Val = 0;
807	break;
808
809	default:
810	Log(("CAPS: Unexpected CAP %d\n", idx3dCaps));
811	rc = VERR_INVALID_PARAMETER;
812	break;
813	}
814	#if 0
815	/* Dump of VMWare Player caps (from their log); for debugging purposes */
816	switch (idx3dCaps)
817	{
818	case 0:
819	*pu32Val = 0x00000001;
820	break;
821	case 1:
822	*pu32Val = 0x0000000a;
823	break;
824	case 2:
825	*pu32Val = 0x00000008;
826	break;
827	case 3: *pu32Val = 0x00000006; break;
828	case 4: *pu32Val = 0x00000007; break;
829	case 5: *pu32Val = 0x00000001; break;
830	case 6: *pu32Val = 0x0000000d; break;
831	case 7: *pu32Val = 0x00000001; break;
832	case 8: *pu32Val = 0x00000004; break;
833	case 9: *pu32Val = 0x00000001; break;
834	case 10: *pu32Val = 0x00000001; break;
835	case 11: *pu32Val = 0x00000004; break;
836	case 12: *pu32Val = 0x00000001; break;
837	case 13: *pu32Val = 0x00000001; break;
838	case 14: *pu32Val = 0x00000001; break;
839	case 15: *pu32Val = 0x00000001; break;
840	case 16: *pu32Val = 0x00000001; break;
841	case 17: *pu32Val = (uint32_t)256.000000; break;
842	case 18: *pu32Val = 0x00000014; break;
843	case 19: *pu32Val = 0x00001000; break;
844	case 20: *pu32Val = 0x00001000; break;
845	case 21: *pu32Val = 0x00000800; break;
846	case 22: *pu32Val = 0x00002000; break;
847	case 23: *pu32Val = 0x00000800; break;
848	case 24: *pu32Val = 0x00000010; break;
849	case 25: *pu32Val = 0x000fffff; break;
850	case 26: *pu32Val = 0x00ffffff; break;
851	case 27: *pu32Val = 0xffffffff; break;
852	case 28: *pu32Val = 0xffffffff; break;
853	case 29: *pu32Val = 0x00000020; break;
854	case 30: *pu32Val = 0x00000020; break;
855	case 31: *pu32Val = 0x03ffffff; break;
856	case 32: *pu32Val = 0x0098ec1f; break;
857	case 33: *pu32Val = 0x0098e11f; break;
858	case 34: *pu32Val = 0x0098e01f; break;
859	case 35: *pu32Val = 0x012c2000; break;
860	case 36: *pu32Val = 0x0098e11f; break;
861	case 37: *pu32Val = 0x0090c11f; break;
862	case 38: *pu32Val = 0x0098ec1f; break;
863	case 39: *pu32Val = 0x00804007; break;
864	case 40: *pu32Val = 0x0080c007; break;
865	case 41: *pu32Val = 0x00804007; break;
866	case 42: *pu32Val = 0x0080c007; break;
867	case 43: *pu32Val = 0x000000c1; break;
868	case 44: *pu32Val = 0x000000c1; break;
869	case 45: *pu32Val = 0x000000c1; break;
870	case 46: *pu32Val = 0x00808005; break;
871	case 47: *pu32Val = 0x00808005; break;
872	case 48: *pu32Val = 0x00808005; break;
873	case 49: *pu32Val = 0x00808005; break;
874	case 50: *pu32Val = 0x00808005; break;
875	case 51: *pu32Val = 0x01240000; break;
876	case 52: *pu32Val = 0x00814007; break;
877	case 53: *pu32Val = 0x00814007; break;
878	case 54: *pu32Val = 0x00814007; break;
879	case 55: *pu32Val = 0x01240000; break;
880	case 56: *pu32Val = 0x0080401f; break;
881	case 57: *pu32Val = 0x0080401f; break;
882	case 58: *pu32Val = 0x0080401f; break;
883	case 59: *pu32Val = 0x0080401f; break;
884	case 60: *pu32Val = 0x0080601f; break;
885	case 61: *pu32Val = 0x0080401f; break;
886	case 62: *pu32Val = 0x00000000; break;
887	case 63: *pu32Val = 0x00000004; break;
888	case 64: *pu32Val = 0x00000004; break;
889	case 65: *pu32Val = 0x00814005; break;
890	case 66: *pu32Val = 0x0080401f; break;
891	case 67: *pu32Val = 0x0080601f; break;
892	case 68: *pu32Val = 0x00006009; break;
893	case 69: *pu32Val = 0x00006001; break;
894	case 70: *pu32Val = 0x00000001; break;
895	case 71: *pu32Val = 0x0000000b; break;
896	case 72: *pu32Val = 0x00000001; break;
897	case 73: *pu32Val = 0x00000000; break;
898	case 74: *pu32Val = 0x00000000; break;
899	case 75: *pu32Val = 0x01246000; break;
900	case 76: *pu32Val = 0x00004009; break;
901	case 77: *pu32Val = 0x00000100; break;
902	case 78: *pu32Val = 0x00008000; break;
903	case 79: *pu32Val = 0x000000c1; break;
904	case 80: *pu32Val = 0x01240000; break;
905	case 81: *pu32Val = 0x000000c1; break;
906	case 82: *pu32Val = 0x00800005; break;
907	case 83: *pu32Val = 0x00800005; break;
908	case 84: *pu32Val = 0x00000000; break;
909	case 85: *pu32Val = 0x00000000; break;
910	case 86: *pu32Val = 0x00000000; break;
911	case 87: *pu32Val = 0x00000000; break;
912	case 88: *pu32Val = 0x00000000; break;
913	case 89: *pu32Val = (uint32_t) 0.000000; break;
914	case 90: *pu32Val = (uint32_t) 0.000000; break;
915	case 91: *pu32Val = 0x00006009; break;
916	default:
917	// Log(("CAPS: Unexpected CAP %d\n", idx3dCaps));
918	// rc = VERR_INVALID_PARAMETER;
919	break;
920	}
921	#endif
922	Log(("CAPS: %d=%s - %x\n", idx3dCaps, vmsvga3dGetCapString(idx3dCaps), *pu32Val));
923	return rc;
924	}
925
926	/**
927	* Convert SVGA format value to its D3D equivalent
928	*/
929	D3DFORMAT vmsvga3dSurfaceFormat2D3D(SVGA3dSurfaceFormat format)
930	{
931	switch (format)
932	{
933	case SVGA3D_X8R8G8B8:
934	return D3DFMT_X8R8G8B8;
935	case SVGA3D_A8R8G8B8:
936	return D3DFMT_A8R8G8B8;
937	case SVGA3D_R5G6B5:
938	return D3DFMT_R5G6B5;
939	case SVGA3D_X1R5G5B5:
940	return D3DFMT_X1R5G5B5;
941	case SVGA3D_A1R5G5B5:
942	return D3DFMT_A1R5G5B5;
943	case SVGA3D_A4R4G4B4:
944	return D3DFMT_A4R4G4B4;
945
946	case SVGA3D_R8G8B8A8_UNORM:
947	return D3DFMT_A8B8G8R8;
948
949	case SVGA3D_Z_D32:
950	return D3DFMT_D32;
951	case SVGA3D_Z_D16:
952	return D3DFMT_D16;
953	case SVGA3D_Z_D24S8_INT: /** @todo not correct */
954	case SVGA3D_Z_D24S8:
955	return D3DFMT_D24S8;
956	case SVGA3D_Z_D15S1:
957	return D3DFMT_D15S1;
958	case SVGA3D_Z_D24X8:
959	return D3DFMT_D24X8;
960	/* Advanced D3D9 depth formats. */
961	case SVGA3D_Z_DF16:
962	/** @todo supposed to be floating-point, but unable to find a match for D3D9... */
963	AssertFailedReturn(D3DFMT_UNKNOWN);
964	case SVGA3D_Z_DF24:
965	return D3DFMT_D24FS8;
966
967	case SVGA3D_LUMINANCE8:
968	return D3DFMT_L8;
969	case SVGA3D_LUMINANCE4_ALPHA4:
970	return D3DFMT_A4L4;
971	case SVGA3D_LUMINANCE16:
972	return D3DFMT_L16;
973	case SVGA3D_LUMINANCE8_ALPHA8:
974	return D3DFMT_A8L8;
975
976	case SVGA3D_DXT1:
977	return D3DFMT_DXT1;
978	case SVGA3D_DXT2:
979	return D3DFMT_DXT2;
980	case SVGA3D_DXT3:
981	return D3DFMT_DXT3;
982	case SVGA3D_DXT4:
983	return D3DFMT_DXT4;
984	case SVGA3D_DXT5:
985	return D3DFMT_DXT5;
986
987	/* Bump-map formats */
988	case SVGA3D_BUMPU8V8:
989	return D3DFMT_V8U8;
990	case SVGA3D_BUMPL6V5U5:
991	return D3DFMT_L6V5U5;
992	case SVGA3D_BUMPX8L8V8U8:
993	return D3DFMT_X8L8V8U8;
994	case SVGA3D_BUMPL8V8U8:
995	/* No corresponding D3D9 equivalent. */
996	AssertFailedReturn(D3DFMT_UNKNOWN);
997	/* signed bump-map formats */
998	case SVGA3D_V8U8:
999	return D3DFMT_V8U8;
1000	case SVGA3D_Q8W8V8U8:
1001	return D3DFMT_Q8W8V8U8;
1002	case SVGA3D_CxV8U8:
1003	return D3DFMT_CxV8U8;
1004	/* mixed bump-map formats */
1005	case SVGA3D_X8L8V8U8:
1006	return D3DFMT_X8L8V8U8;
1007	case SVGA3D_A2W10V10U10:
1008	return D3DFMT_A2W10V10U10;
1009
1010	case SVGA3D_ARGB_S10E5: /* 16-bit floating-point ARGB */
1011	return D3DFMT_A16B16G16R16F;
1012	case SVGA3D_ARGB_S23E8: /* 32-bit floating-point ARGB */
1013	return D3DFMT_A32B32G32R32F;
1014
1015	case SVGA3D_A2R10G10B10:
1016	return D3DFMT_A2R10G10B10;
1017
1018	case SVGA3D_ALPHA8:
1019	return D3DFMT_A8;
1020
1021	/* Single- and dual-component floating point formats */
1022	case SVGA3D_R_S10E5:
1023	return D3DFMT_R16F;
1024	case SVGA3D_R_S23E8:
1025	return D3DFMT_R32F;
1026	case SVGA3D_RG_S10E5:
1027	return D3DFMT_G16R16F;
1028	case SVGA3D_RG_S23E8:
1029	return D3DFMT_G32R32F;
1030
1031	/*
1032	* Any surface can be used as a buffer object, but SVGA3D_BUFFER is
1033	* the most efficient format to use when creating new surfaces
1034	* expressly for index or vertex data.
1035	*/
1036	case SVGA3D_BUFFER:
1037	return D3DFMT_UNKNOWN;
1038
1039	case SVGA3D_V16U16:
1040	return D3DFMT_V16U16;
1041
1042	case SVGA3D_G16R16:
1043	return D3DFMT_G16R16;
1044	case SVGA3D_A16B16G16R16:
1045	return D3DFMT_A16B16G16R16;
1046
1047	/* Packed Video formats */
1048	case SVGA3D_UYVY:
1049	return D3DFMT_UYVY;
1050	case SVGA3D_YUY2:
1051	return D3DFMT_YUY2;
1052
1053	/* Planar video formats */
1054	case SVGA3D_NV12:
1055	return (D3DFORMAT)MAKEFOURCC('N', 'V', '1', '2');
1056
1057	/* Video format with alpha */
1058	case SVGA3D_AYUV:
1059	return (D3DFORMAT)MAKEFOURCC('A', 'Y', 'U', 'V');
1060
1061	case SVGA3D_R8G8B8A8_SNORM:
1062	return D3DFMT_Q8W8V8U8;
1063	case SVGA3D_R16G16_UNORM:
1064	return D3DFMT_G16R16;
1065
1066	case SVGA3D_BC4_UNORM:
1067	case SVGA3D_BC5_UNORM:
1068	/* Unknown; only in DX10 & 11 */
1069	break;
1070
1071	case SVGA3D_FORMAT_MAX: /* shut up MSC */
1072	case SVGA3D_FORMAT_INVALID:
1073	break;
1074	}
1075	AssertFailedReturn(D3DFMT_UNKNOWN);
1076	}
1077
1078	/**
1079	* Convert SVGA multi sample count value to its D3D equivalent
1080	*/
1081	D3DMULTISAMPLE_TYPE vmsvga3dMultipeSampleCount2D3D(uint32_t multisampleCount)
1082	{
1083	AssertCompile(D3DMULTISAMPLE_2_SAMPLES == 2);
1084	AssertCompile(D3DMULTISAMPLE_16_SAMPLES == 16);
1085
1086	if (multisampleCount > 16)
1087	return D3DMULTISAMPLE_NONE;
1088
1089	/** @todo exact same mapping as d3d? */
1090	return (D3DMULTISAMPLE_TYPE)multisampleCount;
1091	}
1092
1093
1094	/**
1095	* Destroy backend specific surface bits (part of SVGA_3D_CMD_SURFACE_DESTROY).
1096	*
1097	* @param pState The VMSVGA3d state.
1098	* @param pSurface The surface being destroyed.
1099	*/
1100	void vmsvga3dBackSurfaceDestroy(PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface)
1101	{
1102	RT_NOREF(pState);
1103
1104	RTAvlU32Destroy(&pSurface->pSharedObjectTree, vmsvga3dSharedSurfaceDestroyTree, pSurface);
1105	Assert(pSurface->pSharedObjectTree == NULL);
1106
1107	switch (pSurface->enmD3DResType)
1108	{
1109	case VMSVGA3D_D3DRESTYPE_SURFACE:
1110	D3D_RELEASE(pSurface->u.pSurface);
1111	break;
1112
1113	case VMSVGA3D_D3DRESTYPE_TEXTURE:
1114	D3D_RELEASE(pSurface->u.pTexture);
1115	D3D_RELEASE(pSurface->bounce.pTexture);
1116	D3D_RELEASE(pSurface->emulated.pTexture);
1117	break;
1118
1119	case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
1120	D3D_RELEASE(pSurface->u.pCubeTexture);
1121	D3D_RELEASE(pSurface->bounce.pCubeTexture);
1122	D3D_RELEASE(pSurface->emulated.pCubeTexture);
1123	break;
1124
1125	case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
1126	D3D_RELEASE(pSurface->u.pVolumeTexture);
1127	D3D_RELEASE(pSurface->bounce.pVolumeTexture);
1128	D3D_RELEASE(pSurface->emulated.pVolumeTexture);
1129	break;
1130
1131	case VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER:
1132	D3D_RELEASE(pSurface->u.pVertexBuffer);
1133	break;
1134
1135	case VMSVGA3D_D3DRESTYPE_INDEX_BUFFER:
1136	D3D_RELEASE(pSurface->u.pIndexBuffer);
1137	break;
1138
1139	default:
1140	AssertMsg(!VMSVGA3DSURFACE_HAS_HW_SURFACE(pSurface),
1141	("surfaceFlags=0x%x\n", (pSurface->surfaceFlags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)));
1142	break;
1143	}
1144
1145	D3D_RELEASE(pSurface->pQuery);
1146	}
1147
1148
1149	/*
1150	* Release all shared surface objects.
1151	*/
1152	DECLCALLBACK(int) vmsvga3dSharedSurfaceDestroyTree(PAVLU32NODECORE pNode, void *pvParam)
1153	{
1154	PVMSVGA3DSHAREDSURFACE pSharedSurface = (PVMSVGA3DSHAREDSURFACE)pNode;
1155	PVMSVGA3DSURFACE pSurface = (PVMSVGA3DSURFACE)pvParam;
1156
1157	switch (pSurface->enmD3DResType)
1158	{
1159	case VMSVGA3D_D3DRESTYPE_TEXTURE:
1160	LogFunc(("release shared texture object for context %d\n", pNode->Key));
1161	Assert(pSharedSurface->u.pTexture);
1162	D3D_RELEASE(pSharedSurface->u.pTexture);
1163	break;
1164
1165	case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
1166	LogFunc(("release shared cube texture object for context %d\n", pNode->Key));
1167	Assert(pSharedSurface->u.pCubeTexture);
1168	D3D_RELEASE(pSharedSurface->u.pCubeTexture);
1169	break;
1170
1171	case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
1172	LogFunc(("release shared volume texture object for context %d\n", pNode->Key));
1173	Assert(pSharedSurface->u.pVolumeTexture);
1174	D3D_RELEASE(pSharedSurface->u.pVolumeTexture);
1175	break;
1176
1177	default:
1178	AssertFailed();
1179	break;
1180	}
1181	RTMemFree(pNode);
1182	return 0;
1183	}
1184
1185	/* Get the shared surface copy or create a new one. */
1186	static PVMSVGA3DSHAREDSURFACE vmsvga3dSurfaceGetSharedCopy(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface)
1187	{
1188	Assert(pSurface->hSharedObject);
1189
1190	PVMSVGA3DSHAREDSURFACE pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTAvlU32Get(&pSurface->pSharedObjectTree, pContext->id);
1191	if (!pSharedSurface)
1192	{
1193	const uint32_t cWidth = pSurface->paMipmapLevels[0].mipmapSize.width;
1194	const uint32_t cHeight = pSurface->paMipmapLevels[0].mipmapSize.height;
1195	const uint32_t cDepth = pSurface->paMipmapLevels[0].mipmapSize.depth;
1196	const uint32_t numMipLevels = pSurface->faces[0].numMipLevels;
1197
1198	LogFunc(("Create shared %stexture copy d3d (%d,%d,%d) cMip=%d usage %x format %x.\n",
1199	pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE ? "volume " :
1200	pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE ? "cube " :
1201	pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE ? "" : "UNKNOWN!!!",
1202	cWidth,
1203	cHeight,
1204	cDepth,
1205	numMipLevels,
1206	pSurface->fUsageD3D \| D3DUSAGE_RENDERTARGET,
1207	pSurface->formatD3D));
1208
1209	pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTMemAllocZ(sizeof(*pSharedSurface));
1210	AssertReturn(pSharedSurface, NULL);
1211
1212	pSharedSurface->Core.Key = pContext->id;
1213	bool ret = RTAvlU32Insert(&pSurface->pSharedObjectTree, &pSharedSurface->Core);
1214	AssertReturn(ret, NULL);
1215
1216	/* Create shadow copy of the original shared texture.
1217	* Shared d3d resources require Vista+ and have some restrictions.
1218	* D3DUSAGE_RENDERTARGET is required for use as a StretchRect destination.
1219	*/
1220	HRESULT hr;
1221	if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
1222	hr = pContext->pDevice->CreateVolumeTexture(cWidth,
1223	cHeight,
1224	cDepth,
1225	numMipLevels,
1226	pSurface->fUsageD3D \| D3DUSAGE_RENDERTARGET,
1227	pSurface->formatD3D,
1228	D3DPOOL_DEFAULT,
1229	&pSharedSurface->u.pVolumeTexture,
1230	&pSurface->hSharedObject);
1231	else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
1232	hr = pContext->pDevice->CreateCubeTexture(cWidth,
1233	numMipLevels,
1234	pSurface->fUsageD3D \| D3DUSAGE_RENDERTARGET,
1235	pSurface->formatD3D,
1236	D3DPOOL_DEFAULT,
1237	&pSharedSurface->u.pCubeTexture,
1238	&pSurface->hSharedObject);
1239	else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE)
1240	{
1241	if (pSurface->fStencilAsTexture)
1242	{
1243	/* Use the INTZ format for a depth/stencil surface that will be used as a texture */
1244	hr = pContext->pDevice->CreateTexture(cWidth,
1245	cHeight,
1246	1, /* mip levels */
1247	D3DUSAGE_DEPTHSTENCIL,
1248	FOURCC_INTZ,
1249	D3DPOOL_DEFAULT,
1250	&pSharedSurface->u.pTexture,
1251	&pSurface->hSharedObject);
1252	}
1253	else
1254	{
1255	hr = pContext->pDevice->CreateTexture(cWidth,
1256	cHeight,
1257	numMipLevels,
1258	pSurface->fUsageD3D \| D3DUSAGE_RENDERTARGET,
1259	pSurface->formatD3D,
1260	D3DPOOL_DEFAULT,
1261	&pSharedSurface->u.pTexture,
1262	&pSurface->hSharedObject);
1263	}
1264	}
1265	else
1266	hr = E_FAIL;
1267
1268	if (RT_LIKELY(hr == D3D_OK))
1269	{
1270	/* Make sure that the created shared copy has the same content as the original. */
1271	PVMSVGA3DCONTEXT pAssociatedContext;
1272	int rc = vmsvga3dContextFromCid(pState, pSurface->idAssociatedContext, &pAssociatedContext);
1273	if (RT_SUCCESS(rc))
1274	{
1275	IDirect3DQuery9 *pQuery;
1276	hr = pAssociatedContext->pDevice->CreateQuery(D3DQUERYTYPE_EVENT, &pQuery);
1277	if (hr == D3D_OK)
1278	{
1279	hr = pQuery->Issue(D3DISSUE_END);
1280	if (hr == D3D_OK)
1281	{
1282	do
1283	{
1284	hr = pQuery->GetData(NULL, 0, D3DGETDATA_FLUSH);
1285	} while (hr == S_FALSE);
1286	}
1287
1288	D3D_RELEASE(pQuery);
1289	}
1290	}
1291	else
1292	AssertMsgFailed(("idAssociatedContext cid=%u, sid=%u\n", pSurface->idAssociatedContext, pSurface->id));
1293	}
1294	else
1295	{
1296	AssertMsgFailed(("CreateTexture type %d failed with %x\n", pSurface->enmD3DResType, hr));
1297	RTAvlU32Remove(&pSurface->pSharedObjectTree, pContext->id);
1298	RTMemFree(pSharedSurface);
1299	return NULL;
1300	}
1301	}
1302	return pSharedSurface;
1303	}
1304
1305	/* Inject a query event into the D3D pipeline so we can check when usage of this surface has finished.
1306	* (D3D does not synchronize shared surface usage)
1307	*/
1308	static int vmsvga3dSurfaceTrackUsage(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, PVMSVGA3DSURFACE pSurface)
1309	{
1310	RT_NOREF(pState);
1311	#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
1312	Assert(pSurface->id != SVGA3D_INVALID_ID);
1313
1314	/* Nothing to do if this surface hasn't been shared. */
1315	if (pSurface->pSharedObjectTree == NULL)
1316	return VINF_SUCCESS;
1317
1318	LogFunc(("track usage of sid=%u (cid=%u) for cid=%u, pQuery %p\n", pSurface->id, pSurface->idAssociatedContext, pContext->id, pSurface->pQuery));
1319
1320	if (pSurface->idQueryContext == pContext->id)
1321	{
1322	/* Release the previous query object, if any. */
1323	D3D_RELEASE(pSurface->pQuery);
1324	}
1325	else
1326	{
1327	/* Different context. There must be no pending drawing operations. If there are any, then a flush is missing. */
1328	if (pSurface->pQuery)
1329	{
1330	/* Should not happen. */
1331	AssertFailed();
1332
1333	/* Make sure that all drawing has completed. */
1334	vmsvga3dSurfaceFlush(pSurface);
1335	}
1336	pSurface->idQueryContext = pContext->id;
1337	}
1338
1339	HRESULT hr = pContext->pDevice->CreateQuery(D3DQUERYTYPE_EVENT, &pSurface->pQuery);
1340	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: CreateQuery failed with %x\n", hr), VERR_INTERNAL_ERROR);
1341
1342	hr = pSurface->pQuery->Issue(D3DISSUE_END);
1343	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: Issue failed with %x\n", hr), VERR_INTERNAL_ERROR);
1344	#endif /* !VBOX_VMSVGA3D_WITH_WINE_OPENGL */
1345
1346	return VINF_SUCCESS;
1347	}
1348
1349
1350	/**
1351	* Surface ID based version of vmsvga3dSurfaceTrackUsage.
1352	*
1353	* @returns VBox status code.
1354	* @param pState The VMSVGA3d state.
1355	* @param pContext The context.
1356	* @param sid The surface ID.
1357	*/
1358	static int vmsvga3dSurfaceTrackUsageById(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t sid)
1359	{
1360	PVMSVGA3DSURFACE pSurface;
1361	int rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
1362	AssertRCReturn(rc, rc);
1363
1364	return vmsvga3dSurfaceTrackUsage(pState, pContext, pSurface);
1365	}
1366
1367
1368	/* Wait for all drawing, that uses this surface, to finish. */
1369	int vmsvga3dSurfaceFlush(PVMSVGA3DSURFACE pSurface)
1370	{
1371	#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
1372	HRESULT hr;
1373
1374	if (!pSurface->pQuery)
1375	{
1376	LogFlow(("vmsvga3dSurfaceFlush: no query object\n"));
1377	return VINF_SUCCESS; /* nothing to wait for */
1378	}
1379	Assert(pSurface->pSharedObjectTree);
1380
1381	Log(("vmsvga3dSurfaceFlush: wait for draw to finish (sid=%u)\n", pSurface->id));
1382	while (true)
1383	{
1384	hr = pSurface->pQuery->GetData(NULL, 0, D3DGETDATA_FLUSH);
1385	if (hr != S_FALSE) break;
1386
1387	RTThreadSleep(1);
1388	}
1389
1390	D3D_RELEASE(pSurface->pQuery);
1391
1392	AssertMsgReturn(hr == S_OK, ("vmsvga3dSurfaceFinishDrawing: GetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
1393	#endif /* !VBOX_VMSVGA3D_WITH_WINE_OPENGL */
1394
1395	return VINF_SUCCESS;
1396	}
1397
1398	/** Get IDirect3DSurface9 for the given face and mipmap.
1399	*/
1400	int vmsvga3dGetD3DSurface(PVMSVGA3DSTATE pState,
1401	PVMSVGA3DCONTEXT pContext,
1402	PVMSVGA3DSURFACE pSurface,
1403	uint32_t face,
1404	uint32_t mipmap,
1405	bool fLockable,
1406	IDirect3DSurface9 **ppD3DSurf)
1407	{
1408	AssertPtrReturn(pSurface->u.pSurface, VERR_INVALID_PARAMETER);
1409
1410	IDirect3DBaseTexture9 *pTexture;
1411	if (fLockable && pSurface->bounce.pTexture)
1412	pTexture = pSurface->bounce.pTexture;
1413	else
1414	pTexture = pSurface->u.pTexture;
1415
1416	#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
1417	if (pSurface->idAssociatedContext != pContext->id)
1418	{
1419	AssertMsgReturn(!fLockable,
1420	("Lockable surface must be from the same context (surface cid = %d, req cid = %d)",
1421	pSurface->idAssociatedContext, pContext->id),
1422	VERR_INVALID_PARAMETER);
1423
1424	if ( pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE
1425	\|\| pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
1426	{
1427	LogFunc(("using texture sid=%u created for another context (%d vs %d)\n",
1428	pSurface->id, pSurface->idAssociatedContext, pContext->id));
1429
1430	PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pState, pContext, pSurface);
1431	AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
1432
1433	pTexture = pSharedSurface->u.pTexture;
1434	}
1435	else
1436	{
1437	AssertMsgFailed(("surface sid=%u created for another context (%d vs %d)\n",
1438	pSurface->id, pSurface->idAssociatedContext, pContext->id));
1439	}
1440	}
1441	#else
1442	RT_NOREF(pContext);
1443	#endif
1444
1445	if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
1446	{
1447	Assert(pSurface->cFaces == 6);
1448
1449	IDirect3DCubeTexture9 p = (IDirect3DCubeTexture9 )pTexture;
1450	D3DCUBEMAP_FACES FaceType = vmsvga3dCubemapFaceFromIndex(face);
1451	HRESULT hr = p->GetCubeMapSurface(FaceType, mipmap, ppD3DSurf);
1452	AssertMsgReturn(hr == D3D_OK, ("GetCubeMapSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
1453	}
1454	else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE)
1455	{
1456	Assert(pSurface->cFaces == 1);
1457	Assert(face == 0);
1458
1459	IDirect3DTexture9 p = (IDirect3DTexture9 )pTexture;
1460	HRESULT hr = p->GetSurfaceLevel(mipmap, ppD3DSurf);
1461	AssertMsgReturn(hr == D3D_OK, ("GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
1462	}
1463	else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_SURFACE)
1464	{
1465	pSurface->u.pSurface->AddRef();
1466	*ppD3DSurf = pSurface->u.pSurface;
1467	}
1468	else
1469	{
1470	AssertMsgFailedReturn(("No surface for type %d\n", pSurface->enmD3DResType), VERR_INTERNAL_ERROR);
1471	}
1472
1473	return VINF_SUCCESS;
1474	}
1475
1476	int vmsvga3dSurfaceCopy(PVGASTATECC pThisCC, SVGA3dSurfaceImageId dest, SVGA3dSurfaceImageId src,
1477	uint32_t cCopyBoxes, SVGA3dCopyBox *pBox)
1478	{
1479	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
1480	AssertReturn(pState, VERR_NO_MEMORY);
1481
1482	const uint32_t sidSrc = src.sid;
1483	const uint32_t sidDest = dest.sid;
1484	int rc;
1485
1486	PVMSVGA3DSURFACE pSurfaceSrc;
1487	rc = vmsvga3dSurfaceFromSid(pState, sidSrc, &pSurfaceSrc);
1488	AssertRCReturn(rc, rc);
1489
1490	PVMSVGA3DSURFACE pSurfaceDest;
1491	rc = vmsvga3dSurfaceFromSid(pState, sidDest, &pSurfaceDest);
1492	AssertRCReturn(rc, rc);
1493
1494	PVMSVGA3DMIPMAPLEVEL pMipmapLevelSrc;
1495	rc = vmsvga3dMipmapLevel(pSurfaceSrc, src.face, src.mipmap, &pMipmapLevelSrc);
1496	AssertRCReturn(rc, rc);
1497
1498	PVMSVGA3DMIPMAPLEVEL pMipmapLevelDest;
1499	rc = vmsvga3dMipmapLevel(pSurfaceDest, dest.face, dest.mipmap, &pMipmapLevelDest);
1500	AssertRCReturn(rc, rc);
1501
1502	/* If src is HW and dst is not, then create the dst texture. */
1503	if ( pSurfaceSrc->u.pSurface
1504	&& !pSurfaceDest->u.pSurface
1505	&& RT_BOOL(pSurfaceDest->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE))
1506	{
1507	/* Create the destination texture in the same context as the source texture. */
1508	uint32_t const cidSrc = pSurfaceSrc->idAssociatedContext;
1509
1510	PVMSVGA3DCONTEXT pContextSrc;
1511	rc = vmsvga3dContextFromCid(pState, cidSrc, &pContextSrc);
1512	AssertRCReturn(rc, rc);
1513
1514	LogFunc(("sid=%u type=%x format=%d -> create dest texture\n", sidDest, pSurfaceDest->surfaceFlags, pSurfaceDest->format));
1515	rc = vmsvga3dBackCreateTexture(pState, pContextSrc, cidSrc, pSurfaceDest);
1516	AssertRCReturn(rc, rc);
1517	}
1518
1519	Assert(pSurfaceSrc->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE); /// @todo
1520	Assert(pSurfaceDest->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE); /// @todo
1521
1522	if ( pSurfaceSrc->u.pSurface
1523	&& pSurfaceDest->u.pSurface)
1524	{
1525	/* Both surfaces in hardware. Use the src context to copy one to another, because the src context may be needed
1526	* to copy data from source texture to the source bounce texture. while only the shared hardware surface is required
1527	* from the dst context.
1528	*/
1529	uint32_t const cidSrc = pSurfaceSrc->idAssociatedContext;
1530
1531	PVMSVGA3DCONTEXT pContextSrc;
1532	rc = vmsvga3dContextFromCid(pState, cidSrc, &pContextSrc);
1533	AssertRCReturn(rc, rc);
1534
1535	/* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
1536	vmsvga3dSurfaceFlush(pSurfaceSrc);
1537	vmsvga3dSurfaceFlush(pSurfaceDest);
1538
1539	IDirect3DSurface9 *pSrc;
1540	rc = vmsvga3dGetD3DSurface(pState, pContextSrc, pSurfaceSrc, src.face, src.mipmap, false, &pSrc);
1541	AssertRCReturn(rc, rc);
1542
1543	IDirect3DSurface9 *pDest;
1544	rc = vmsvga3dGetD3DSurface(pState, pContextSrc, pSurfaceDest, dest.face, dest.mipmap, false, &pDest);
1545	AssertRCReturnStmt(rc, D3D_RELEASE(pSrc), rc);
1546
1547	for (uint32_t i = 0; i < cCopyBoxes; ++i)
1548	{
1549	SVGA3dCopyBox clipBox = pBox[i];
1550	vmsvgaR3ClipCopyBox(&pMipmapLevelSrc->mipmapSize, &pMipmapLevelDest->mipmapSize, &clipBox);
1551	if ( !clipBox.w
1552	\|\| !clipBox.h
1553	\|\| !clipBox.d)
1554	{
1555	LogFunc(("Skipped empty box.\n"));
1556	continue;
1557	}
1558
1559	RECT RectSrc;
1560	RectSrc.left = clipBox.srcx;
1561	RectSrc.top = clipBox.srcy;
1562	RectSrc.right = clipBox.srcx + clipBox.w; /* exclusive */
1563	RectSrc.bottom = clipBox.srcy + clipBox.h; /* exclusive */
1564
1565	RECT RectDest;
1566	RectDest.left = clipBox.x;
1567	RectDest.top = clipBox.y;
1568	RectDest.right = clipBox.x + clipBox.w; /* exclusive */
1569	RectDest.bottom = clipBox.y + clipBox.h; /* exclusive */
1570
1571	LogFunc(("StretchRect copy src sid=%u face=%d mipmap=%d (%d,%d)(%d,%d) to dest sid=%u face=%d mipmap=%d (%d,%d)\n", sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom, sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
1572
1573	if ( sidSrc == sidDest
1574	&& clipBox.srcx == clipBox.x
1575	&& clipBox.srcy == clipBox.y)
1576	{
1577	LogFunc(("redundant copy to the same surface at the same coordinates. Ignore.\n"));
1578	continue;
1579	}
1580	Assert(sidSrc != sidDest);
1581	Assert(!clipBox.srcz && !clipBox.z);
1582
1583	HRESULT hr = pContextSrc->pDevice->StretchRect(pSrc, &RectSrc, pDest, &RectDest, D3DTEXF_NONE);
1584	if (hr != D3D_OK)
1585	{
1586	/* This can happen for compressed texture formats for example. */
1587	LogFunc(("StretchRect failed with %x. Try a slow path.\n", hr));
1588	if ( pSurfaceSrc->bounce.pTexture
1589	&& (pSurfaceSrc->fUsageD3D & D3DUSAGE_RENDERTARGET))
1590	{
1591	/* Copy the source texture mipmap level to the source bounce texture. */
1592	hr = D3D9GetRenderTargetData(pContextSrc, pSurfaceSrc, src.face, src.mipmap);
1593	AssertMsg(hr == D3D_OK, ("D3D9GetRenderTargetData failed with %x\n", hr));
1594	if (hr == D3D_OK)
1595	{
1596	/* Copy the source bounce texture to the destination surface. */
1597	IDirect3DSurface9 *pSrcBounce;
1598	rc = vmsvga3dGetD3DSurface(pState, pContextSrc, pSurfaceSrc, src.face, src.mipmap, true, &pSrcBounce);
1599	if (RT_SUCCESS(rc))
1600	{
1601	POINT pointDest;
1602	pointDest.x = clipBox.x;
1603	pointDest.y = clipBox.y;
1604
1605	hr = pContextSrc->pDevice->UpdateSurface(pSrcBounce, &RectSrc, pDest, &pointDest);
1606	Assert(hr == D3D_OK);
1607
1608	D3D_RELEASE(pSrcBounce);
1609	}
1610	else
1611	{
1612	AssertRC(rc);
1613	hr = E_INVALIDARG;
1614	}
1615	}
1616	}
1617	else if ( (pSurfaceSrc->fUsageD3D & D3DUSAGE_RENDERTARGET) == 0
1618	&& (pSurfaceDest->fUsageD3D & D3DUSAGE_RENDERTARGET) == 0)
1619	{
1620	/* Can lock both. */
1621	D3DLOCKED_RECT LockedSrcRect;
1622	hr = pSrc->LockRect(&LockedSrcRect, &RectSrc, D3DLOCK_READONLY);
1623	Assert(hr == D3D_OK);
1624	if (SUCCEEDED(hr))
1625	{
1626	D3DLOCKED_RECT LockedDestRect;
1627	hr = pDest->LockRect(&LockedDestRect, &RectDest, 0);
1628	Assert(hr == D3D_OK);
1629	if (SUCCEEDED(hr))
1630	{
1631	uint32_t cBlocksX = (clipBox.w + pSurfaceSrc->cxBlock - 1) / pSurfaceSrc->cxBlock;
1632	uint32_t cBlocksY = (clipBox.h + pSurfaceSrc->cyBlock - 1) / pSurfaceSrc->cyBlock;
1633
1634	uint32_t cbToCopy = cBlocksX * pSurfaceSrc->cbBlock;
1635	cbToCopy = RT_MIN(cbToCopy, (uint32_t)RT_ABS(LockedDestRect.Pitch));
1636	cbToCopy = RT_MIN(cbToCopy, (uint32_t)RT_ABS(LockedSrcRect.Pitch));
1637
1638	uint8_t pu8Dst = (uint8_t )LockedDestRect.pBits;
1639	const uint8_t pu8Src = (uint8_t )LockedSrcRect.pBits;
1640	for (uint32_t j = 0; j < cBlocksY; ++j)
1641	{
1642	memcpy(pu8Dst, pu8Src, cbToCopy);
1643	pu8Dst += LockedDestRect.Pitch;
1644	pu8Src += LockedSrcRect.Pitch;
1645	}
1646
1647	hr = pDest->UnlockRect();
1648	Assert(hr == D3D_OK);
1649	}
1650
1651	hr = pSrc->UnlockRect();
1652	Assert(hr == D3D_OK);
1653	}
1654	}
1655	}
1656	AssertMsgReturnStmt(hr == D3D_OK,
1657	("StretchRect failed with %x\n", hr),
1658	D3D_RELEASE(pDest); D3D_RELEASE(pSrc),
1659	VERR_INTERNAL_ERROR);
1660	}
1661
1662	D3D_RELEASE(pDest);
1663	D3D_RELEASE(pSrc);
1664
1665	/* Track the StretchRect operation. */
1666	vmsvga3dSurfaceTrackUsage(pState, pContextSrc, pSurfaceSrc);
1667	vmsvga3dSurfaceTrackUsage(pState, pContextSrc, pSurfaceDest);
1668	}
1669	else
1670	{
1671	/* One of the surfaces is in memory.
1672	*
1673	* Copy from/to memory to/from a HW surface. Or mem->mem.
1674	* Use the context of the HW surface, if any.
1675	*/
1676	PVMSVGA3DCONTEXT pContext = NULL;
1677	IDirect3DSurface9 *pD3DSurf = NULL;
1678
1679	if (pSurfaceSrc->u.pSurface)
1680	{
1681	AssertReturn(!pSurfaceDest->u.pSurface, VERR_INTERNAL_ERROR);
1682
1683	rc = vmsvga3dContextFromCid(pState, pSurfaceSrc->idAssociatedContext, &pContext);
1684	AssertRCReturn(rc, rc);
1685
1686	rc = vmsvga3dGetD3DSurface(pState, pContext, pSurfaceSrc, src.face, src.mipmap, true, &pD3DSurf);
1687	AssertRCReturn(rc, rc);
1688	}
1689	else if (pSurfaceDest->u.pSurface)
1690	{
1691	AssertReturn(!pSurfaceSrc->u.pSurface, VERR_INTERNAL_ERROR);
1692
1693	rc = vmsvga3dContextFromCid(pState, pSurfaceDest->idAssociatedContext, &pContext);
1694	AssertRCReturn(rc, rc);
1695
1696	rc = vmsvga3dGetD3DSurface(pState, pContext, pSurfaceDest, dest.face, dest.mipmap, true, &pD3DSurf);
1697	AssertRCReturn(rc, rc);
1698	}
1699
1700	for (uint32_t i = 0; i < cCopyBoxes; ++i)
1701	{
1702	HRESULT hr;
1703
1704	SVGA3dCopyBox clipBox = pBox[i];
1705	vmsvgaR3ClipCopyBox(&pMipmapLevelSrc->mipmapSize, &pMipmapLevelDest->mipmapSize, &clipBox);
1706	if ( !clipBox.w
1707	\|\| !clipBox.h
1708	\|\| !clipBox.d)
1709	{
1710	LogFunc(("Skipped empty box.\n"));
1711	continue;
1712	}
1713
1714	RECT RectSrc;
1715	RectSrc.left = clipBox.srcx;
1716	RectSrc.top = clipBox.srcy;
1717	RectSrc.right = clipBox.srcx + clipBox.w; /* exclusive */
1718	RectSrc.bottom = clipBox.srcy + clipBox.h; /* exclusive */
1719
1720	RECT RectDest;
1721	RectDest.left = clipBox.x;
1722	RectDest.top = clipBox.y;
1723	RectDest.right = clipBox.x + clipBox.w; /* exclusive */
1724	RectDest.bottom = clipBox.y + clipBox.h; /* exclusive */
1725
1726	LogFunc(("(manual) copy sid=%u face=%d mipmap=%d (%d,%d)(%d,%d) to sid=%u face=%d mipmap=%d (%d,%d)\n",
1727	sidSrc, src.face, src.mipmap, RectSrc.left, RectSrc.top, RectSrc.right, RectSrc.bottom,
1728	sidDest, dest.face, dest.mipmap, pBox[i].x, pBox[i].y));
1729
1730	Assert(!clipBox.srcz && !clipBox.z);
1731	Assert(pSurfaceSrc->cbBlock == pSurfaceDest->cbBlock);
1732	Assert(pSurfaceSrc->cxBlock == pSurfaceDest->cxBlock);
1733	Assert(pSurfaceSrc->cyBlock == pSurfaceDest->cyBlock);
1734
1735	uint32_t cBlocksX = (clipBox.w + pSurfaceSrc->cxBlock - 1) / pSurfaceSrc->cxBlock;
1736	uint32_t cBlocksY = (clipBox.h + pSurfaceSrc->cyBlock - 1) / pSurfaceSrc->cyBlock;
1737
1738	D3DLOCKED_RECT LockedSrcRect;
1739	if (!pSurfaceSrc->u.pSurface)
1740	{
1741	uint32_t u32BlockX = clipBox.srcx / pSurfaceSrc->cxBlock;
1742	uint32_t u32BlockY = clipBox.srcy / pSurfaceSrc->cyBlock;
1743	Assert(u32BlockX * pSurfaceSrc->cxBlock == clipBox.srcx);
1744	Assert(u32BlockY * pSurfaceSrc->cyBlock == clipBox.srcy);
1745
1746	LockedSrcRect.pBits = (uint8_t *)pMipmapLevelSrc->pSurfaceData +
1747	pMipmapLevelSrc->cbSurfacePitch * u32BlockY + pSurfaceSrc->cbBlock * u32BlockX;
1748	LockedSrcRect.Pitch = pMipmapLevelSrc->cbSurfacePitch;
1749	}
1750	else
1751	{
1752	/* Must flush the context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
1753	vmsvga3dSurfaceFlush(pSurfaceSrc);
1754
1755	hr = pD3DSurf->LockRect(&LockedSrcRect, &RectSrc, D3DLOCK_READONLY);
1756	AssertMsgReturnStmt(hr == D3D_OK, ("LockRect failed with %x\n", hr), D3D_RELEASE(pD3DSurf), VERR_INTERNAL_ERROR);
1757	}
1758
1759	D3DLOCKED_RECT LockedDestRect;
1760	if (!pSurfaceDest->u.pSurface)
1761	{
1762	uint32_t u32BlockX = clipBox.x / pSurfaceDest->cxBlock;
1763	uint32_t u32BlockY = clipBox.y / pSurfaceDest->cyBlock;
1764	Assert(u32BlockX * pSurfaceDest->cxBlock == clipBox.x);
1765	Assert(u32BlockY * pSurfaceDest->cyBlock == clipBox.y);
1766
1767	LockedDestRect.pBits = (uint8_t *)pMipmapLevelDest->pSurfaceData +
1768	pMipmapLevelDest->cbSurfacePitch * u32BlockY + pSurfaceDest->cbBlock * u32BlockX;
1769	LockedDestRect.Pitch = pMipmapLevelDest->cbSurfacePitch;
1770	pSurfaceDest->fDirty = true;
1771	}
1772	else
1773	{
1774	/* Must flush the context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
1775	vmsvga3dSurfaceFlush(pSurfaceDest);
1776
1777	hr = pD3DSurf->LockRect(&LockedDestRect, &RectDest, 0);
1778	AssertMsgReturnStmt(hr == D3D_OK, ("LockRect failed with %x\n", hr), D3D_RELEASE(pD3DSurf), VERR_INTERNAL_ERROR);
1779	}
1780
1781	uint8_t pDest = (uint8_t )LockedDestRect.pBits;
1782	const uint8_t pSrc = (uint8_t )LockedSrcRect.pBits;
1783	for (uint32_t j = 0; j < cBlocksY; ++j)
1784	{
1785	memcpy(pDest, pSrc, cBlocksX * pSurfaceSrc->cbBlock);
1786	pDest += LockedDestRect.Pitch;
1787	pSrc += LockedSrcRect.Pitch;
1788	}
1789
1790	if (pD3DSurf)
1791	{
1792	hr = pD3DSurf->UnlockRect();
1793	AssertMsgReturnStmt(hr == D3D_OK, ("Unlock failed with %x\n", hr), D3D_RELEASE(pD3DSurf), VERR_INTERNAL_ERROR);
1794	}
1795	}
1796
1797	D3D_RELEASE(pD3DSurf);
1798
1799	/* If the destination bounce texture has been used, then update the actual destination texture. */
1800	if ( pSurfaceDest->u.pTexture
1801	&& pSurfaceDest->bounce.pTexture
1802	&& ( pSurfaceDest->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE
1803	\|\| pSurfaceDest->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE))
1804	{
1805	AssertMsgReturn(pContext, ("Context is NULL\n"), VERR_INTERNAL_ERROR);
1806
1807	/* Copy the new content to the actual texture object. */
1808	HRESULT hr2 = D3D9UpdateTexture(pContext, pSurfaceDest);
1809	AssertMsg(hr2 == D3D_OK, ("UpdateTexture failed with %x\n", hr2)); RT_NOREF(hr2);
1810
1811	/* Track the UpdateTexture operation. */
1812	vmsvga3dSurfaceTrackUsage(pState, pContext, pSurfaceDest);
1813	}
1814	}
1815
1816	return VINF_SUCCESS;
1817	}
1818
1819
1820	/**
1821	* Create D3D/OpenGL texture object for the specified surface.
1822	*
1823	* Surfaces are created when needed.
1824	*
1825	* @param pState The VMSVGA3d state.
1826	* @param pContext The context.
1827	* @param idAssociatedContext Probably the same as pContext->id.
1828	* @param pSurface The surface to create the texture for.
1829	*/
1830	int vmsvga3dBackCreateTexture(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t idAssociatedContext,
1831	PVMSVGA3DSURFACE pSurface)
1832
1833	{
1834	RT_NOREF(pState);
1835	HRESULT hr;
1836
1837	LogFunc(("sid=%u\n", pSurface->id));
1838
1839	Assert(pSurface->hSharedObject == NULL);
1840	Assert(pSurface->u.pTexture == NULL);
1841	Assert(pSurface->bounce.pTexture == NULL);
1842	Assert(pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_NONE);
1843
1844	const uint32_t cWidth = pSurface->paMipmapLevels[0].mipmapSize.width;
1845	const uint32_t cHeight = pSurface->paMipmapLevels[0].mipmapSize.height;
1846	const uint32_t cDepth = pSurface->paMipmapLevels[0].mipmapSize.depth;
1847	const uint32_t numMipLevels = pSurface->faces[0].numMipLevels;
1848
1849	/*
1850	* Create D3D texture object.
1851	*/
1852	if (pSurface->surfaceFlags & SVGA3D_SURFACE_CUBEMAP)
1853	{
1854	Assert(pSurface->cFaces == 6);
1855	Assert(cWidth == cHeight);
1856	Assert(cDepth == 1);
1857
1858	hr = pContext->pDevice->CreateCubeTexture(cWidth,
1859	numMipLevels,
1860	pSurface->fUsageD3D,
1861	pSurface->formatD3D,
1862	D3DPOOL_DEFAULT,
1863	&pSurface->u.pCubeTexture,
1864	&pSurface->hSharedObject);
1865	if (hr == D3D_OK)
1866	{
1867	/* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
1868	hr = pContext->pDevice->CreateCubeTexture(cWidth,
1869	numMipLevels,
1870	(pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) \| D3DUSAGE_DYNAMIC /* Lockable */,
1871	pSurface->formatD3D,
1872	D3DPOOL_SYSTEMMEM,
1873	&pSurface->bounce.pCubeTexture,
1874	NULL);
1875	AssertMsgReturnStmt(hr == D3D_OK,
1876	("CreateCubeTexture (systemmem) failed with %x\n", hr),
1877	D3D_RELEASE(pSurface->u.pCubeTexture),
1878	VERR_INTERNAL_ERROR);
1879	}
1880	else
1881	{
1882	Log(("Format not accepted -> try old method\n"));
1883	/* The format was probably not accepted; fall back to our old mode. */
1884	hr = pContext->pDevice->CreateCubeTexture(cWidth,
1885	numMipLevels,
1886	(pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) \| D3DUSAGE_DYNAMIC /* Lockable */,
1887	pSurface->formatD3D,
1888	D3DPOOL_DEFAULT,
1889	&pSurface->u.pCubeTexture,
1890	&pSurface->hSharedObject);
1891	AssertMsgReturn(hr == D3D_OK, ("CreateCubeTexture (fallback) failed with %x\n", hr), VERR_INTERNAL_ERROR);
1892	}
1893
1894	pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE;
1895	}
1896	else if ( pSurface->formatD3D == D3DFMT_D24S8
1897	\|\| pSurface->formatD3D == D3DFMT_D24X8
1898	\|\| pSurface->formatD3D == D3DFMT_D32
1899	\|\| pSurface->formatD3D == D3DFMT_D16)
1900	{
1901	Assert(pSurface->cFaces == 1);
1902	Assert(pSurface->faces[0].numMipLevels == 1);
1903	Assert(cDepth == 1);
1904
1905	/* Use the INTZ format for a depth/stencil surface that will be used as a texture */
1906	hr = pContext->pDevice->CreateTexture(cWidth,
1907	cHeight,
1908	1, /* mip levels */
1909	D3DUSAGE_DEPTHSTENCIL,
1910	FOURCC_INTZ,
1911	D3DPOOL_DEFAULT,
1912	&pSurface->u.pTexture,
1913	&pSurface->hSharedObject /* might result in poor performance */);
1914	if ( hr == D3D_OK
1915	&& ( pSurface->formatD3D == D3DFMT_D24S8
1916	\|\| pSurface->formatD3D == D3DFMT_D24X8))
1917	{
1918	/* Create another texture object to serve as a bounce buffer as the
1919	* D3DFMT_D24S8 and D3DFMT_D24X8 surface can't be locked apparently (from testing).
1920	*/
1921	hr = pContext->pDevice->CreateTexture(cWidth,
1922	cHeight,
1923	1, /* mip levels */
1924	D3DUSAGE_DYNAMIC /* Lockable */,
1925	FOURCC_INTZ,
1926	D3DPOOL_SYSTEMMEM,
1927	&pSurface->bounce.pTexture,
1928	NULL);
1929	AssertMsgReturn(hr == D3D_OK, ("CreateTexture (systemmem) failed with %x\n", hr), VERR_INTERNAL_ERROR);
1930	}
1931	AssertMsgReturn(hr == D3D_OK, ("CreateTexture INTZ failed with %x\n", hr), VERR_INTERNAL_ERROR);
1932
1933	pSurface->fStencilAsTexture = true;
1934	pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_TEXTURE;
1935	}
1936	else
1937	{
1938	if (cDepth > 1)
1939	{
1940	hr = pContext->pDevice->CreateVolumeTexture(cWidth,
1941	cHeight,
1942	cDepth,
1943	numMipLevels,
1944	pSurface->fUsageD3D,
1945	pSurface->formatD3D,
1946	D3DPOOL_DEFAULT,
1947	&pSurface->u.pVolumeTexture,
1948	&pSurface->hSharedObject);
1949	if (hr == D3D_OK)
1950	{
1951	/* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
1952	hr = pContext->pDevice->CreateVolumeTexture(cWidth,
1953	cHeight,
1954	cDepth,
1955	numMipLevels,
1956	(pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) \| D3DUSAGE_DYNAMIC /* Lockable */,
1957	pSurface->formatD3D,
1958	D3DPOOL_SYSTEMMEM,
1959	&pSurface->bounce.pVolumeTexture,
1960	NULL);
1961	AssertMsgReturnStmt(hr == D3D_OK,
1962	("CreateVolumeTexture (systemmem) failed with %x\n", hr),
1963	D3D_RELEASE(pSurface->u.pVolumeTexture),
1964	VERR_INTERNAL_ERROR);
1965	}
1966	else
1967	{
1968	Log(("Format not accepted -> try old method\n"));
1969	/* The format was probably not accepted; fall back to our old mode. */
1970	hr = pContext->pDevice->CreateVolumeTexture(cWidth,
1971	cHeight,
1972	cDepth,
1973	numMipLevels,
1974	(pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) \| D3DUSAGE_DYNAMIC /* Lockable */,
1975	pSurface->formatD3D,
1976	D3DPOOL_DEFAULT,
1977	&pSurface->u.pVolumeTexture,
1978	&pSurface->hSharedObject);
1979	AssertMsgReturn(hr == D3D_OK, ("CreateVolumeTexture (fallback) failed with %x\n", hr), VERR_INTERNAL_ERROR);
1980	}
1981
1982	pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE;
1983	}
1984	else
1985	{
1986	Assert(pSurface->cFaces == 1);
1987
1988	hr = pContext->pDevice->CreateTexture(cWidth,
1989	cHeight,
1990	numMipLevels,
1991	pSurface->fUsageD3D \| D3DUSAGE_RENDERTARGET /* required for use as a StretchRect destination */,
1992	pSurface->formatD3D,
1993	D3DPOOL_DEFAULT,
1994	&pSurface->u.pTexture,
1995	&pSurface->hSharedObject);
1996	if (hr == D3D_OK)
1997	{
1998	/* Create another texture object to serve as a bounce buffer as the above texture surface can't be locked. */
1999	hr = pContext->pDevice->CreateTexture(cWidth,
2000	cHeight,
2001	numMipLevels,
2002	(pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) \| D3DUSAGE_DYNAMIC /* Lockable */,
2003	pSurface->formatD3D,
2004	D3DPOOL_SYSTEMMEM,
2005	&pSurface->bounce.pTexture,
2006	NULL);
2007	AssertMsgReturn(hr == D3D_OK, ("CreateTexture (systemmem) failed with %x\n", hr), VERR_INTERNAL_ERROR);
2008
2009	if (pSurface->formatD3D != pSurface->d3dfmtRequested)
2010	{
2011	/* Create a staging texture/render target for format conversion. */
2012	hr = pContext->pDevice->CreateTexture(cWidth,
2013	cHeight,
2014	numMipLevels,
2015	pSurface->fUsageD3D \| D3DUSAGE_RENDERTARGET,
2016	pSurface->formatD3D,
2017	D3DPOOL_DEFAULT,
2018	&pSurface->emulated.pTexture,
2019	NULL);
2020	AssertMsgReturn(hr == D3D_OK, ("CreateTexture (emulated) failed with %x\n", hr), VERR_INTERNAL_ERROR);
2021	}
2022	}
2023	else
2024	{
2025	Log(("Format not accepted (%x) -> try old method\n", hr));
2026	/* The format was probably not accepted; fall back to our old mode. */
2027	hr = pContext->pDevice->CreateTexture(cWidth,
2028	cHeight,
2029	numMipLevels,
2030	(pSurface->fUsageD3D & ~D3DUSAGE_RENDERTARGET) \| D3DUSAGE_DYNAMIC /* Lockable */,
2031	pSurface->formatD3D,
2032	D3DPOOL_DEFAULT,
2033	&pSurface->u.pTexture,
2034	&pSurface->hSharedObject /* might result in poor performance */);
2035	AssertMsgReturn(hr == D3D_OK, ("CreateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
2036	}
2037
2038	pSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_TEXTURE;
2039	}
2040	}
2041
2042	Assert(hr == D3D_OK);
2043
2044	if (pSurface->autogenFilter != SVGA3D_TEX_FILTER_NONE)
2045	{
2046	/* Set the mip map generation filter settings. */
2047	IDirect3DBaseTexture9 *pBaseTexture;
2048	if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
2049	pBaseTexture = pSurface->u.pVolumeTexture;
2050	else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
2051	pBaseTexture = pSurface->u.pCubeTexture;
2052	else
2053	pBaseTexture = pSurface->u.pTexture;
2054	hr = pBaseTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)pSurface->autogenFilter);
2055	AssertMsg(hr == D3D_OK, ("vmsvga3dBackCreateTexture: SetAutoGenFilterType failed with %x\n", hr));
2056	}
2057
2058	/*
2059	* Always initialize all mipmap levels using the in memory data
2060	* to make sure that the just created texture has the up-to-date content.
2061	* The OpenGL backend does this too.
2062	*/
2063	Log(("vmsvga3dBackCreateTexture: sync texture\n"));
2064
2065	if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
2066	{
2067	IDirect3DVolumeTexture9 *pVolumeTexture = pSurface->bounce.pVolumeTexture ?
2068	pSurface->bounce.pVolumeTexture :
2069	pSurface->u.pVolumeTexture;
2070
2071	for (uint32_t i = 0; i < numMipLevels; ++i)
2072	{
2073	D3DLOCKED_BOX LockedVolume;
2074	hr = pVolumeTexture->LockBox(i, &LockedVolume, NULL, D3DLOCK_DISCARD);
2075	AssertMsgBreak(hr == D3D_OK, ("LockBox failed with %x\n", hr));
2076
2077	PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[i];
2078
2079	LogFunc(("sync volume texture mipmap level %d (pitch row %x vs %x, slice %x vs %x)\n",
2080	i, LockedVolume.RowPitch, pMipLevel->cbSurfacePitch, LockedVolume.SlicePitch, pMipLevel->cbSurfacePlane));
2081
2082
2083	uint8_t pDst = (uint8_t )LockedVolume.pBits;
2084	const uint8_t pSrc = (uint8_t )pMipLevel->pSurfaceData;
2085	for (uint32_t d = 0; d < cDepth; ++d)
2086	{
2087	uint8_t *pRowDst = pDst;
2088	const uint8_t *pRowSrc = pSrc;
2089	for (uint32_t h = 0; h < pMipLevel->cBlocksY; ++h)
2090	{
2091	memcpy(pRowDst, pRowSrc, pMipLevel->cbSurfacePitch);
2092	pRowDst += LockedVolume.RowPitch;
2093	pRowSrc += pMipLevel->cbSurfacePitch;
2094	}
2095	pDst += LockedVolume.SlicePitch;
2096	pSrc += pMipLevel->cbSurfacePlane;
2097	}
2098
2099	hr = pVolumeTexture->UnlockBox(i);
2100	AssertMsgBreak(hr == D3D_OK, ("UnlockBox failed with %x\n", hr));
2101
2102	pMipLevel->fDirty = false;
2103	}
2104	}
2105	else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE)
2106	{
2107	IDirect3DCubeTexture9 *pCubeTexture = pSurface->bounce.pCubeTexture ?
2108	pSurface->bounce.pCubeTexture :
2109	pSurface->u.pCubeTexture;
2110
2111	for (uint32_t iFace = 0; iFace < 6; ++iFace)
2112	{
2113	const D3DCUBEMAP_FACES Face = vmsvga3dCubemapFaceFromIndex(iFace);
2114
2115	for (uint32_t i = 0; i < numMipLevels; ++i)
2116	{
2117	D3DLOCKED_RECT LockedRect;
2118	hr = pCubeTexture->LockRect(Face,
2119	i, /* texture level */
2120	&LockedRect,
2121	NULL, /* entire texture */
2122	0);
2123	AssertMsgBreak(hr == D3D_OK, ("LockRect failed with %x\n", hr));
2124
2125	PVMSVGA3DMIPMAPLEVEL pMipLevel = &pSurface->paMipmapLevels[iFace * numMipLevels + i];
2126
2127	LogFunc(("sync texture face %d mipmap level %d (pitch %x vs %x)\n",
2128	iFace, i, LockedRect.Pitch, pMipLevel->cbSurfacePitch));
2129
2130	uint8_t pDest = (uint8_t )LockedRect.pBits;
2131	const uint8_t pSrc = (uint8_t )pMipLevel->pSurfaceData;
2132	for (uint32_t j = 0; j < pMipLevel->cBlocksY; ++j)
2133	{
2134	memcpy(pDest, pSrc, pMipLevel->cbSurfacePitch);
2135
2136	pDest += LockedRect.Pitch;
2137	pSrc += pMipLevel->cbSurfacePitch;
2138	}
2139
2140	hr = pCubeTexture->UnlockRect(Face, i /* texture level */);
2141	AssertMsgBreak(hr == D3D_OK, ("UnlockRect failed with %x\n", hr));
2142
2143	pMipLevel->fDirty = false;
2144	}
2145
2146	if (hr != D3D_OK)
2147	break;
2148	}
2149
2150	if (hr != D3D_OK)
2151	{
2152	D3D_RELEASE(pSurface->bounce.pCubeTexture);
2153	D3D_RELEASE(pSurface->u.pCubeTexture);
2154	return VERR_INTERNAL_ERROR;
2155	}
2156	}
2157	else if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE)
2158	{
2159	IDirect3DTexture9 *pTexture;
2160	if (pSurface->bounce.pTexture)
2161	pTexture = pSurface->bounce.pTexture;
2162	else if (pSurface->formatD3D != pSurface->d3dfmtRequested)
2163	pTexture = pSurface->emulated.pTexture;
2164	else
2165	pTexture = pSurface->u.pTexture;
2166
2167	for (uint32_t i = 0; i < numMipLevels; ++i)
2168	{
2169	D3DLOCKED_RECT LockedRect;
2170
2171	hr = pTexture->LockRect(i, /* texture level */
2172	&LockedRect,
2173	NULL, /* entire texture */
2174	0);
2175
2176	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2177
2178	LogFunc(("sync texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pSurface->paMipmapLevels[i].cbSurfacePitch));
2179
2180	uint8_t pDest = (uint8_t )LockedRect.pBits;
2181	const uint8_t pSrc = (uint8_t )pSurface->paMipmapLevels[i].pSurfaceData;
2182	for (uint32_t j = 0; j < pSurface->paMipmapLevels[i].cBlocksY; ++j)
2183	{
2184	memcpy(pDest, pSrc, pSurface->paMipmapLevels[i].cbSurfacePitch);
2185
2186	pDest += LockedRect.Pitch;
2187	pSrc += pSurface->paMipmapLevels[i].cbSurfacePitch;
2188	}
2189
2190	hr = pTexture->UnlockRect(i /* texture level */);
2191	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dBackCreateTexture: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2192
2193	pSurface->paMipmapLevels[i].fDirty = false;
2194	}
2195	}
2196	else
2197	{
2198	AssertMsgFailedReturn(("enmD3DResType not expected %d\n", pSurface->enmD3DResType), VERR_INTERNAL_ERROR);
2199	}
2200
2201	if (pSurface->bounce.pTexture)
2202	{
2203	Log(("vmsvga3dBackCreateTexture: sync dirty texture from bounce buffer\n"));
2204	if (pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE)
2205	hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pVolumeTexture, pSurface->u.pVolumeTexture);
2206	else
2207	hr = D3D9UpdateTexture(pContext, pSurface);
2208	AssertMsgReturn(hr == D3D_OK, ("UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
2209
2210	/* We will now use the bounce texture for all memory accesses, so free our surface memory buffer. */
2211	for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
2212	{
2213	RTMemFree(pSurface->paMipmapLevels[i].pSurfaceData);
2214	pSurface->paMipmapLevels[i].pSurfaceData = NULL;
2215	}
2216
2217	/* Track the UpdateTexture operation. */
2218	vmsvga3dSurfaceTrackUsage(pState, pContext, pSurface);
2219	}
2220	pSurface->fDirty = false;
2221
2222	Assert(pSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_NONE);
2223
2224	pSurface->surfaceFlags \|= SVGA3D_SURFACE_HINT_TEXTURE;
2225	pSurface->idAssociatedContext = idAssociatedContext;
2226	return VINF_SUCCESS;
2227	}
2228
2229
2230	/**
2231	* Backend worker for implementing SVGA_3D_CMD_SURFACE_STRETCHBLT.
2232	*
2233	* @returns VBox status code.
2234	* @param pThis The VGA device instance.
2235	* @param pState The VMSVGA3d state.
2236	* @param pDstSurface The destination host surface.
2237	* @param uDstFace The destination face (valid).
2238	* @param uDstMipmap The destination mipmap level (valid).
2239	* @param pDstBox The destination box.
2240	* @param pSrcSurface The source host surface.
2241	* @param uSrcFace The destination face (valid).
2242	* @param uSrcMipmap The source mimap level (valid).
2243	* @param pSrcBox The source box.
2244	* @param enmMode The strecht blt mode .
2245	* @param pContext The VMSVGA3d context (already current for OGL).
2246	*/
2247	int vmsvga3dBackSurfaceStretchBlt(PVGASTATE pThis, PVMSVGA3DSTATE pState,
2248	PVMSVGA3DSURFACE pDstSurface, uint32_t uDstFace, uint32_t uDstMipmap, SVGA3dBox const *pDstBox,
2249	PVMSVGA3DSURFACE pSrcSurface, uint32_t uSrcFace, uint32_t uSrcMipmap, SVGA3dBox const *pSrcBox,
2250	SVGA3dStretchBltMode enmMode, PVMSVGA3DCONTEXT pContext)
2251	{
2252	RT_NOREF(pThis);
2253
2254	HRESULT hr;
2255	int rc;
2256
2257	AssertReturn(pSrcSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE, VERR_NOT_IMPLEMENTED);
2258	AssertReturn(pDstSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE, VERR_NOT_IMPLEMENTED);
2259
2260	/* Flush the drawing pipeline for this surface as it could be used in a shared context. */
2261	vmsvga3dSurfaceFlush(pSrcSurface);
2262	vmsvga3dSurfaceFlush(pDstSurface);
2263
2264	RECT RectSrc;
2265	RectSrc.left = pSrcBox->x;
2266	RectSrc.top = pSrcBox->y;
2267	RectSrc.right = pSrcBox->x + pSrcBox->w; /* exclusive */
2268	RectSrc.bottom = pSrcBox->y + pSrcBox->h; /* exclusive */
2269	Assert(!pSrcBox->z);
2270
2271	RECT RectDst;
2272	RectDst.left = pDstBox->x;
2273	RectDst.top = pDstBox->y;
2274	RectDst.right = pDstBox->x + pDstBox->w; /* exclusive */
2275	RectDst.bottom = pDstBox->y + pDstBox->h; /* exclusive */
2276	Assert(!pDstBox->z);
2277
2278	IDirect3DSurface9 *pSrc;
2279	rc = vmsvga3dGetD3DSurface(pState, pContext, pSrcSurface, uSrcFace, uSrcMipmap, false, &pSrc);
2280	AssertRCReturn(rc, rc);
2281
2282	IDirect3DSurface9 *pDst;
2283	rc = vmsvga3dGetD3DSurface(pState, pContext, pDstSurface, uDstFace, uDstMipmap, false, &pDst);
2284	AssertRCReturn(rc, rc);
2285
2286	D3DTEXTUREFILTERTYPE moded3d;
2287	switch (enmMode)
2288	{
2289	case SVGA3D_STRETCH_BLT_POINT:
2290	moded3d = D3DTEXF_POINT;
2291	break;
2292
2293	case SVGA3D_STRETCH_BLT_LINEAR:
2294	moded3d = D3DTEXF_LINEAR;
2295	break;
2296
2297	default:
2298	AssertFailed();
2299	moded3d = D3DTEXF_NONE;
2300	break;
2301	}
2302
2303	hr = pContext->pDevice->StretchRect(pSrc, &RectSrc, pDst, &RectDst, moded3d);
2304
2305	D3D_RELEASE(pDst);
2306	D3D_RELEASE(pSrc);
2307
2308	AssertMsgReturn(hr == D3D_OK, ("StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2309
2310	/* Track the StretchRect operation. */
2311	vmsvga3dSurfaceTrackUsage(pState, pContext, pSrcSurface);
2312	vmsvga3dSurfaceTrackUsage(pState, pContext, pDstSurface);
2313
2314	return VINF_SUCCESS;
2315	}
2316
2317
2318	/**
2319	* Backend worker for implementing SVGA_3D_CMD_SURFACE_DMA that copies one box.
2320	*
2321	* @returns Failure status code or @a rc.
2322	* @param pThis The shared VGA/VMSVGA instance data.
2323	* @param pThisCC The VGA/VMSVGA state for ring-3.
2324	* @param pState The VMSVGA3d state.
2325	* @param pSurface The host surface.
2326	* @param pMipLevel Mipmap level. The caller knows it already.
2327	* @param uHostFace The host face (valid).
2328	* @param uHostMipmap The host mipmap level (valid).
2329	* @param GuestPtr The guest pointer.
2330	* @param cbGuestPitch The guest pitch.
2331	* @param transfer The transfer direction.
2332	* @param pBox The box to copy (clipped, valid, except for guest's srcx, srcy, srcz).
2333	* @param pContext The context (for OpenGL).
2334	* @param rc The current rc for all boxes.
2335	* @param iBox The current box number (for Direct 3D).
2336	*/
2337	int vmsvga3dBackSurfaceDMACopyBox(PVGASTATE pThis, PVGASTATECC pThisCC, PVMSVGA3DSTATE pState, PVMSVGA3DSURFACE pSurface,
2338	PVMSVGA3DMIPMAPLEVEL pMipLevel, uint32_t uHostFace, uint32_t uHostMipmap,
2339	SVGAGuestPtr GuestPtr, uint32_t cbGuestPitch, SVGA3dTransferType transfer,
2340	SVGA3dCopyBox const *pBox, PVMSVGA3DCONTEXT pContext, int rc, int iBox)
2341	{
2342	HRESULT hr = D3D_OK;
2343	const DWORD dwFlags = transfer == SVGA3D_READ_HOST_VRAM ? D3DLOCK_READONLY : 0;
2344
2345	AssertReturn(pSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE, VERR_NOT_IMPLEMENTED);
2346
2347	const bool fTexture = pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE
2348	\|\| pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE;
2349	if ( pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_SURFACE
2350	\|\| fTexture)
2351	{
2352	rc = vmsvga3dContextFromCid(pState, pSurface->idAssociatedContext, &pContext);
2353	AssertRCReturn(rc, rc);
2354
2355	/* Get the surface involved in the transfer. */
2356	IDirect3DSurface9 *pSurf;
2357	rc = vmsvga3dGetD3DSurface(pState, pContext, pSurface, uHostFace, uHostMipmap, true, &pSurf);
2358	AssertRCReturn(rc, rc);
2359
2360	if (transfer == SVGA3D_READ_HOST_VRAM)
2361	{
2362	/* Texture data is copied to the host VRAM.
2363	* Update the 'bounce' texture if necessary.
2364	*/
2365	if ( fTexture
2366	&& pSurface->bounce.pTexture
2367	&& iBox == 0 /* only the first time */)
2368	{
2369	/** @todo inefficient for VRAM buffers!! */
2370	if (RT_BOOL(pSurface->surfaceFlags & SVGA3D_SURFACE_HINT_RENDERTARGET))
2371	{
2372	/* Copy the texture mipmap level to the bounce texture. */
2373	hr = D3D9GetRenderTargetData(pContext, pSurface, uHostFace, uHostMipmap);
2374	AssertMsgReturn(hr == D3D_OK, ("D3D9GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
2375	}
2376	}
2377	}
2378
2379	uint32_t const u32GuestBlockX = pBox->srcx / pSurface->cxBlock;
2380	uint32_t const u32GuestBlockY = pBox->srcy / pSurface->cyBlock;
2381	Assert(u32GuestBlockX * pSurface->cxBlock == pBox->srcx);
2382	Assert(u32GuestBlockY * pSurface->cyBlock == pBox->srcy);
2383	uint32_t const cBlocksX = (pBox->w + pSurface->cxBlock - 1) / pSurface->cxBlock;
2384	uint32_t const cBlocksY = (pBox->h + pSurface->cyBlock - 1) / pSurface->cyBlock;
2385	AssertMsgReturn(cBlocksX && cBlocksY, ("Empty box %dx%d\n", pBox->w, pBox->h), VERR_INTERNAL_ERROR);
2386
2387	/* vmsvgaR3GmrTransfer verifies uGuestOffset.
2388	* srcx(u32GuestBlockX) and srcy(u32GuestBlockY) have been verified in vmsvga3dSurfaceDMA
2389	* to not cause 32 bit overflow when multiplied by cbBlock and cbGuestPitch.
2390	*/
2391	uint64_t const uGuestOffset = u32GuestBlockX * pSurface->cbBlock + u32GuestBlockY * cbGuestPitch;
2392	AssertReturn(uGuestOffset < UINT32_MAX, VERR_INVALID_PARAMETER);
2393
2394	RECT Rect;
2395	Rect.left = pBox->x;
2396	Rect.top = pBox->y;
2397	Rect.right = pBox->x + pBox->w; /* exclusive */
2398	Rect.bottom = pBox->y + pBox->h; /* exclusive */
2399
2400	D3DLOCKED_RECT LockedRect;
2401	hr = pSurf->LockRect(&LockedRect, &Rect, dwFlags);
2402	AssertMsgReturn(hr == D3D_OK, ("LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2403
2404	LogFunc(("Lock sid=%u %s(bounce=%d) memory for rectangle (%d,%d)(%d,%d)\n",
2405	pSurface->id, fTexture ? "TEXTURE " : "", RT_BOOL(pSurface->bounce.pTexture),
2406	Rect.left, Rect.top, Rect.right, Rect.bottom));
2407
2408	/* Prepare parameters for vmsvgaR3GmrTransfer, which needs the host buffer address, size
2409	* and offset of the first scanline.
2410	*/
2411	uint32_t const cbLockedBuf = RT_ABS(LockedRect.Pitch) * cBlocksY;
2412	uint8_t pu8LockedBuf = (uint8_t )LockedRect.pBits;
2413	if (LockedRect.Pitch < 0)
2414	pu8LockedBuf -= cbLockedBuf + LockedRect.Pitch;
2415	uint32_t const offLockedBuf = (uint32_t)((uintptr_t)LockedRect.pBits - (uintptr_t)pu8LockedBuf);
2416
2417	rc = vmsvgaR3GmrTransfer(pThis,
2418	pThisCC,
2419	transfer,
2420	pu8LockedBuf,
2421	cbLockedBuf,
2422	offLockedBuf,
2423	LockedRect.Pitch,
2424	GuestPtr,
2425	(uint32_t)uGuestOffset,
2426	cbGuestPitch,
2427	cBlocksX * pSurface->cbBlock,
2428	cBlocksY);
2429	AssertRC(rc);
2430
2431	Log4(("first line:\n%.Rhxd\n", cBlocksX pSurface->cbBlock, LockedRect.pBits));
2432
2433	hr = pSurf->UnlockRect();
2434
2435	D3D_RELEASE(pSurf);
2436
2437	AssertMsgReturn(hr == D3D_OK, ("UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2438
2439	if (transfer == SVGA3D_WRITE_HOST_VRAM)
2440	{
2441	/* Data is copied to the texture. Copy updated 'bounce' texture to the actual if necessary.
2442	*/
2443	/// @todo for the last iBox only.
2444	if ( fTexture
2445	&& pSurface->bounce.pTexture)
2446	{
2447	LogFunc(("Sync texture from bounce buffer\n"));
2448
2449	/* Copy the new contents to the actual texture object. */
2450	hr = D3D9UpdateTexture(pContext, pSurface);
2451	AssertMsgReturn(hr == D3D_OK, ("UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
2452
2453	/* Track the copy operation. */
2454	vmsvga3dSurfaceTrackUsage(pState, pContext, pSurface);
2455	}
2456	}
2457	}
2458	else if ( pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER
2459	\|\| pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_INDEX_BUFFER)
2460	{
2461	/*
2462	* Mesa SVGA driver can use the same buffer either for vertex or index data.
2463	* But D3D distinguishes between index and vertex buffer objects.
2464	* Therefore it should be possible to switch the buffer type on the fly.
2465	*
2466	* Always save the data to the memory buffer in pSurface->paMipmapLevels and,
2467	* if necessary, recreate the corresponding D3D object with the data.
2468	*/
2469
2470	/* Buffers are uncompressed. */
2471	AssertReturn(pSurface->cxBlock == 1 && pSurface->cyBlock == 1, VERR_INTERNAL_ERROR);
2472
2473	/* Caller already clipped pBox and buffers are 1-dimensional. */
2474	Assert(pBox->y == 0 && pBox->h == 1 && pBox->z == 0 && pBox->d == 1);
2475
2476	/* The caller has already updated pMipLevel->pSurfaceData, see VMSVGA3DSURFACE_NEEDS_DATA. */
2477
2478	#ifdef LOG_ENABLED
2479	uint32_t const offHst = pBox->x * pSurface->cbBlock;
2480	uint32_t const cbWidth = pBox->w * pSurface->cbBlock;
2481	Log4(("Buffer updated at [0x%x;0x%x):\n%.Rhxd\n", offHst, offHst + cbWidth, cbWidth, (uint8_t )pMipLevel->pSurfaceData + offHst));
2482	#endif
2483
2484	/* Do not bother to copy the data to the D3D resource now. vmsvga3dDrawPrimitives will do that.
2485	* The SVGA driver may use the same surface for both index and vertex data.
2486	*/
2487
2488	/* Make sure that vmsvga3dDrawPrimitives fetches the new data. */
2489	pMipLevel->fDirty = true;
2490	pSurface->fDirty = true;
2491	}
2492	else
2493	{
2494	AssertMsgFailed(("Unsupported surface flags 0x%08X, type %d\n", pSurface->surfaceFlags, pSurface->enmD3DResType));
2495	}
2496
2497	return rc;
2498	}
2499
2500	int vmsvga3dGenerateMipmaps(PVGASTATECC pThisCC, uint32_t sid, SVGA3dTextureFilter filter)
2501	{
2502	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2503	HRESULT hr;
2504
2505	PVMSVGA3DSURFACE pSurface;
2506	int rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
2507	AssertRCReturn(rc, rc);
2508	AssertReturn(pSurface->idAssociatedContext != SVGA3D_INVALID_ID, VERR_INTERNAL_ERROR);
2509
2510	Assert(filter != SVGA3D_TEX_FILTER_FLATCUBIC);
2511	Assert(filter != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
2512	pSurface->autogenFilter = filter;
2513
2514	Log(("vmsvga3dGenerateMipmaps: sid=%u filter=%d\n", sid, filter));
2515
2516	if (!pSurface->u.pSurface)
2517	{
2518	/** @todo stricter checks for associated context */
2519	uint32_t const cid = pSurface->idAssociatedContext;
2520
2521	PVMSVGA3DCONTEXT pContext;
2522	rc = vmsvga3dContextFromCid(pState, cid, &pContext);
2523	AssertRCReturn(rc, rc);
2524
2525	/* Unknown surface type; turn it into a texture. */
2526	LogFunc(("unknown src surface sid=%u type=%d format=%d -> create texture\n", sid, pSurface->surfaceFlags, pSurface->format));
2527	rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
2528	AssertRCReturn(rc, rc);
2529	}
2530	else
2531	{
2532	hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)filter);
2533	AssertMsg(hr == D3D_OK, ("SetAutoGenFilterType failed with %x\n", hr));
2534	}
2535
2536	/* Generate the mip maps. */
2537	pSurface->u.pTexture->GenerateMipSubLevels();
2538
2539	return VINF_SUCCESS;
2540	}
2541
2542
2543	/**
2544	* Create a new 3d context
2545	*
2546	* @returns VBox status code.
2547	* @param pThisCC The VGA/VMSVGA state for ring-3.
2548	* @param cid Context id
2549	*/
2550	int vmsvga3dContextDefine(PVGASTATECC pThisCC, uint32_t cid)
2551	{
2552	int rc;
2553	PVMSVGA3DCONTEXT pContext;
2554	HRESULT hr;
2555	D3DPRESENT_PARAMETERS PresParam;
2556	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2557
2558	Log(("vmsvga3dContextDefine id %x\n", cid));
2559
2560	AssertReturn(pState, VERR_NO_MEMORY);
2561	AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
2562
2563	if (cid >= pState->cContexts)
2564	{
2565	/* Grow the array. */
2566	uint32_t cNew = RT_ALIGN(cid + 15, 16);
2567	void pvNew = RTMemRealloc(pState->papContexts, sizeof(pState->papContexts[0]) cNew);
2568	AssertReturn(pvNew, VERR_NO_MEMORY);
2569	pState->papContexts = (PVMSVGA3DCONTEXT *)pvNew;
2570	while (pState->cContexts < cNew)
2571	{
2572	pContext = (PVMSVGA3DCONTEXT)RTMemAllocZ(sizeof(*pContext));
2573	AssertReturn(pContext, VERR_NO_MEMORY);
2574	pContext->id = SVGA3D_INVALID_ID;
2575	pState->papContexts[pState->cContexts++] = pContext;
2576	}
2577	}
2578	/* If one already exists with this id, then destroy it now. */
2579	if (pState->papContexts[cid]->id != SVGA3D_INVALID_ID)
2580	vmsvga3dContextDestroy(pThisCC, cid);
2581
2582	pContext = pState->papContexts[cid];
2583	memset(pContext, 0, sizeof(*pContext));
2584	pContext->id = cid;
2585	for (uint32_t i = 0; i< RT_ELEMENTS(pContext->aSidActiveTextures); i++)
2586	pContext->aSidActiveTextures[i] = SVGA3D_INVALID_ID;
2587	pContext->state.shidVertex = SVGA3D_INVALID_ID;
2588	pContext->state.shidPixel = SVGA3D_INVALID_ID;
2589
2590	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderTargets); i++)
2591	pContext->state.aRenderTargets[i] = SVGA3D_INVALID_ID;
2592
2593	/* Create a context window with minimal 4x4 size. We will never use the swapchain
2594	* to present the rendered image. Rendered images from the guest will be copied to
2595	* the VMSVGA SCREEN object, which can be either an offscreen render target or
2596	* system memory in the guest VRAM.
2597	*/
2598	rc = vmsvga3dContextWindowCreate(pState->hInstance, pState->pWindowThread, pState->WndRequestSem, &pContext->hwnd);
2599	AssertRCReturn(rc, rc);
2600
2601	/* Changed when the function returns. */
2602	PresParam.BackBufferWidth = 0;
2603	PresParam.BackBufferHeight = 0;
2604	PresParam.BackBufferFormat = D3DFMT_UNKNOWN;
2605	PresParam.BackBufferCount = 0;
2606
2607	PresParam.MultiSampleType = D3DMULTISAMPLE_NONE;
2608	PresParam.MultiSampleQuality = 0;
2609	PresParam.SwapEffect = D3DSWAPEFFECT_DISCARD;
2610	PresParam.hDeviceWindow = pContext->hwnd;
2611	PresParam.Windowed = TRUE;
2612	PresParam.EnableAutoDepthStencil = FALSE;
2613	PresParam.AutoDepthStencilFormat = D3DFMT_UNKNOWN; /* not relevant */
2614	PresParam.Flags = 0;
2615	PresParam.FullScreen_RefreshRateInHz = 0; /* windowed -> 0 */
2616	/** @todo consider using D3DPRESENT_DONOTWAIT so we don't wait for the GPU during Present calls. */
2617	PresParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
2618
2619	#ifdef VBOX_VMSVGA3D_WITH_WINE_OPENGL
2620	hr = pState->pD3D9->CreateDevice(D3DADAPTER_DEFAULT,
2621	D3DDEVTYPE_HAL,
2622	pContext->hwnd,
2623	D3DCREATE_MULTITHREADED \| D3DCREATE_MIXED_VERTEXPROCESSING, //D3DCREATE_HARDWARE_VERTEXPROCESSING,
2624	&PresParam,
2625	&pContext->pDevice);
2626	#else
2627	hr = pState->pD3D9->CreateDeviceEx(D3DADAPTER_DEFAULT,
2628	D3DDEVTYPE_HAL,
2629	pContext->hwnd,
2630	D3DCREATE_MULTITHREADED \| D3DCREATE_MIXED_VERTEXPROCESSING, //D3DCREATE_HARDWARE_VERTEXPROCESSING,
2631	&PresParam,
2632	NULL,
2633	&pContext->pDevice);
2634	#endif
2635	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dContextDefine: CreateDevice failed with %x\n", hr), VERR_INTERNAL_ERROR);
2636
2637	Log(("vmsvga3dContextDefine: Backbuffer (%d,%d) count=%d format=%x\n", PresParam.BackBufferWidth, PresParam.BackBufferHeight, PresParam.BackBufferCount, PresParam.BackBufferFormat));
2638	return VINF_SUCCESS;
2639	}
2640
2641	/**
2642	* Destroy an existing 3d context
2643	*
2644	* @returns VBox status code.
2645	* @param pThisCC The VGA/VMSVGA state for ring-3.
2646	* @param cid Context id
2647	*/
2648	int vmsvga3dContextDestroy(PVGASTATECC pThisCC, uint32_t cid)
2649	{
2650	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2651	AssertReturn(pState, VERR_NO_MEMORY);
2652
2653	AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
2654
2655	if ( cid < pState->cContexts
2656	&& pState->papContexts[cid]->id == cid)
2657	{
2658	PVMSVGA3DCONTEXT pContext = pState->papContexts[cid];
2659
2660	Log(("vmsvga3dContextDestroy id %x\n", cid));
2661
2662	/* Cleanup the device runtime state. */
2663	D3D_RELEASE(pContext->d3dState.pVertexDecl);
2664
2665	/* Check for all surfaces that are associated with this context to remove all dependencies */
2666	for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
2667	{
2668	PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
2669	if ( pSurface->id == sid
2670	&& pSurface->idAssociatedContext == cid)
2671	{
2672	int rc;
2673
2674	LogFunc(("Remove all dependencies for surface sid=%u\n", sid));
2675
2676	uint32_t surfaceFlags = pSurface->surfaceFlags;
2677	SVGA3dSurfaceFormat format = pSurface->format;
2678	SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES];
2679	uint32_t multisampleCount = pSurface->multiSampleCount;
2680	SVGA3dTextureFilter autogenFilter = pSurface->autogenFilter;
2681	SVGA3dSize *pMipLevelSize;
2682	uint32_t cFaces = pSurface->cFaces;
2683
2684	pMipLevelSize = (SVGA3dSize )RTMemAllocZ(pSurface->faces[0].numMipLevels pSurface->cFaces * sizeof(SVGA3dSize));
2685	AssertReturn(pMipLevelSize, VERR_NO_MEMORY);
2686
2687	for (uint32_t face=0; face < pSurface->cFaces; face++)
2688	{
2689	for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
2690	{
2691	uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
2692	memcpy(&pMipLevelSize[idx], &pSurface->paMipmapLevels[idx].mipmapSize, sizeof(SVGA3dSize));
2693	}
2694	}
2695	memcpy(face, pSurface->faces, sizeof(pSurface->faces));
2696
2697	/* Recreate the surface with the original settings; destroys the contents, but that seems fairly safe since the context is also destroyed. */
2698	#ifdef DEBUG_sunlover
2699	/** @todo not safe with shared objects */
2700	Assert(pSurface->pSharedObjectTree == NULL);
2701	#endif
2702
2703	rc = vmsvga3dSurfaceDestroy(pThisCC, sid);
2704	AssertRC(rc);
2705
2706	rc = vmsvga3dSurfaceDefine(pThisCC, sid, surfaceFlags, format, face, multisampleCount, autogenFilter,
2707	face[0].numMipLevels * cFaces, pMipLevelSize);
2708	AssertRC(rc);
2709
2710	Assert(!pSurface->u.pSurface);
2711	}
2712	else
2713	{
2714	/* Check for a shared surface object. */
2715	PVMSVGA3DSHAREDSURFACE pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTAvlU32Get(&pSurface->pSharedObjectTree, cid);
2716	if (pSharedSurface)
2717	{
2718	LogFunc(("Remove shared dependency for surface sid=%u\n", sid));
2719
2720	switch (pSurface->enmD3DResType)
2721	{
2722	case VMSVGA3D_D3DRESTYPE_TEXTURE:
2723	Assert(pSharedSurface->u.pTexture);
2724	D3D_RELEASE(pSharedSurface->u.pTexture);
2725	break;
2726
2727	case VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE:
2728	Assert(pSharedSurface->u.pCubeTexture);
2729	D3D_RELEASE(pSharedSurface->u.pCubeTexture);
2730	break;
2731
2732	case VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE:
2733	Assert(pSharedSurface->u.pVolumeTexture);
2734	D3D_RELEASE(pSharedSurface->u.pVolumeTexture);
2735	break;
2736
2737	default:
2738	AssertFailed();
2739	break;
2740	}
2741	RTAvlU32Remove(&pSurface->pSharedObjectTree, cid);
2742	RTMemFree(pSharedSurface);
2743	}
2744	}
2745	}
2746
2747	/* Destroy all leftover pixel shaders. */
2748	for (uint32_t i = 0; i < pContext->cPixelShaders; i++)
2749	{
2750	if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
2751	vmsvga3dShaderDestroy(pThisCC, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
2752	}
2753	if (pContext->paPixelShader)
2754	RTMemFree(pContext->paPixelShader);
2755
2756	/* Destroy all leftover vertex shaders. */
2757	for (uint32_t i = 0; i < pContext->cVertexShaders; i++)
2758	{
2759	if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
2760	vmsvga3dShaderDestroy(pThisCC, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
2761	}
2762	if (pContext->paVertexShader)
2763	RTMemFree(pContext->paVertexShader);
2764
2765	if (pContext->state.paVertexShaderConst)
2766	RTMemFree(pContext->state.paVertexShaderConst);
2767	if (pContext->state.paPixelShaderConst)
2768	RTMemFree(pContext->state.paPixelShaderConst);
2769
2770	vmsvga3dOcclusionQueryDelete(pState, pContext);
2771
2772	/* Release the D3D device object */
2773	D3D_RELEASE(pContext->pDevice);
2774
2775	/* Destroy the window we've created. */
2776	int rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_DESTROYWINDOW, (WPARAM)pContext->hwnd, 0);
2777	AssertRC(rc);
2778
2779	memset(pContext, 0, sizeof(*pContext));
2780	pContext->id = SVGA3D_INVALID_ID;
2781	}
2782	else
2783	AssertFailed();
2784
2785	return VINF_SUCCESS;
2786	}
2787
2788	static int vmsvga3dContextTrackUsage(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext)
2789	{
2790	#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
2791	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2792	AssertReturn(pState, VERR_NO_MEMORY);
2793
2794	/* Inject fences to make sure we can track surface usage in case the client wants to reuse it in another context. */
2795	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTextures); ++i)
2796	{
2797	if (pContext->aSidActiveTextures[i] != SVGA3D_INVALID_ID)
2798	vmsvga3dSurfaceTrackUsageById(pState, pContext, pContext->aSidActiveTextures[i]);
2799	}
2800	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderTargets); ++i)
2801	if (pContext->state.aRenderTargets[i] != SVGA3D_INVALID_ID)
2802	vmsvga3dSurfaceTrackUsageById(pState, pContext, pContext->state.aRenderTargets[i]);
2803	#endif
2804	return VINF_SUCCESS;
2805	}
2806
2807	/* Handle resize */
2808	int vmsvga3dChangeMode(PVGASTATECC pThisCC)
2809	{
2810	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
2811	AssertReturn(pState, VERR_NO_MEMORY);
2812
2813	/* Resize all active contexts. */
2814	for (uint32_t i = 0; i < pState->cContexts; i++)
2815	{
2816	PVMSVGA3DCONTEXT pContext = pState->papContexts[i];
2817	uint32_t cid = pContext->id;
2818
2819	if (cid != SVGA3D_INVALID_ID)
2820	{
2821	D3DPRESENT_PARAMETERS PresParam;
2822	D3DVIEWPORT9 viewportOrg;
2823	HRESULT hr;
2824
2825	#ifdef VMSVGA3D_DIRECT3D9_RESET
2826	/* Sync back all surface data as everything is lost after the Reset. */
2827	for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
2828	{
2829	PVMSVGA3DSURFACE pSurface = pState->papSurfaces[sid];
2830	if ( pSurface->id == sid
2831	&& pSurface->idAssociatedContext == cid
2832	&& pSurface->u.pSurface)
2833	{
2834	Log(("vmsvga3dChangeMode: sync back data of surface sid=%u (fDirty=%d)\n", sid, pSurface->fDirty));
2835
2836	/* Reallocate our surface memory buffers. */
2837	for (uint32_t i = 0; i < pSurface->cMipLevels; i++)
2838	{
2839	PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->paMipmapLevels[i];
2840
2841	pMipmapLevel->pSurfaceData = RTMemAllocZ(pMipmapLevel->cbSurface);
2842	AssertReturn(pMipmapLevel->pSurfaceData, VERR_NO_MEMORY);
2843
2844	if (!pSurface->fDirty)
2845	{
2846	D3DLOCKED_RECT LockedRect;
2847
2848	if (pSurface->bounce.pTexture)
2849	{
2850	IDirect3DSurface9 pSrc, pDest;
2851
2852	/** @todo only sync when something was actually rendered (since the last sync) */
2853	Log(("vmsvga3dChangeMode: sync bounce buffer (level %d)\n", i));
2854	hr = pSurface->bounce.pTexture->GetSurfaceLevel(i, &pDest);
2855	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
2856
2857	hr = pSurface->u.pTexture->GetSurfaceLevel(i, &pSrc);
2858	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
2859
2860	hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
2861	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
2862
2863	D3D_RELEASE(pSrc);
2864	D3D_RELEASE(pDest);
2865
2866	hr = pSurface->bounce.pTexture->LockRect(i,
2867	&LockedRect,
2868	NULL,
2869	D3DLOCK_READONLY);
2870	}
2871	else
2872	hr = pSurface->u.pTexture->LockRect(i,
2873	&LockedRect,
2874	NULL,
2875	D3DLOCK_READONLY);
2876	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2877
2878	/* Copy the data one line at a time in case the internal pitch is different. */
2879	for (uint32_t j = 0; j < pMipmapLevel->size.height; j++)
2880	{
2881	memcpy((uint8_t )pMipmapLevel->pSurfaceData + j pMipmapLevel->cbSurfacePitch, (uint8_t )LockedRect.pBits + j LockedRect.Pitch, pMipmapLevel->cbSurfacePitch);
2882	}
2883
2884	if (pSurface->bounce.pTexture)
2885	hr = pSurface->bounce.pTexture->UnlockRect(i);
2886	else
2887	hr = pSurface->u.pTexture->UnlockRect(i);
2888	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2889	}
2890	}
2891
2892
2893	switch (pSurface->flags & VMSVGA3D_SURFACE_HINT_SWITCH_MASK)
2894	{
2895	case SVGA3D_SURFACE_CUBEMAP:
2896	case SVGA3D_SURFACE_CUBEMAP \| SVGA3D_SURFACE_HINT_TEXTURE:
2897	case SVGA3D_SURFACE_CUBEMAP \| SVGA3D_SURFACE_HINT_TEXTURE \| SVGA3D_SURFACE_HINT_RENDERTARGET:
2898	D3D_RELEASE(pSurface->u.pCubeTexture);
2899	D3D_RELEASE(pSurface->bounce.pCubeTexture);
2900	break;
2901
2902	case SVGA3D_SURFACE_HINT_INDEXBUFFER \| SVGA3D_SURFACE_HINT_VERTEXBUFFER:
2903	case SVGA3D_SURFACE_HINT_INDEXBUFFER:
2904	case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
2905	if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_VERTEXBUFFER)
2906	D3D_RELEASE(pSurface->u.pVertexBuffer);
2907	else if (pSurface->fu32ActualUsageFlags == SVGA3D_SURFACE_HINT_INDEXBUFFER)
2908	D3D_RELEASE(pSurface->u.pIndexBuffer);
2909	else
2910	AssertMsg(pSurface->u.pVertexBuffer == NULL, ("fu32ActualUsageFlags %x\n", pSurface->fu32ActualUsageFlags));
2911	break;
2912
2913	case SVGA3D_SURFACE_HINT_TEXTURE:
2914	case SVGA3D_SURFACE_HINT_TEXTURE \| SVGA3D_SURFACE_HINT_RENDERTARGET:
2915	D3D_RELEASE(pSurface->u.pTexture);
2916	D3D_RELEASE(pSurface->bounce.pTexture);
2917	break;
2918
2919	case SVGA3D_SURFACE_HINT_RENDERTARGET:
2920	case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
2921	if (pSurface->fStencilAsTexture)
2922	D3D_RELEASE(pSurface->u.pTexture);
2923	else
2924	D3D_RELEASE(pSurface->u.pSurface);
2925	break;
2926
2927	default:
2928	AssertFailed();
2929	break;
2930	}
2931	RTAvlU32Destroy(&pSurface->pSharedObjectTree, vmsvga3dSharedSurfaceDestroyTree, pSurface);
2932	Assert(pSurface->pSharedObjectTree == NULL);
2933
2934	pSurface->idAssociatedContext = SVGA3D_INVALID_ID;
2935	pSurface->hSharedObject = 0;
2936	}
2937	}
2938	#endif /* #ifdef VMSVGA3D_DIRECT3D9_RESET */
2939
2940	/* Cleanup the device runtime state. */
2941	D3D_RELEASE(pContext->d3dState.pVertexDecl);
2942
2943	AssertReturn(pContext->pDevice, VERR_INTERNAL_ERROR);
2944	hr = pContext->pDevice->GetViewport(&viewportOrg);
2945	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
2946
2947	Log(("vmsvga3dChangeMode: old viewport settings (%d,%d)(%d,%d) z=%d/%d\n", viewportOrg.X, viewportOrg.Y, viewportOrg.Width, viewportOrg.Height, (uint32_t)(viewportOrg.MinZ * 100.0), (uint32_t)(viewportOrg.MaxZ * 100.0)));
2948
2949	/* Changed when the function returns. */
2950	PresParam.BackBufferWidth = 0;
2951	PresParam.BackBufferHeight = 0;
2952	PresParam.BackBufferFormat = D3DFMT_UNKNOWN;
2953	PresParam.BackBufferCount = 0;
2954
2955	PresParam.MultiSampleType = D3DMULTISAMPLE_NONE;
2956	PresParam.MultiSampleQuality = 0;
2957	PresParam.SwapEffect = D3DSWAPEFFECT_DISCARD;
2958	PresParam.hDeviceWindow = pContext->hwnd;
2959	PresParam.Windowed = TRUE;
2960	PresParam.EnableAutoDepthStencil = FALSE;
2961	PresParam.AutoDepthStencilFormat = D3DFMT_UNKNOWN; /* not relevant */
2962	PresParam.Flags = 0;
2963	PresParam.FullScreen_RefreshRateInHz = 0; /* windowed -> 0 */
2964	/** @todo consider using D3DPRESENT_DONOTWAIT so we don't wait for the GPU during Present calls. */
2965	PresParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;;
2966
2967	#ifdef VBOX_VMSVGA3D_WITH_WINE_OPENGL
2968	hr = pContext->pDevice->Reset(&PresParam);
2969	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: Reset failed with %x\n", hr), VERR_INTERNAL_ERROR);
2970	#else
2971	/* ResetEx does not trash the device state */
2972	hr = pContext->pDevice->ResetEx(&PresParam, NULL);
2973	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: Reset failed with %x\n", hr), VERR_INTERNAL_ERROR);
2974	#endif
2975	Log(("vmsvga3dChangeMode: Backbuffer (%d,%d) count=%d format=%x\n", PresParam.BackBufferWidth, PresParam.BackBufferHeight, PresParam.BackBufferCount, PresParam.BackBufferFormat));
2976
2977	/* ResetEx changes the viewport; restore it again. */
2978	hr = pContext->pDevice->SetViewport(&viewportOrg);
2979	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
2980
2981	#ifdef LOG_ENABLED
2982	{
2983	D3DVIEWPORT9 viewport;
2984	hr = pContext->pDevice->GetViewport(&viewport);
2985	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
2986
2987	Log(("vmsvga3dChangeMode: changed viewport settings (%d,%d)(%d,%d) z=%d/%d\n", viewport.X, viewport.Y, viewport.Width, viewport.Height, (uint32_t)(viewport.MinZ * 100.0), (uint32_t)(viewport.MaxZ * 100.0)));
2988	}
2989	#endif
2990
2991	/* First set the render targets as they change the internal state (reset viewport etc) */
2992	Log(("vmsvga3dChangeMode: Recreate render targets BEGIN\n"));
2993	for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aRenderTargets); j++)
2994	{
2995	if (pContext->state.aRenderTargets[j] != SVGA3D_INVALID_ID)
2996	{
2997	SVGA3dSurfaceImageId target;
2998
2999	target.sid = pContext->state.aRenderTargets[j];
3000	target.face = 0;
3001	target.mipmap = 0;
3002	int rc = vmsvga3dSetRenderTarget(pThisCC, cid, (SVGA3dRenderTargetType)j, target);
3003	AssertRCReturn(rc, rc);
3004	}
3005	}
3006
3007	#ifdef VMSVGA3D_DIRECT3D9_RESET
3008	/* Recreate the render state */
3009	Log(("vmsvga3dChangeMode: Recreate render state BEGIN\n"));
3010	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderState); i++)
3011	{
3012	SVGA3dRenderState *pRenderState = &pContext->state.aRenderState[i];
3013
3014	if (pRenderState->state != SVGA3D_RS_INVALID)
3015	vmsvga3dSetRenderState(pThisCC, pContext->id, 1, pRenderState);
3016	}
3017	Log(("vmsvga3dChangeMode: Recreate render state END\n"));
3018
3019	/* Recreate the texture state */
3020	Log(("vmsvga3dChangeMode: Recreate texture state BEGIN\n"));
3021	for (uint32_t iStage = 0; iStage < RT_ELEMENTS(pContext->state.aTextureStates); iStage++)
3022	{
3023	for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aTextureStates[0]); j++)
3024	{
3025	SVGA3dTextureState *pTextureState = &pContext->state.aTextureStates[iStage][j];
3026
3027	if (pTextureState->name != SVGA3D_RS_INVALID)
3028	vmsvga3dSetTextureState(pThisCC, pContext->id, 1, pTextureState);
3029	}
3030	}
3031	Log(("vmsvga3dChangeMode: Recreate texture state END\n"));
3032
3033	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
3034	vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
3035	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
3036	vmsvga3dSetZRange(pThisCC, cid, pContext->state.zRange);
3037	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
3038	vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
3039	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VERTEXSHADER)
3040	vmsvga3dShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);
3041	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_PIXELSHADER)
3042	vmsvga3dShaderSet(pThis, pContext, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);
3043	/** @todo restore more state data */
3044	#endif /* #ifdef VMSVGA3D_DIRECT3D9_RESET */
3045	}
3046	}
3047	return VINF_SUCCESS;
3048	}
3049
3050
3051	int vmsvga3dSetTransform(PVGASTATECC pThisCC, uint32_t cid, SVGA3dTransformType type, float matrix[16])
3052	{
3053	D3DTRANSFORMSTATETYPE d3dState;
3054	HRESULT hr;
3055	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3056	AssertReturn(pState, VERR_NO_MEMORY);
3057
3058	Log(("vmsvga3dSetTransform %x %s\n", cid, vmsvgaTransformToString(type)));
3059
3060	ASSERT_GUEST_RETURN((unsigned)type < SVGA3D_TRANSFORM_MAX, VERR_INVALID_PARAMETER);
3061
3062	PVMSVGA3DCONTEXT pContext;
3063	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
3064	AssertRCReturn(rc, rc);
3065
3066	switch (type)
3067	{
3068	case SVGA3D_TRANSFORM_VIEW:
3069	d3dState = D3DTS_VIEW;
3070	break;
3071	case SVGA3D_TRANSFORM_PROJECTION:
3072	d3dState = D3DTS_PROJECTION;
3073	break;
3074	case SVGA3D_TRANSFORM_TEXTURE0:
3075	d3dState = D3DTS_TEXTURE0;
3076	break;
3077	case SVGA3D_TRANSFORM_TEXTURE1:
3078	d3dState = D3DTS_TEXTURE1;
3079	break;
3080	case SVGA3D_TRANSFORM_TEXTURE2:
3081	d3dState = D3DTS_TEXTURE2;
3082	break;
3083	case SVGA3D_TRANSFORM_TEXTURE3:
3084	d3dState = D3DTS_TEXTURE3;
3085	break;
3086	case SVGA3D_TRANSFORM_TEXTURE4:
3087	d3dState = D3DTS_TEXTURE4;
3088	break;
3089	case SVGA3D_TRANSFORM_TEXTURE5:
3090	d3dState = D3DTS_TEXTURE5;
3091	break;
3092	case SVGA3D_TRANSFORM_TEXTURE6:
3093	d3dState = D3DTS_TEXTURE6;
3094	break;
3095	case SVGA3D_TRANSFORM_TEXTURE7:
3096	d3dState = D3DTS_TEXTURE7;
3097	break;
3098	case SVGA3D_TRANSFORM_WORLD:
3099	d3dState = D3DTS_WORLD;
3100	break;
3101	case SVGA3D_TRANSFORM_WORLD1:
3102	d3dState = D3DTS_WORLD1;
3103	break;
3104	case SVGA3D_TRANSFORM_WORLD2:
3105	d3dState = D3DTS_WORLD2;
3106	break;
3107	case SVGA3D_TRANSFORM_WORLD3:
3108	d3dState = D3DTS_WORLD3;
3109	break;
3110
3111	default:
3112	Log(("vmsvga3dSetTransform: unknown type!!\n"));
3113	return VERR_INVALID_PARAMETER;
3114	}
3115
3116	/* Save this matrix for vm state save/restore. */
3117	pContext->state.aTransformState[type].fValid = true;
3118	memcpy(pContext->state.aTransformState[type].matrix, matrix, sizeof(pContext->state.aTransformState[type].matrix));
3119	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_TRANSFORM;
3120
3121	Log(("Matrix [%d %d %d %d]\n", (int)(matrix[0] * 10.0), (int)(matrix[1] * 10.0), (int)(matrix[2] * 10.0), (int)(matrix[3] * 10.0)));
3122	Log((" [%d %d %d %d]\n", (int)(matrix[4] * 10.0), (int)(matrix[5] * 10.0), (int)(matrix[6] * 10.0), (int)(matrix[7] * 10.0)));
3123	Log((" [%d %d %d %d]\n", (int)(matrix[8] * 10.0), (int)(matrix[9] * 10.0), (int)(matrix[10] * 10.0), (int)(matrix[11] * 10.0)));
3124	Log((" [%d %d %d %d]\n", (int)(matrix[12] * 10.0), (int)(matrix[13] * 10.0), (int)(matrix[14] * 10.0), (int)(matrix[15] * 10.0)));
3125	hr = pContext->pDevice->SetTransform(d3dState, (const D3DMATRIX *)matrix);
3126	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTransform: SetTransform failed with %x\n", hr), VERR_INTERNAL_ERROR);
3127	return VINF_SUCCESS;
3128	}
3129
3130	int vmsvga3dSetZRange(PVGASTATECC pThisCC, uint32_t cid, SVGA3dZRange zRange)
3131	{
3132	D3DVIEWPORT9 viewport;
3133	HRESULT hr;
3134	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3135	AssertReturn(pState, VERR_NO_MEMORY);
3136
3137	Log(("vmsvga3dSetZRange %x min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
3138
3139	PVMSVGA3DCONTEXT pContext;
3140	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
3141	AssertRCReturn(rc, rc);
3142
3143	pContext->state.zRange = zRange;
3144	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_ZRANGE;
3145
3146	hr = pContext->pDevice->GetViewport(&viewport);
3147	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetZRange: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
3148
3149	Log(("vmsvga3dSetZRange: old viewport settings (%d,%d)(%d,%d) z=%d/%d\n", viewport.X, viewport.Y, viewport.Width, viewport.Height, (uint32_t)(viewport.MinZ * 100.0), (uint32_t)(viewport.MaxZ * 100.0)));
3150	/** @todo convert the depth range from -1-1 to 0-1 although we shouldn't be getting such values in the first place... */
3151	if (zRange.min < 0.0)
3152	zRange.min = 0.0;
3153	if (zRange.max > 1.0)
3154	zRange.max = 1.0;
3155
3156	viewport.MinZ = zRange.min;
3157	viewport.MaxZ = zRange.max;
3158	hr = pContext->pDevice->SetViewport(&viewport);
3159	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetZRange: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
3160	return VINF_SUCCESS;
3161	}
3162
3163	/**
3164	* Convert SVGA blend op value to its D3D equivalent
3165	*/
3166	static DWORD vmsvga3dBlendOp2D3D(uint32_t blendOp, DWORD defaultBlendOp)
3167	{
3168	switch (blendOp)
3169	{
3170	case SVGA3D_BLENDOP_ZERO:
3171	return D3DBLEND_ZERO;
3172	case SVGA3D_BLENDOP_ONE:
3173	return D3DBLEND_ONE;
3174	case SVGA3D_BLENDOP_SRCCOLOR:
3175	return D3DBLEND_SRCCOLOR;
3176	case SVGA3D_BLENDOP_INVSRCCOLOR:
3177	return D3DBLEND_INVSRCCOLOR;
3178	case SVGA3D_BLENDOP_SRCALPHA:
3179	return D3DBLEND_SRCALPHA;
3180	case SVGA3D_BLENDOP_INVSRCALPHA:
3181	return D3DBLEND_INVSRCALPHA;
3182	case SVGA3D_BLENDOP_DESTALPHA:
3183	return D3DBLEND_DESTALPHA;
3184	case SVGA3D_BLENDOP_INVDESTALPHA:
3185	return D3DBLEND_INVDESTALPHA;
3186	case SVGA3D_BLENDOP_DESTCOLOR:
3187	return D3DBLEND_DESTCOLOR;
3188	case SVGA3D_BLENDOP_INVDESTCOLOR:
3189	return D3DBLEND_INVDESTCOLOR;
3190	case SVGA3D_BLENDOP_SRCALPHASAT:
3191	return D3DBLEND_SRCALPHASAT;
3192	case SVGA3D_BLENDOP_BLENDFACTOR:
3193	return D3DBLEND_BLENDFACTOR;
3194	case SVGA3D_BLENDOP_INVBLENDFACTOR:
3195	return D3DBLEND_INVBLENDFACTOR;
3196	default:
3197	AssertFailed();
3198	return defaultBlendOp;
3199	}
3200	}
3201
3202	int vmsvga3dSetRenderState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
3203	{
3204	DWORD val = 0; /* Shut up MSC */
3205	HRESULT hr;
3206	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3207	AssertReturn(pState, VERR_NO_MEMORY);
3208
3209	Log(("vmsvga3dSetRenderState cid=%u cRenderStates=%d\n", cid, cRenderStates));
3210
3211	PVMSVGA3DCONTEXT pContext;
3212	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
3213	AssertRCReturn(rc, rc);
3214
3215	for (unsigned i = 0; i < cRenderStates; i++)
3216	{
3217	D3DRENDERSTATETYPE renderState = D3DRS_FORCE_DWORD;
3218
3219	Log(("vmsvga3dSetRenderState: state=%s (%d) val=%x\n", vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
3220	/* Save the render state for vm state saving. */
3221	ASSERT_GUEST_RETURN((unsigned)pRenderState[i].state < SVGA3D_RS_MAX, VERR_INVALID_PARAMETER);
3222	pContext->state.aRenderState[pRenderState[i].state] = pRenderState[i];
3223
3224	switch (pRenderState[i].state)
3225	{
3226	case SVGA3D_RS_ZENABLE: /* SVGA3dBool */
3227	renderState = D3DRS_ZENABLE;
3228	val = pRenderState[i].uintValue;
3229	Assert(val == D3DZB_FALSE \|\| val == D3DZB_TRUE);
3230	break;
3231
3232	case SVGA3D_RS_ZWRITEENABLE: /* SVGA3dBool */
3233	renderState = D3DRS_ZWRITEENABLE;
3234	val = pRenderState[i].uintValue;
3235	break;
3236
3237	case SVGA3D_RS_ALPHATESTENABLE: /* SVGA3dBool */
3238	renderState = D3DRS_ALPHATESTENABLE;
3239	val = pRenderState[i].uintValue;
3240	break;
3241
3242	case SVGA3D_RS_DITHERENABLE: /* SVGA3dBool */
3243	renderState = D3DRS_DITHERENABLE;
3244	val = pRenderState[i].uintValue;
3245	break;
3246
3247	case SVGA3D_RS_BLENDENABLE: /* SVGA3dBool */
3248	renderState = D3DRS_ALPHABLENDENABLE;
3249	val = pRenderState[i].uintValue;
3250	break;
3251
3252	case SVGA3D_RS_FOGENABLE: /* SVGA3dBool */
3253	renderState = D3DRS_FOGENABLE;
3254	val = pRenderState[i].uintValue;
3255	break;
3256
3257	case SVGA3D_RS_SPECULARENABLE: /* SVGA3dBool */
3258	renderState = D3DRS_SPECULARENABLE;
3259	val = pRenderState[i].uintValue;
3260	break;
3261
3262	case SVGA3D_RS_LIGHTINGENABLE: /* SVGA3dBool */
3263	renderState = D3DRS_LIGHTING;
3264	val = pRenderState[i].uintValue;
3265	break;
3266
3267	case SVGA3D_RS_NORMALIZENORMALS: /* SVGA3dBool */
3268	renderState = D3DRS_NORMALIZENORMALS;
3269	val = pRenderState[i].uintValue;
3270	break;
3271
3272	case SVGA3D_RS_POINTSPRITEENABLE: /* SVGA3dBool */
3273	renderState = D3DRS_POINTSPRITEENABLE;
3274	val = pRenderState[i].uintValue;
3275	break;
3276
3277	case SVGA3D_RS_POINTSCALEENABLE: /* SVGA3dBool */
3278	renderState = D3DRS_POINTSCALEENABLE;
3279	val = pRenderState[i].uintValue;
3280	break;
3281
3282	case SVGA3D_RS_POINTSIZE: /* float */
3283	renderState = D3DRS_POINTSIZE;
3284	val = pRenderState[i].uintValue;
3285	Log(("SVGA3D_RS_POINTSIZE: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
3286	break;
3287
3288	case SVGA3D_RS_POINTSIZEMIN: /* float */
3289	renderState = D3DRS_POINTSIZE_MIN;
3290	val = pRenderState[i].uintValue;
3291	Log(("SVGA3D_RS_POINTSIZEMIN: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
3292	break;
3293
3294	case SVGA3D_RS_POINTSIZEMAX: /* float */
3295	renderState = D3DRS_POINTSIZE_MAX;
3296	val = pRenderState[i].uintValue;
3297	Log(("SVGA3D_RS_POINTSIZEMAX: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
3298	break;
3299
3300	case SVGA3D_RS_POINTSCALE_A: /* float */
3301	renderState = D3DRS_POINTSCALE_A;
3302	val = pRenderState[i].uintValue;
3303	break;
3304
3305	case SVGA3D_RS_POINTSCALE_B: /* float */
3306	renderState = D3DRS_POINTSCALE_B;
3307	val = pRenderState[i].uintValue;
3308	break;
3309
3310	case SVGA3D_RS_POINTSCALE_C: /* float */
3311	renderState = D3DRS_POINTSCALE_C;
3312	val = pRenderState[i].uintValue;
3313	break;
3314
3315	case SVGA3D_RS_AMBIENT: /* SVGA3dColor - identical */
3316	renderState = D3DRS_AMBIENT;
3317	val = pRenderState[i].uintValue;
3318	break;
3319
3320	case SVGA3D_RS_CLIPPLANEENABLE: /* SVGA3dClipPlanes - identical */
3321	renderState = D3DRS_CLIPPLANEENABLE;
3322	val = pRenderState[i].uintValue;
3323	break;
3324
3325	case SVGA3D_RS_FOGCOLOR: /* SVGA3dColor - identical */
3326	renderState = D3DRS_FOGCOLOR;
3327	val = pRenderState[i].uintValue;
3328	break;
3329
3330	case SVGA3D_RS_FOGSTART: /* float */
3331	renderState = D3DRS_FOGSTART;
3332	val = pRenderState[i].uintValue;
3333	break;
3334
3335	case SVGA3D_RS_FOGEND: /* float */
3336	renderState = D3DRS_FOGEND;
3337	val = pRenderState[i].uintValue;
3338	break;
3339
3340	case SVGA3D_RS_FOGDENSITY: /* float */
3341	renderState = D3DRS_FOGDENSITY;
3342	val = pRenderState[i].uintValue;
3343	break;
3344
3345	case SVGA3D_RS_RANGEFOGENABLE: /* SVGA3dBool */
3346	renderState = D3DRS_RANGEFOGENABLE;
3347	val = pRenderState[i].uintValue;
3348	break;
3349
3350	case SVGA3D_RS_FOGMODE: /* SVGA3dFogMode */
3351	{
3352	SVGA3dFogMode mode;
3353	mode.uintValue = pRenderState[i].uintValue;
3354
3355	switch (mode.s.function)
3356	{
3357	case SVGA3D_FOGFUNC_INVALID:
3358	val = D3DFOG_NONE;
3359	break;
3360	case SVGA3D_FOGFUNC_EXP:
3361	val = D3DFOG_EXP;
3362	break;
3363	case SVGA3D_FOGFUNC_EXP2:
3364	val = D3DFOG_EXP2;
3365	break;
3366	case SVGA3D_FOGFUNC_LINEAR:
3367	val = D3DFOG_LINEAR;
3368	break;
3369	case SVGA3D_FOGFUNC_PER_VERTEX: /* unable to find a d3d9 equivalent */
3370	AssertMsgFailedReturn(("Unsupported fog function SVGA3D_FOGFUNC_PER_VERTEX\n"), VERR_INTERNAL_ERROR);
3371	break;
3372	default:
3373	AssertMsgFailedReturn(("Unexpected fog function %d\n", mode.s.function), VERR_INTERNAL_ERROR);
3374	break;
3375	}
3376
3377	/* The fog type determines the render state. */
3378	switch (mode.s.type)
3379	{
3380	case SVGA3D_FOGTYPE_VERTEX:
3381	renderState = D3DRS_FOGVERTEXMODE;
3382	break;
3383	case SVGA3D_FOGTYPE_PIXEL:
3384	renderState = D3DRS_FOGTABLEMODE;
3385	break;
3386	default:
3387	AssertMsgFailedReturn(("Unexpected fog type %d\n", mode.s.type), VERR_INTERNAL_ERROR);
3388	break;
3389	}
3390
3391	/* Set the fog base to depth or range. */
3392	switch (mode.s.base)
3393	{
3394	case SVGA3D_FOGBASE_DEPTHBASED:
3395	hr = pContext->pDevice->SetRenderState(D3DRS_RANGEFOGENABLE, FALSE);
3396	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState SVGA3D_FOGBASE_DEPTHBASED failed with %x\n", hr), VERR_INTERNAL_ERROR);
3397	break;
3398	case SVGA3D_FOGBASE_RANGEBASED:
3399	hr = pContext->pDevice->SetRenderState(D3DRS_RANGEFOGENABLE, TRUE);
3400	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState SVGA3D_FOGBASE_RANGEBASED failed with %x\n", hr), VERR_INTERNAL_ERROR);
3401	break;
3402	default:
3403	/* ignore */
3404	AssertMsgFailed(("Unexpected fog base %d\n", mode.s.base));
3405	break;
3406	}
3407	break;
3408	}
3409
3410	case SVGA3D_RS_FILLMODE: /* SVGA3dFillMode */
3411	{
3412	SVGA3dFillMode mode;
3413
3414	mode.uintValue = pRenderState[i].uintValue;
3415
3416	switch (mode.s.mode)
3417	{
3418	case SVGA3D_FILLMODE_POINT:
3419	val = D3DFILL_POINT;
3420	break;
3421	case SVGA3D_FILLMODE_LINE:
3422	val = D3DFILL_WIREFRAME;
3423	break;
3424	case SVGA3D_FILLMODE_FILL:
3425	val = D3DFILL_SOLID;
3426	break;
3427	default:
3428	AssertMsgFailedReturn(("Unexpected fill mode %d\n", mode.s.mode), VERR_INTERNAL_ERROR);
3429	break;
3430	}
3431	/** @todo ignoring face for now. */
3432	renderState = D3DRS_FILLMODE;
3433	break;
3434	}
3435
3436	case SVGA3D_RS_SHADEMODE: /* SVGA3dShadeMode */
3437	renderState = D3DRS_SHADEMODE;
3438	AssertCompile(D3DSHADE_FLAT == SVGA3D_SHADEMODE_FLAT);
3439	val = pRenderState[i].uintValue; /* SVGA3dShadeMode == D3DSHADEMODE */
3440	break;
3441
3442	case SVGA3D_RS_LINEPATTERN: /* SVGA3dLinePattern */
3443	/* No longer supported by d3d; mesagl comments suggest not all backends support it */
3444	/** @todo */
3445	Log(("WARNING: SVGA3D_RS_LINEPATTERN %x not supported!!\n", pRenderState[i].uintValue));
3446	/*
3447	renderState = D3DRS_LINEPATTERN;
3448	val = pRenderState[i].uintValue;
3449	*/
3450	break;
3451
3452	case SVGA3D_RS_SRCBLEND: /* SVGA3dBlendOp */
3453	renderState = D3DRS_SRCBLEND;
3454	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ONE /* default */);
3455	break;
3456
3457	case SVGA3D_RS_DSTBLEND: /* SVGA3dBlendOp */
3458	renderState = D3DRS_DESTBLEND;
3459	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ZERO /* default */);
3460	break;
3461
3462	case SVGA3D_RS_BLENDEQUATION: /* SVGA3dBlendEquation - identical */
3463	AssertCompile(SVGA3D_BLENDEQ_MAXIMUM == D3DBLENDOP_MAX);
3464	renderState = D3DRS_BLENDOP;
3465	val = pRenderState[i].uintValue;
3466	break;
3467
3468	case SVGA3D_RS_CULLMODE: /* SVGA3dFace */
3469	{
3470	switch (pRenderState[i].uintValue)
3471	{
3472	case SVGA3D_FACE_NONE:
3473	val = D3DCULL_NONE;
3474	break;
3475	case SVGA3D_FACE_FRONT:
3476	val = D3DCULL_CW;
3477	break;
3478	case SVGA3D_FACE_BACK:
3479	val = D3DCULL_CCW;
3480	break;
3481	case SVGA3D_FACE_FRONT_BACK:
3482	AssertFailed();
3483	val = D3DCULL_CW;
3484	break;
3485	default:
3486	AssertMsgFailedReturn(("Unexpected cull mode %d\n", pRenderState[i].uintValue), VERR_INTERNAL_ERROR);
3487	break;
3488	}
3489	renderState = D3DRS_CULLMODE;
3490	break;
3491	}
3492
3493	case SVGA3D_RS_ZFUNC: /* SVGA3dCmpFunc - identical */
3494	AssertCompile(SVGA3D_CMP_ALWAYS == D3DCMP_ALWAYS);
3495	renderState = D3DRS_ZFUNC;
3496	val = pRenderState[i].uintValue;
3497	break;
3498
3499	case SVGA3D_RS_ALPHAFUNC: /* SVGA3dCmpFunc - identical */
3500	renderState = D3DRS_ALPHAFUNC;
3501	val = pRenderState[i].uintValue;
3502	break;
3503
3504	case SVGA3D_RS_STENCILENABLE: /* SVGA3dBool */
3505	renderState = D3DRS_STENCILENABLE;
3506	val = pRenderState[i].uintValue;
3507	break;
3508
3509	case SVGA3D_RS_STENCILREF: /* uint32_t */
3510	renderState = D3DRS_STENCILREF;
3511	val = pRenderState[i].uintValue;
3512	break;
3513
3514	case SVGA3D_RS_STENCILMASK: /* uint32_t */
3515	renderState = D3DRS_STENCILMASK;
3516	val = pRenderState[i].uintValue;
3517	break;
3518
3519	case SVGA3D_RS_STENCILWRITEMASK: /* uint32_t */
3520	renderState = D3DRS_STENCILWRITEMASK;
3521	val = pRenderState[i].uintValue;
3522	break;
3523
3524	case SVGA3D_RS_STENCILFUNC: /* SVGA3dCmpFunc - identical */
3525	renderState = D3DRS_STENCILFUNC;
3526	val = pRenderState[i].uintValue;
3527	break;
3528
3529	case SVGA3D_RS_STENCILFAIL: /* SVGA3dStencilOp - identical */
3530	AssertCompile(D3DSTENCILOP_KEEP == SVGA3D_STENCILOP_KEEP);
3531	AssertCompile(D3DSTENCILOP_DECR == SVGA3D_STENCILOP_DECR);
3532	renderState = D3DRS_STENCILFAIL;
3533	val = pRenderState[i].uintValue;
3534	break;
3535
3536	case SVGA3D_RS_STENCILZFAIL: /* SVGA3dStencilOp - identical */
3537	renderState = D3DRS_STENCILZFAIL;
3538	val = pRenderState[i].uintValue;
3539	break;
3540
3541	case SVGA3D_RS_STENCILPASS: /* SVGA3dStencilOp - identical */
3542	renderState = D3DRS_STENCILPASS;
3543	val = pRenderState[i].uintValue;
3544	break;
3545
3546	case SVGA3D_RS_ALPHAREF: /* float (0.0 .. 1.0) */
3547	renderState = D3DRS_ALPHAREF;
3548	val = (uint8_t)(pRenderState[i].floatValue * 255.0f); /* D3DRS_ALPHAREF 0..255 */
3549	break;
3550
3551	case SVGA3D_RS_FRONTWINDING: /* SVGA3dFrontWinding */
3552	Assert(pRenderState[i].uintValue == SVGA3D_FRONTWINDING_CW);
3553	/*
3554	renderState = D3DRS_FRONTWINDING; //D3DRS_TWOSIDEDSTENCILMODE
3555	val = pRenderState[i].uintValue;
3556	*/
3557	break;
3558
3559	case SVGA3D_RS_COORDINATETYPE: /* SVGA3dCoordinateType */
3560	Assert(pRenderState[i].uintValue == SVGA3D_COORDINATE_LEFTHANDED);
3561	/** @todo setup a view matrix to scale the world space by -1 in the z-direction for right handed coordinates. */
3562	/*
3563	renderState = D3DRS_COORDINATETYPE;
3564	val = pRenderState[i].uintValue;
3565	*/
3566	break;
3567
3568	case SVGA3D_RS_ZBIAS: /* float */
3569	/** @todo unknown meaning; depth bias is not identical
3570	renderState = D3DRS_DEPTHBIAS;
3571	val = pRenderState[i].uintValue;
3572	*/
3573	Log(("vmsvga3dSetRenderState: WARNING unsupported SVGA3D_RS_ZBIAS\n"));
3574	break;
3575
3576	case SVGA3D_RS_SLOPESCALEDEPTHBIAS: /* float */
3577	renderState = D3DRS_SLOPESCALEDEPTHBIAS;
3578	val = pRenderState[i].uintValue;
3579	break;
3580
3581	case SVGA3D_RS_DEPTHBIAS: /* float */
3582	renderState = D3DRS_DEPTHBIAS;
3583	val = pRenderState[i].uintValue;
3584	break;
3585
3586	case SVGA3D_RS_COLORWRITEENABLE: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
3587	renderState = D3DRS_COLORWRITEENABLE;
3588	val = pRenderState[i].uintValue;
3589	break;
3590
3591	case SVGA3D_RS_VERTEXMATERIALENABLE: /* SVGA3dBool */
3592	//AssertFailed();
3593	renderState = D3DRS_INDEXEDVERTEXBLENDENABLE; /* correct?? */
3594	val = pRenderState[i].uintValue;
3595	break;
3596
3597	case SVGA3D_RS_DIFFUSEMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3598	AssertCompile(D3DMCS_COLOR2 == SVGA3D_VERTEXMATERIAL_SPECULAR);
3599	renderState = D3DRS_DIFFUSEMATERIALSOURCE;
3600	val = pRenderState[i].uintValue;
3601	break;
3602
3603	case SVGA3D_RS_SPECULARMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3604	renderState = D3DRS_SPECULARMATERIALSOURCE;
3605	val = pRenderState[i].uintValue;
3606	break;
3607
3608	case SVGA3D_RS_AMBIENTMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3609	renderState = D3DRS_AMBIENTMATERIALSOURCE;
3610	val = pRenderState[i].uintValue;
3611	break;
3612
3613	case SVGA3D_RS_EMISSIVEMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3614	renderState = D3DRS_EMISSIVEMATERIALSOURCE;
3615	val = pRenderState[i].uintValue;
3616	break;
3617
3618	case SVGA3D_RS_TEXTUREFACTOR: /* SVGA3dColor - identical */
3619	renderState = D3DRS_TEXTUREFACTOR;
3620	val = pRenderState[i].uintValue;
3621	break;
3622
3623	case SVGA3D_RS_LOCALVIEWER: /* SVGA3dBool */
3624	renderState = D3DRS_LOCALVIEWER;
3625	val = pRenderState[i].uintValue;
3626	break;
3627
3628	case SVGA3D_RS_SCISSORTESTENABLE: /* SVGA3dBool */
3629	renderState = D3DRS_SCISSORTESTENABLE;
3630	val = pRenderState[i].uintValue;
3631	break;
3632
3633	case SVGA3D_RS_BLENDCOLOR: /* SVGA3dColor - identical */
3634	renderState = D3DRS_BLENDFACTOR;
3635	val = pRenderState[i].uintValue;
3636	break;
3637
3638	case SVGA3D_RS_STENCILENABLE2SIDED: /* SVGA3dBool */
3639	renderState = D3DRS_TWOSIDEDSTENCILMODE;
3640	val = pRenderState[i].uintValue;
3641	break;
3642
3643	case SVGA3D_RS_CCWSTENCILFUNC: /* SVGA3dCmpFunc - identical */
3644	renderState = D3DRS_CCW_STENCILFUNC;
3645	val = pRenderState[i].uintValue;
3646	break;
3647
3648	case SVGA3D_RS_CCWSTENCILFAIL: /* SVGA3dStencilOp - identical */
3649	renderState = D3DRS_CCW_STENCILFAIL;
3650	val = pRenderState[i].uintValue;
3651	break;
3652
3653	case SVGA3D_RS_CCWSTENCILZFAIL: /* SVGA3dStencilOp - identical */
3654	renderState = D3DRS_CCW_STENCILZFAIL;
3655	val = pRenderState[i].uintValue;
3656	break;
3657
3658	case SVGA3D_RS_CCWSTENCILPASS: /* SVGA3dStencilOp - identical */
3659	renderState = D3DRS_CCW_STENCILPASS;
3660	val = pRenderState[i].uintValue;
3661	break;
3662
3663	case SVGA3D_RS_VERTEXBLEND: /* SVGA3dVertexBlendFlags - identical */
3664	AssertCompile(SVGA3D_VBLEND_DISABLE == D3DVBF_DISABLE);
3665	renderState = D3DRS_VERTEXBLEND;
3666	val = pRenderState[i].uintValue;
3667	break;
3668
3669	case SVGA3D_RS_OUTPUTGAMMA: /* float */
3670	//AssertFailed();
3671	/*
3672	D3DRS_SRGBWRITEENABLE ??
3673	renderState = D3DRS_OUTPUTGAMMA;
3674	val = pRenderState[i].uintValue;
3675	*/
3676	break;
3677
3678	case SVGA3D_RS_ZVISIBLE: /* SVGA3dBool */
3679	AssertFailed();
3680	/*
3681	renderState = D3DRS_ZVISIBLE;
3682	val = pRenderState[i].uintValue;
3683	*/
3684	break;
3685
3686	case SVGA3D_RS_LASTPIXEL: /* SVGA3dBool */
3687	renderState = D3DRS_LASTPIXEL;
3688	val = pRenderState[i].uintValue;
3689	break;
3690
3691	case SVGA3D_RS_CLIPPING: /* SVGA3dBool */
3692	renderState = D3DRS_CLIPPING;
3693	val = pRenderState[i].uintValue;
3694	break;
3695
3696	case SVGA3D_RS_WRAP0: /* SVGA3dWrapFlags - identical */
3697	Assert(SVGA3D_WRAPCOORD_3 == D3DWRAPCOORD_3);
3698	renderState = D3DRS_WRAP0;
3699	val = pRenderState[i].uintValue;
3700	break;
3701
3702	case SVGA3D_RS_WRAP1: /* SVGA3dWrapFlags - identical */
3703	renderState = D3DRS_WRAP1;
3704	val = pRenderState[i].uintValue;
3705	break;
3706
3707	case SVGA3D_RS_WRAP2: /* SVGA3dWrapFlags - identical */
3708	renderState = D3DRS_WRAP2;
3709	val = pRenderState[i].uintValue;
3710	break;
3711
3712	case SVGA3D_RS_WRAP3: /* SVGA3dWrapFlags - identical */
3713	renderState = D3DRS_WRAP3;
3714	val = pRenderState[i].uintValue;
3715	break;
3716
3717	case SVGA3D_RS_WRAP4: /* SVGA3dWrapFlags - identical */
3718	renderState = D3DRS_WRAP4;
3719	val = pRenderState[i].uintValue;
3720	break;
3721
3722	case SVGA3D_RS_WRAP5: /* SVGA3dWrapFlags - identical */
3723	renderState = D3DRS_WRAP5;
3724	val = pRenderState[i].uintValue;
3725	break;
3726
3727	case SVGA3D_RS_WRAP6: /* SVGA3dWrapFlags - identical */
3728	renderState = D3DRS_WRAP6;
3729	val = pRenderState[i].uintValue;
3730	break;
3731
3732	case SVGA3D_RS_WRAP7: /* SVGA3dWrapFlags - identical */
3733	renderState = D3DRS_WRAP7;
3734	val = pRenderState[i].uintValue;
3735	break;
3736
3737	case SVGA3D_RS_WRAP8: /* SVGA3dWrapFlags - identical */
3738	renderState = D3DRS_WRAP8;
3739	val = pRenderState[i].uintValue;
3740	break;
3741
3742	case SVGA3D_RS_WRAP9: /* SVGA3dWrapFlags - identical */
3743	renderState = D3DRS_WRAP9;
3744	val = pRenderState[i].uintValue;
3745	break;
3746
3747	case SVGA3D_RS_WRAP10: /* SVGA3dWrapFlags - identical */
3748	renderState = D3DRS_WRAP10;
3749	val = pRenderState[i].uintValue;
3750	break;
3751
3752	case SVGA3D_RS_WRAP11: /* SVGA3dWrapFlags - identical */
3753	renderState = D3DRS_WRAP11;
3754	val = pRenderState[i].uintValue;
3755	break;
3756
3757	case SVGA3D_RS_WRAP12: /* SVGA3dWrapFlags - identical */
3758	renderState = D3DRS_WRAP12;
3759	val = pRenderState[i].uintValue;
3760	break;
3761
3762	case SVGA3D_RS_WRAP13: /* SVGA3dWrapFlags - identical */
3763	renderState = D3DRS_WRAP13;
3764	val = pRenderState[i].uintValue;
3765	break;
3766
3767	case SVGA3D_RS_WRAP14: /* SVGA3dWrapFlags - identical */
3768	renderState = D3DRS_WRAP14;
3769	val = pRenderState[i].uintValue;
3770	break;
3771
3772	case SVGA3D_RS_WRAP15: /* SVGA3dWrapFlags - identical */
3773	renderState = D3DRS_WRAP15;
3774	val = pRenderState[i].uintValue;
3775	break;
3776
3777	case SVGA3D_RS_MULTISAMPLEANTIALIAS: /* SVGA3dBool */
3778	renderState = D3DRS_MULTISAMPLEANTIALIAS;
3779	val = pRenderState[i].uintValue;
3780	break;
3781
3782	case SVGA3D_RS_MULTISAMPLEMASK: /* uint32_t */
3783	renderState = D3DRS_MULTISAMPLEMASK;
3784	val = pRenderState[i].uintValue;
3785	break;
3786
3787	case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE: /* SVGA3dBool */
3788	renderState = D3DRS_INDEXEDVERTEXBLENDENABLE;
3789	val = pRenderState[i].uintValue;
3790	break;
3791
3792	case SVGA3D_RS_TWEENFACTOR: /* float */
3793	renderState = D3DRS_TWEENFACTOR;
3794	val = pRenderState[i].uintValue;
3795	break;
3796
3797	case SVGA3D_RS_ANTIALIASEDLINEENABLE: /* SVGA3dBool */
3798	renderState = D3DRS_ANTIALIASEDLINEENABLE;
3799	val = pRenderState[i].uintValue;
3800	break;
3801
3802	case SVGA3D_RS_COLORWRITEENABLE1: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
3803	renderState = D3DRS_COLORWRITEENABLE1;
3804	val = pRenderState[i].uintValue;
3805	break;
3806
3807	case SVGA3D_RS_COLORWRITEENABLE2: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
3808	renderState = D3DRS_COLORWRITEENABLE2;
3809	val = pRenderState[i].uintValue;
3810	break;
3811
3812	case SVGA3D_RS_COLORWRITEENABLE3: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
3813	renderState = D3DRS_COLORWRITEENABLE3;
3814	val = pRenderState[i].uintValue;
3815	break;
3816
3817	case SVGA3D_RS_SEPARATEALPHABLENDENABLE: /* SVGA3dBool */
3818	renderState = D3DRS_SEPARATEALPHABLENDENABLE;
3819	val = pRenderState[i].uintValue;
3820	break;
3821
3822	case SVGA3D_RS_SRCBLENDALPHA: /* SVGA3dBlendOp */
3823	renderState = D3DRS_SRCBLENDALPHA;
3824	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ONE /* default */);
3825	break;
3826
3827	case SVGA3D_RS_DSTBLENDALPHA: /* SVGA3dBlendOp */
3828	renderState = D3DRS_DESTBLENDALPHA;
3829	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ZERO /* default */);
3830	break;
3831
3832	case SVGA3D_RS_BLENDEQUATIONALPHA: /* SVGA3dBlendEquation - identical */
3833	renderState = D3DRS_BLENDOPALPHA;
3834	val = pRenderState[i].uintValue;
3835	break;
3836
3837	case SVGA3D_RS_TRANSPARENCYANTIALIAS: /* SVGA3dTransparencyAntialiasType */
3838	AssertFailed();
3839	/*
3840	renderState = D3DRS_TRANSPARENCYANTIALIAS;
3841	val = pRenderState[i].uintValue;
3842	*/
3843	break;
3844
3845	case SVGA3D_RS_LINEAA: /* SVGA3dBool */
3846	renderState = D3DRS_ANTIALIASEDLINEENABLE;
3847	val = pRenderState[i].uintValue;
3848	break;
3849
3850	case SVGA3D_RS_LINEWIDTH: /* float */
3851	AssertFailed();
3852	/*
3853	renderState = D3DRS_LINEWIDTH;
3854	val = pRenderState[i].uintValue;
3855	*/
3856	break;
3857
3858	case SVGA3D_RS_MAX: /* shut up MSC */
3859	case SVGA3D_RS_INVALID:
3860	AssertFailedBreak();
3861	}
3862
3863	if (renderState != D3DRS_FORCE_DWORD)
3864	{
3865	hr = pContext->pDevice->SetRenderState(renderState, val);
3866	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState failed with %x\n", hr), VERR_INTERNAL_ERROR);
3867	}
3868	}
3869
3870	return VINF_SUCCESS;
3871	}
3872
3873	int vmsvga3dSetRenderTarget(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
3874	{
3875	HRESULT hr;
3876	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
3877
3878	AssertReturn(pState, VERR_NO_MEMORY);
3879	AssertReturn((unsigned)type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
3880
3881	LogFunc(("cid=%u type=%x sid=%u face=%u mipmap=%u\n", cid, type, target.sid, target.face, target.mipmap));
3882
3883	PVMSVGA3DCONTEXT pContext;
3884	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
3885	AssertRCReturn(rc, rc);
3886
3887	/* Save for vm state save/restore. */
3888	pContext->state.aRenderTargets[type] = target.sid;
3889	/** @todo Also save target.face and target.mipmap */
3890
3891	if (target.sid == SVGA3D_INVALID_ID)
3892	{
3893	/* Disable render target. */
3894	switch (type)
3895	{
3896	case SVGA3D_RT_DEPTH:
3897	hr = pContext->pDevice->SetDepthStencilSurface(NULL);
3898	AssertMsgReturn(hr == D3D_OK, ("SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
3899	break;
3900
3901	case SVGA3D_RT_STENCIL:
3902	/* ignore; correct?? */
3903	break;
3904
3905	case SVGA3D_RT_COLOR0:
3906	case SVGA3D_RT_COLOR1:
3907	case SVGA3D_RT_COLOR2:
3908	case SVGA3D_RT_COLOR3:
3909	case SVGA3D_RT_COLOR4:
3910	case SVGA3D_RT_COLOR5:
3911	case SVGA3D_RT_COLOR6:
3912	case SVGA3D_RT_COLOR7:
3913	if (pState->fSupportedSurfaceNULL)
3914	{
3915	/* Create a dummy render target to satisfy D3D. This path is usually taken only to render
3916	* into a depth buffer without wishing to update an actual color render target.
3917	* The dimensions of the render target must match the dimensions of the depth render target,
3918	* which is usually equal to the viewport width and height.
3919	*/
3920	IDirect3DSurface9 *pDummyRenderTarget;
3921	hr = pContext->pDevice->CreateRenderTarget(pContext->state.RectViewPort.w,
3922	pContext->state.RectViewPort.h,
3923	FOURCC_NULL,
3924	D3DMULTISAMPLE_NONE,
3925	0,
3926	FALSE,
3927	&pDummyRenderTarget,
3928	NULL);
3929
3930	AssertMsgReturn(hr == D3D_OK, ("CreateRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
3931
3932	hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pDummyRenderTarget);
3933	D3D_RELEASE(pDummyRenderTarget);
3934	}
3935	else
3936	hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, NULL);
3937
3938	AssertMsgReturn(hr == D3D_OK, ("SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
3939	break;
3940
3941	default:
3942	AssertFailedReturn(VERR_INVALID_PARAMETER);
3943	}
3944	return VINF_SUCCESS;
3945	}
3946
3947	PVMSVGA3DSURFACE pRenderTarget;
3948	rc = vmsvga3dSurfaceFromSid(pState, target.sid, &pRenderTarget);
3949	AssertRCReturn(rc, rc);
3950
3951	switch (type)
3952	{
3953	case SVGA3D_RT_DEPTH:
3954	case SVGA3D_RT_STENCIL:
3955	AssertReturn(target.face == 0 && target.mipmap == 0, VERR_INVALID_PARAMETER);
3956	if (!pRenderTarget->u.pSurface)
3957	{
3958	DWORD cQualityLevels = 0;
3959
3960	/* Query the nr of quality levels for this particular format */
3961	if (pRenderTarget->multiSampleTypeD3D != D3DMULTISAMPLE_NONE)
3962	{
3963	hr = pState->pD3D9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
3964	D3DDEVTYPE_HAL,
3965	pRenderTarget->formatD3D,
3966	TRUE, /* Windowed */
3967	pRenderTarget->multiSampleTypeD3D,
3968	&cQualityLevels);
3969	Assert(hr == D3D_OK \|\| hr == D3DERR_NOTAVAILABLE);
3970	}
3971
3972	if ( pState->fSupportedSurfaceINTZ
3973	&& pRenderTarget->multiSampleTypeD3D == D3DMULTISAMPLE_NONE
3974	&& ( pRenderTarget->formatD3D == D3DFMT_D24S8
3975	\|\| pRenderTarget->formatD3D == D3DFMT_D24X8
3976	\|\| pRenderTarget->formatD3D == D3DFMT_D32
3977	\|\| pRenderTarget->formatD3D == D3DFMT_D16))
3978	{
3979	LogFunc(("Creating stencil surface as texture!\n"));
3980	int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
3981	AssertRC(rc); /* non-fatal, will use CreateDepthStencilSurface */
3982	}
3983
3984	if (!pRenderTarget->fStencilAsTexture)
3985	{
3986	Assert(!pRenderTarget->u.pSurface);
3987
3988	LogFunc(("DEPTH/STENCIL; cQualityLevels=%d\n", cQualityLevels));
3989	hr = pContext->pDevice->CreateDepthStencilSurface(pRenderTarget->paMipmapLevels[0].mipmapSize.width,
3990	pRenderTarget->paMipmapLevels[0].mipmapSize.height,
3991	pRenderTarget->formatD3D,
3992	pRenderTarget->multiSampleTypeD3D,
3993	((cQualityLevels >= 1) ? cQualityLevels - 1 : 0), /* 0 - (levels-1) */
3994	FALSE, /* not discardable */
3995	&pRenderTarget->u.pSurface,
3996	NULL);
3997	AssertMsgReturn(hr == D3D_OK, ("CreateDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
3998	pRenderTarget->enmD3DResType = VMSVGA3D_D3DRESTYPE_SURFACE;
3999	}
4000
4001	pRenderTarget->idAssociatedContext = cid;
4002
4003	#if 0 /* doesn't work */
4004	if ( !pRenderTarget->fStencilAsTexture
4005	&& pRenderTarget->fDirty)
4006	{
4007	Log(("vmsvga3dSetRenderTarget: sync dirty depth/stencil buffer\n"));
4008	Assert(pRenderTarget->faces[0].numMipLevels == 1);
4009
4010	for (uint32_t i = 0; i < pRenderTarget->faces[0].numMipLevels; i++)
4011	{
4012	if (pRenderTarget->paMipmapLevels[i].fDirty)
4013	{
4014	D3DLOCKED_RECT LockedRect;
4015
4016	hr = pRenderTarget->u.pSurface->LockRect(&LockedRect,
4017	NULL, /* entire surface */
4018	0);
4019
4020	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
4021
4022	Log(("vmsvga3dSetRenderTarget: sync dirty texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pRenderTarget->paMipmapLevels[i].cbSurfacePitch));
4023
4024	uint8_t pDest = (uint8_t )LockedRect.pBits;
4025	uint8_t pSrc = (uint8_t )pRenderTarget->paMipmapLevels[i].pSurfaceData;
4026	for (uint32_t j = 0; j < pRenderTarget->paMipmapLevels[i].size.height; j++)
4027	{
4028	memcpy(pDest, pSrc, pRenderTarget->paMipmapLevels[i].cbSurfacePitch);
4029
4030	pDest += LockedRect.Pitch;
4031	pSrc += pRenderTarget->paMipmapLevels[i].cbSurfacePitch;
4032	}
4033
4034	hr = pRenderTarget->u.pSurface->UnlockRect();
4035	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
4036
4037	pRenderTarget->paMipmapLevels[i].fDirty = false;
4038	}
4039	}
4040	}
4041	#endif
4042	}
4043
4044	/** @todo Assert(!pRenderTarget->fDirty); */
4045
4046	AssertReturn(pRenderTarget->u.pSurface, VERR_INVALID_PARAMETER);
4047
4048	pRenderTarget->fUsageD3D \|= D3DUSAGE_DEPTHSTENCIL;
4049	pRenderTarget->surfaceFlags \|= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
4050
4051	if (pRenderTarget->fStencilAsTexture)
4052	{
4053	IDirect3DSurface9 *pStencilSurface;
4054
4055	rc = vmsvga3dGetD3DSurface(pState, pContext, pRenderTarget, target.face, target.mipmap, /fLockable=/ false, &pStencilSurface);
4056	AssertRCReturn(rc, rc);
4057
4058	hr = pContext->pDevice->SetDepthStencilSurface(pStencilSurface);
4059	D3D_RELEASE(pStencilSurface);
4060	AssertMsgReturn(hr == D3D_OK, ("SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
4061	}
4062	else
4063	{
4064	Assert(pRenderTarget->idAssociatedContext == cid);
4065	hr = pContext->pDevice->SetDepthStencilSurface(pRenderTarget->u.pSurface);
4066	AssertMsgReturn(hr == D3D_OK, ("SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
4067	}
4068	break;
4069
4070	case SVGA3D_RT_COLOR0:
4071	case SVGA3D_RT_COLOR1:
4072	case SVGA3D_RT_COLOR2:
4073	case SVGA3D_RT_COLOR3:
4074	case SVGA3D_RT_COLOR4:
4075	case SVGA3D_RT_COLOR5:
4076	case SVGA3D_RT_COLOR6:
4077	case SVGA3D_RT_COLOR7:
4078	{
4079	IDirect3DSurface9 *pSurface;
4080	bool fTexture = false;
4081
4082	/* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
4083	vmsvga3dSurfaceFlush(pRenderTarget);
4084
4085	if (pRenderTarget->surfaceFlags & SVGA3D_SURFACE_HINT_TEXTURE)
4086	{
4087	fTexture = true;
4088
4089	/* A texture surface can be used as a render target to fill it and later on used as a texture. */
4090	if (!pRenderTarget->u.pTexture)
4091	{
4092	LogFunc(("Create texture to be used as render target; sid=%u type=%d format=%d -> create texture\n", target.sid, pRenderTarget->surfaceFlags, pRenderTarget->format));
4093	int rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pRenderTarget);
4094	AssertRCReturn(rc, rc);
4095	}
4096
4097	rc = vmsvga3dGetD3DSurface(pState, pContext, pRenderTarget, target.face, target.mipmap, false, &pSurface);
4098	AssertRCReturn(rc, rc);
4099	}
4100	else
4101	{
4102	AssertReturn(target.face == 0 && target.mipmap == 0, VERR_INVALID_PARAMETER);
4103	if (!pRenderTarget->u.pSurface)
4104	{
4105	DWORD cQualityLevels = 0;
4106
4107	/* Query the nr of quality levels for this particular format */
4108	if (pRenderTarget->multiSampleTypeD3D != D3DMULTISAMPLE_NONE)
4109	{
4110	hr = pState->pD3D9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
4111	D3DDEVTYPE_HAL,
4112	pRenderTarget->formatD3D,
4113	TRUE, /* Windowed */
4114	pRenderTarget->multiSampleTypeD3D,
4115	&cQualityLevels);
4116	Assert(hr == D3D_OK \|\| hr == D3DERR_NOTAVAILABLE);
4117	}
4118
4119	LogFunc(("COLOR; cQualityLevels=%d\n", cQualityLevels));
4120	LogFunc(("Create rendertarget (%d,%d) formatD3D=%x multisample=%x\n",
4121	pRenderTarget->paMipmapLevels[0].mipmapSize.width, pRenderTarget->paMipmapLevels[0].mipmapSize.height, pRenderTarget->formatD3D, pRenderTarget->multiSampleTypeD3D));
4122
4123	hr = pContext->pDevice->CreateRenderTarget(pRenderTarget->paMipmapLevels[0].mipmapSize.width,
4124	pRenderTarget->paMipmapLevels[0].mipmapSize.height,
4125	pRenderTarget->formatD3D,
4126	pRenderTarget->multiSampleTypeD3D,
4127	((cQualityLevels >= 1) ? cQualityLevels - 1 : 0), /* 0 - (levels-1) */
4128	TRUE, /* lockable */
4129	&pRenderTarget->u.pSurface,
4130	NULL);
4131	AssertReturn(hr == D3D_OK, VERR_INTERNAL_ERROR);
4132
4133	pRenderTarget->idAssociatedContext = cid;
4134	pRenderTarget->enmD3DResType = VMSVGA3D_D3DRESTYPE_SURFACE;
4135	}
4136	else
4137	AssertReturn(pRenderTarget->fUsageD3D & D3DUSAGE_RENDERTARGET, VERR_INVALID_PARAMETER);
4138
4139	Assert(pRenderTarget->idAssociatedContext == cid);
4140	Assert(pRenderTarget->enmD3DResType == VMSVGA3D_D3DRESTYPE_SURFACE);
4141	pSurface = pRenderTarget->u.pSurface;
4142	}
4143
4144	AssertReturn(pRenderTarget->u.pSurface, VERR_INVALID_PARAMETER);
4145	Assert(!pRenderTarget->fDirty);
4146
4147	pRenderTarget->fUsageD3D \|= D3DUSAGE_RENDERTARGET;
4148	pRenderTarget->surfaceFlags \|= SVGA3D_SURFACE_HINT_RENDERTARGET;
4149
4150	hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pSurface);
4151	if (fTexture)
4152	D3D_RELEASE(pSurface); /* Release reference to texture level 0 */
4153	AssertMsgReturn(hr == D3D_OK, ("SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
4154
4155	/* Changing the render target resets the viewport; restore it here. */
4156	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
4157	vmsvga3dSetViewPort(pThisCC, cid, &pContext->state.RectViewPort);
4158	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
4159	vmsvga3dSetZRange(pThisCC, cid, pContext->state.zRange);
4160	/* Changing the render target also resets the scissor rectangle; restore it as well. */
4161	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
4162	vmsvga3dSetScissorRect(pThisCC, cid, &pContext->state.RectScissor);
4163
4164	break;
4165	}
4166
4167	default:
4168	AssertFailedReturn(VERR_INVALID_PARAMETER);
4169	}
4170
4171	return VINF_SUCCESS;
4172	}
4173
4174	/**
4175	* Convert SVGA texture combiner value to its D3D equivalent
4176	*/
4177	static DWORD vmsvga3dTextureCombiner2D3D(uint32_t value)
4178	{
4179	switch (value)
4180	{
4181	case SVGA3D_TC_DISABLE:
4182	return D3DTOP_DISABLE;
4183	case SVGA3D_TC_SELECTARG1:
4184	return D3DTOP_SELECTARG1;
4185	case SVGA3D_TC_SELECTARG2:
4186	return D3DTOP_SELECTARG2;
4187	case SVGA3D_TC_MODULATE:
4188	return D3DTOP_MODULATE;
4189	case SVGA3D_TC_ADD:
4190	return D3DTOP_ADD;
4191	case SVGA3D_TC_ADDSIGNED:
4192	return D3DTOP_ADDSIGNED;
4193	case SVGA3D_TC_SUBTRACT:
4194	return D3DTOP_SUBTRACT;
4195	case SVGA3D_TC_BLENDTEXTUREALPHA:
4196	return D3DTOP_BLENDTEXTUREALPHA;
4197	case SVGA3D_TC_BLENDDIFFUSEALPHA:
4198	return D3DTOP_BLENDDIFFUSEALPHA;
4199	case SVGA3D_TC_BLENDCURRENTALPHA:
4200	return D3DTOP_BLENDCURRENTALPHA;
4201	case SVGA3D_TC_BLENDFACTORALPHA:
4202	return D3DTOP_BLENDFACTORALPHA;
4203	case SVGA3D_TC_MODULATE2X:
4204	return D3DTOP_MODULATE2X;
4205	case SVGA3D_TC_MODULATE4X:
4206	return D3DTOP_MODULATE4X;
4207	case SVGA3D_TC_DSDT:
4208	AssertFailed(); /** @todo ??? */
4209	return D3DTOP_DISABLE;
4210	case SVGA3D_TC_DOTPRODUCT3:
4211	return D3DTOP_DOTPRODUCT3;
4212	case SVGA3D_TC_BLENDTEXTUREALPHAPM:
4213	return D3DTOP_BLENDTEXTUREALPHAPM;
4214	case SVGA3D_TC_ADDSIGNED2X:
4215	return D3DTOP_ADDSIGNED2X;
4216	case SVGA3D_TC_ADDSMOOTH:
4217	return D3DTOP_ADDSMOOTH;
4218	case SVGA3D_TC_PREMODULATE:
4219	return D3DTOP_PREMODULATE;
4220	case SVGA3D_TC_MODULATEALPHA_ADDCOLOR:
4221	return D3DTOP_MODULATEALPHA_ADDCOLOR;
4222	case SVGA3D_TC_MODULATECOLOR_ADDALPHA:
4223	return D3DTOP_MODULATECOLOR_ADDALPHA;
4224	case SVGA3D_TC_MODULATEINVALPHA_ADDCOLOR:
4225	return D3DTOP_MODULATEINVALPHA_ADDCOLOR;
4226	case SVGA3D_TC_MODULATEINVCOLOR_ADDALPHA:
4227	return D3DTOP_MODULATEINVCOLOR_ADDALPHA;
4228	case SVGA3D_TC_BUMPENVMAPLUMINANCE:
4229	return D3DTOP_BUMPENVMAPLUMINANCE;
4230	case SVGA3D_TC_MULTIPLYADD:
4231	return D3DTOP_MULTIPLYADD;
4232	case SVGA3D_TC_LERP:
4233	return D3DTOP_LERP;
4234	default:
4235	AssertFailed();
4236	return D3DTOP_DISABLE;
4237	}
4238	}
4239
4240	/**
4241	* Convert SVGA texture arg data value to its D3D equivalent
4242	*/
4243	static DWORD vmsvga3dTextureArgData2D3D(uint32_t value)
4244	{
4245	switch (value)
4246	{
4247	case SVGA3D_TA_CONSTANT:
4248	return D3DTA_CONSTANT;
4249	case SVGA3D_TA_PREVIOUS:
4250	return D3DTA_CURRENT; /* current = previous */
4251	case SVGA3D_TA_DIFFUSE:
4252	return D3DTA_DIFFUSE;
4253	case SVGA3D_TA_TEXTURE:
4254	return D3DTA_TEXTURE;
4255	case SVGA3D_TA_SPECULAR:
4256	return D3DTA_SPECULAR;
4257	default:
4258	AssertFailed();
4259	return D3DTA_DIFFUSE;
4260	}
4261	}
4262
4263	/**
4264	* Convert SVGA texture transform flag value to its D3D equivalent
4265	*/
4266	static DWORD vmsvga3dTextTransformFlags2D3D(uint32_t value)
4267	{
4268	switch (value)
4269	{
4270	case SVGA3D_TEX_TRANSFORM_OFF:
4271	return D3DTTFF_DISABLE;
4272	case SVGA3D_TEX_TRANSFORM_S:
4273	return D3DTTFF_COUNT1; /** @todo correct? */
4274	case SVGA3D_TEX_TRANSFORM_T:
4275	return D3DTTFF_COUNT2; /** @todo correct? */
4276	case SVGA3D_TEX_TRANSFORM_R:
4277	return D3DTTFF_COUNT3; /** @todo correct? */
4278	case SVGA3D_TEX_TRANSFORM_Q:
4279	return D3DTTFF_COUNT4; /** @todo correct? */
4280	case SVGA3D_TEX_PROJECTED:
4281	return D3DTTFF_PROJECTED;
4282	default:
4283	AssertFailed();
4284	return D3DTTFF_DISABLE;
4285	}
4286	}
4287
4288	static DWORD vmsvga3dSamplerIndex2D3D(uint32_t idxSampler)
4289	{
4290	if (idxSampler < SVGA3D_MAX_SAMPLERS_PS)
4291	return idxSampler;
4292	return (idxSampler - SVGA3D_MAX_SAMPLERS_PS) + D3DDMAPSAMPLER;
4293	}
4294
4295	int vmsvga3dSetTextureState(PVGASTATECC pThisCC, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
4296	{
4297	DWORD val = 0; /* Shut up MSC */
4298	HRESULT hr;
4299	PVMSVGA3DCONTEXT pContext;
4300	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4301	AssertReturn(pState, VERR_NO_MEMORY);
4302
4303	LogFunc(("%x cTextureState=%d\n", cid, cTextureStates));
4304
4305	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4306	AssertRCReturn(rc, rc);
4307
4308	for (unsigned i = 0; i < cTextureStates; i++)
4309	{
4310	LogFunc(("cid=%u stage=%d type=%s (%x) val=%x\n", cid, pTextureState[i].stage, vmsvga3dTextureStateToString(pTextureState[i].name), pTextureState[i].name, pTextureState[i].value));
4311
4312	if (pTextureState[i].name == SVGA3D_TS_BIND_TEXTURE)
4313	{
4314	/* Special case: binding a texture to a sampler. Stage is the sampler index. */
4315	const uint32_t sid = pTextureState[i].value;
4316	const uint32_t idxSampler = pTextureState[i].stage;
4317
4318	if (RT_UNLIKELY(idxSampler >= SVGA3D_MAX_SAMPLERS))
4319	{
4320	AssertMsgFailed(("pTextureState[%d]: SVGA3D_TS_BIND_TEXTURE idxSampler=%d, sid=%u\n", i, idxSampler, sid));
4321	continue;
4322	}
4323
4324	const DWORD d3dSampler = vmsvga3dSamplerIndex2D3D(idxSampler);
4325	if (sid == SVGA3D_INVALID_ID)
4326	{
4327	LogFunc(("SVGA3D_TS_BIND_TEXTURE: unbind sampler=%d\n", idxSampler));
4328
4329	pContext->aSidActiveTextures[idxSampler] = SVGA3D_INVALID_ID;
4330
4331	/* Unselect the currently associated texture. */
4332	hr = pContext->pDevice->SetTexture(d3dSampler, NULL);
4333	AssertMsgReturn(hr == D3D_OK, ("SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
4334	}
4335	else
4336	{
4337	PVMSVGA3DSURFACE pSurface;
4338	rc = vmsvga3dSurfaceFromSid(pState, sid, &pSurface);
4339	AssertRCReturn(rc, rc);
4340
4341	LogFunc(("SVGA3D_TS_BIND_TEXTURE: bind idxSampler=%d, texture sid=%u (%d,%d)\n", idxSampler, sid, pSurface->paMipmapLevels[0].mipmapSize.width, pSurface->paMipmapLevels[0].mipmapSize.height));
4342
4343	if (!pSurface->u.pTexture)
4344	{
4345	Assert(pSurface->idAssociatedContext == SVGA3D_INVALID_ID);
4346	LogFunc(("CreateTexture (%d,%d) level=%d fUsage=%x format=%x\n", pSurface->paMipmapLevels[0].mipmapSize.width, pSurface->paMipmapLevels[0].mipmapSize.height, pSurface->faces[0].numMipLevels, pSurface->fUsageD3D, pSurface->formatD3D));
4347	rc = vmsvga3dBackCreateTexture(pState, pContext, cid, pSurface);
4348	AssertRCReturn(rc, rc);
4349	}
4350	else
4351	{
4352	Assert( pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_TEXTURE
4353	\|\| pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_CUBE_TEXTURE
4354	\|\| pSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VOLUME_TEXTURE);
4355	/* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
4356	vmsvga3dSurfaceFlush(pSurface);
4357	}
4358
4359	#ifndef VBOX_VMSVGA3D_WITH_WINE_OPENGL
4360	if (pSurface->idAssociatedContext != cid)
4361	{
4362	LogFunc(("Using texture sid=%u created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
4363
4364	PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pState, pContext, pSurface);
4365	AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
4366
4367	hr = pContext->pDevice->SetTexture(d3dSampler, pSharedSurface->u.pTexture);
4368	}
4369	else
4370	#endif
4371	hr = pContext->pDevice->SetTexture(d3dSampler, pSurface->u.pTexture);
4372
4373	AssertMsgReturn(hr == D3D_OK, ("SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
4374
4375	pContext->aSidActiveTextures[idxSampler] = sid;
4376	}
4377	/* Finished; continue with the next one. */
4378	continue;
4379	}
4380
4381	D3DTEXTURESTAGESTATETYPE textureType = D3DTSS_FORCE_DWORD;
4382	D3DSAMPLERSTATETYPE samplerType = D3DSAMP_FORCE_DWORD;
4383	switch (pTextureState[i].name)
4384	{
4385	case SVGA3D_TS_COLOROP: /* SVGA3dTextureCombiner */
4386	textureType = D3DTSS_COLOROP;
4387	val = vmsvga3dTextureCombiner2D3D(pTextureState[i].value);
4388	break;
4389
4390	case SVGA3D_TS_COLORARG0: /* SVGA3dTextureArgData */
4391	textureType = D3DTSS_COLORARG0;
4392	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4393	break;
4394
4395	case SVGA3D_TS_COLORARG1: /* SVGA3dTextureArgData */
4396	textureType = D3DTSS_COLORARG1;
4397	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4398	break;
4399
4400	case SVGA3D_TS_COLORARG2: /* SVGA3dTextureArgData */
4401	textureType = D3DTSS_COLORARG2;
4402	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4403	break;
4404
4405	case SVGA3D_TS_ALPHAOP: /* SVGA3dTextureCombiner */
4406	textureType = D3DTSS_ALPHAOP;
4407	val = vmsvga3dTextureCombiner2D3D(pTextureState[i].value);
4408	break;
4409
4410	case SVGA3D_TS_ALPHAARG0: /* SVGA3dTextureArgData */
4411	textureType = D3DTSS_ALPHAARG0;
4412	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4413	break;
4414
4415	case SVGA3D_TS_ALPHAARG1: /* SVGA3dTextureArgData */
4416	textureType = D3DTSS_ALPHAARG1;
4417	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4418	break;
4419
4420	case SVGA3D_TS_ALPHAARG2: /* SVGA3dTextureArgData */
4421	textureType = D3DTSS_ALPHAARG2;
4422	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4423	break;
4424
4425	case SVGA3D_TS_BUMPENVMAT00: /* float */
4426	textureType = D3DTSS_BUMPENVMAT00;
4427	val = pTextureState[i].value;
4428	break;
4429
4430	case SVGA3D_TS_BUMPENVMAT01: /* float */
4431	textureType = D3DTSS_BUMPENVMAT01;
4432	val = pTextureState[i].value;
4433	break;
4434
4435	case SVGA3D_TS_BUMPENVMAT10: /* float */
4436	textureType = D3DTSS_BUMPENVMAT10;
4437	val = pTextureState[i].value;
4438	break;
4439
4440	case SVGA3D_TS_BUMPENVMAT11: /* float */
4441	textureType = D3DTSS_BUMPENVMAT11;
4442	val = pTextureState[i].value;
4443	break;
4444
4445	case SVGA3D_TS_TEXCOORDINDEX: /* uint32_t */
4446	textureType = D3DTSS_TEXCOORDINDEX;
4447	val = pTextureState[i].value;
4448	break;
4449
4450	case SVGA3D_TS_BUMPENVLSCALE: /* float */
4451	textureType = D3DTSS_BUMPENVLSCALE;
4452	val = pTextureState[i].value;
4453	break;
4454
4455	case SVGA3D_TS_BUMPENVLOFFSET: /* float */
4456	textureType = D3DTSS_BUMPENVLOFFSET;
4457	val = pTextureState[i].value;
4458	break;
4459
4460	case SVGA3D_TS_TEXTURETRANSFORMFLAGS: /* SVGA3dTexTransformFlags */
4461	textureType = D3DTSS_TEXTURETRANSFORMFLAGS;
4462	val = vmsvga3dTextTransformFlags2D3D(pTextureState[i].value);
4463	break;
4464
4465	case SVGA3D_TS_ADDRESSW: /* SVGA3dTextureAddress */
4466	samplerType = D3DSAMP_ADDRESSW;
4467	val = pTextureState[i].value; /* Identical otherwise */
4468	Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
4469	break;
4470
4471	case SVGA3D_TS_ADDRESSU: /* SVGA3dTextureAddress */
4472	samplerType = D3DSAMP_ADDRESSU;
4473	val = pTextureState[i].value; /* Identical otherwise */
4474	Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
4475	break;
4476
4477	case SVGA3D_TS_ADDRESSV: /* SVGA3dTextureAddress */
4478	samplerType = D3DSAMP_ADDRESSV;
4479	val = pTextureState[i].value; /* Identical otherwise */
4480	Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
4481	break;
4482
4483	case SVGA3D_TS_MIPFILTER: /* SVGA3dTextureFilter */
4484	samplerType = D3DSAMP_MIPFILTER;
4485	val = pTextureState[i].value; /* Identical otherwise */
4486	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
4487	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
4488	break;
4489
4490	case SVGA3D_TS_MAGFILTER: /* SVGA3dTextureFilter */
4491	samplerType = D3DSAMP_MAGFILTER;
4492	val = pTextureState[i].value; /* Identical otherwise */
4493	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
4494	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
4495	break;
4496
4497	case SVGA3D_TS_MINFILTER: /* SVGA3dTextureFilter */
4498	samplerType = D3DSAMP_MINFILTER;
4499	val = pTextureState[i].value; /* Identical otherwise */
4500	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
4501	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
4502	break;
4503
4504	case SVGA3D_TS_BORDERCOLOR: /* SVGA3dColor */
4505	samplerType = D3DSAMP_BORDERCOLOR;
4506	val = pTextureState[i].value; /* Identical */
4507	break;
4508
4509	case SVGA3D_TS_TEXTURE_LOD_BIAS: /* float */
4510	samplerType = D3DSAMP_MIPMAPLODBIAS;
4511	val = pTextureState[i].value; /* Identical */
4512	break;
4513
4514	case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL: /* uint32_t */
4515	samplerType = D3DSAMP_MAXMIPLEVEL;
4516	val = pTextureState[i].value; /* Identical?? */
4517	break;
4518
4519	case SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL: /* uint32_t */
4520	samplerType = D3DSAMP_MAXANISOTROPY;
4521	val = pTextureState[i].value; /* Identical?? */
4522	break;
4523
4524	case SVGA3D_TS_GAMMA: /* float */
4525	samplerType = D3DSAMP_SRGBTEXTURE;
4526	/* Boolean in D3D */
4527	if (pTextureState[i].floatValue == 1.0f)
4528	val = FALSE;
4529	else
4530	val = TRUE;
4531	break;
4532
4533	/* Internal commands, that don't map directly to the SetTextureStageState API. */
4534	case SVGA3D_TS_TEXCOORDGEN: /* SVGA3dTextureCoordGen */
4535	AssertFailed();
4536	break;
4537
4538	case SVGA3D_TS_MAX: /* shut up MSC */
4539	case SVGA3D_TS_INVALID:
4540	case SVGA3D_TS_BIND_TEXTURE:
4541	AssertFailedBreak();
4542	}
4543
4544	const uint32_t currentStage = pTextureState[i].stage;
4545	/* Record the texture state for vm state saving. */
4546	if ( currentStage < RT_ELEMENTS(pContext->state.aTextureStates)
4547	&& (unsigned)pTextureState[i].name < RT_ELEMENTS(pContext->state.aTextureStates[0]))
4548	{
4549	pContext->state.aTextureStates[currentStage][pTextureState[i].name] = pTextureState[i];
4550	}
4551
4552	if (textureType != D3DTSS_FORCE_DWORD)
4553	{
4554	if (RT_UNLIKELY(currentStage >= SVGA3D_MAX_TEXTURE_STAGES))
4555	{
4556	AssertMsgFailed(("pTextureState[%d].stage=%#x name=%#x value=%#x\n", i, pTextureState[i].stage, pTextureState[i].name, pTextureState[i].value));
4557	continue;
4558	}
4559
4560	hr = pContext->pDevice->SetTextureStageState(currentStage, textureType, val);
4561	AssertMsg(hr == D3D_OK, ("SetTextureStageState failed with %x\n", hr));
4562	}
4563	else if (samplerType != D3DSAMP_FORCE_DWORD)
4564	{
4565	if (RT_UNLIKELY(currentStage >= SVGA3D_MAX_SAMPLERS))
4566	{
4567	AssertMsgFailed(("pTextureState[%d].stage=%#x name=%#x value=%#x\n", i, pTextureState[i].stage, pTextureState[i].name, pTextureState[i].value));
4568	continue;
4569	}
4570
4571	hr = pContext->pDevice->SetSamplerState(currentStage, samplerType, val);
4572	AssertMsg(hr == D3D_OK, ("SetSamplerState failed with %x\n", hr));
4573	}
4574	else
4575	{
4576	AssertFailed();
4577	}
4578	}
4579
4580	return VINF_SUCCESS;
4581	}
4582
4583	int vmsvga3dSetMaterial(PVGASTATECC pThisCC, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
4584	{
4585	HRESULT hr;
4586	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4587	AssertReturn(pState, VERR_NO_MEMORY);
4588
4589	LogFunc(("cid=%u face %d\n", cid, face));
4590
4591	PVMSVGA3DCONTEXT pContext;
4592	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4593	AssertRCReturn(rc, rc);
4594
4595	AssertReturn((unsigned)face < SVGA3D_FACE_MAX, VERR_INVALID_PARAMETER);
4596
4597	/* Save for vm state save/restore. */
4598	pContext->state.aMaterial[face].fValid = true;
4599	pContext->state.aMaterial[face].material = *pMaterial;
4600	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_MATERIAL;
4601
4602	/* @note face not used for D3D9 */
4603	/** @todo ignore everything except SVGA3D_FACE_NONE? */
4604	//Assert(face == SVGA3D_FACE_NONE);
4605	if (face != SVGA3D_FACE_NONE)
4606	Log(("Unsupported face %d!!\n", face));
4607
4608	D3DMATERIAL9 material;
4609	material.Diffuse.r = pMaterial->diffuse[0];
4610	material.Diffuse.g = pMaterial->diffuse[1];
4611	material.Diffuse.b = pMaterial->diffuse[2];
4612	material.Diffuse.a = pMaterial->diffuse[3];
4613	material.Ambient.r = pMaterial->ambient[0];
4614	material.Ambient.g = pMaterial->ambient[1];
4615	material.Ambient.b = pMaterial->ambient[2];
4616	material.Ambient.a = pMaterial->ambient[3];
4617	material.Specular.r = pMaterial->specular[0];
4618	material.Specular.g = pMaterial->specular[1];
4619	material.Specular.b = pMaterial->specular[2];
4620	material.Specular.a = pMaterial->specular[3];
4621	material.Emissive.r = pMaterial->emissive[0];
4622	material.Emissive.g = pMaterial->emissive[1];
4623	material.Emissive.b = pMaterial->emissive[2];
4624	material.Emissive.a = pMaterial->emissive[3];
4625	material.Power = pMaterial->shininess;
4626
4627	hr = pContext->pDevice->SetMaterial(&material);
4628	AssertMsgReturn(hr == D3D_OK, ("SetMaterial failed with %x\n", hr), VERR_INTERNAL_ERROR);
4629
4630	return VINF_SUCCESS;
4631	}
4632
4633	int vmsvga3dSetLightData(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
4634	{
4635	HRESULT hr;
4636	D3DLIGHT9 light;
4637	PVMSVGA3DCONTEXT pContext;
4638	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4639	AssertReturn(pState, VERR_NO_MEMORY);
4640
4641	Log(("vmsvga3dSetLightData %x index=%d\n", cid, index));
4642
4643	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4644	AssertRCReturn(rc, rc);
4645
4646	switch (pData->type)
4647	{
4648	case SVGA3D_LIGHTTYPE_POINT:
4649	light.Type = D3DLIGHT_POINT;
4650	break;
4651
4652	case SVGA3D_LIGHTTYPE_SPOT1: /* 1-cone, in degrees */
4653	light.Type = D3DLIGHT_SPOT;
4654	break;
4655
4656	case SVGA3D_LIGHTTYPE_DIRECTIONAL:
4657	light.Type = D3DLIGHT_DIRECTIONAL;
4658	break;
4659
4660	case SVGA3D_LIGHTTYPE_SPOT2: /* 2-cone, in radians */
4661	default:
4662	Log(("Unsupported light type!!\n"));
4663	return VERR_INVALID_PARAMETER;
4664	}
4665
4666	/* Store for vm state save/restore */
4667	if (index < SVGA3D_MAX_LIGHTS)
4668	{
4669	pContext->state.aLightData[index].fValidData = true;
4670	pContext->state.aLightData[index].data = *pData;
4671	}
4672	else
4673	AssertFailed();
4674
4675	light.Diffuse.r = pData->diffuse[0];
4676	light.Diffuse.g = pData->diffuse[1];
4677	light.Diffuse.b = pData->diffuse[2];
4678	light.Diffuse.a = pData->diffuse[3];
4679	light.Specular.r = pData->specular[0];
4680	light.Specular.g = pData->specular[1];
4681	light.Specular.b = pData->specular[2];
4682	light.Specular.a = pData->specular[3];
4683	light.Ambient.r = pData->ambient[0];
4684	light.Ambient.g = pData->ambient[1];
4685	light.Ambient.b = pData->ambient[2];
4686	light.Ambient.a = pData->ambient[3];
4687	light.Position.x = pData->position[0];
4688	light.Position.y = pData->position[1];
4689	light.Position.z = pData->position[2]; /* @note 4th position not available in D3D9 */
4690	light.Direction.x = pData->direction[0];
4691	light.Direction.y = pData->direction[1];
4692	light.Direction.z = pData->direction[2]; /* @note 4th position not available in D3D9 */
4693	light.Range = pData->range;
4694	light.Falloff = pData->falloff;
4695	light.Attenuation0 = pData->attenuation0;
4696	light.Attenuation1 = pData->attenuation1;
4697	light.Attenuation2 = pData->attenuation2;
4698	light.Theta = pData->theta;
4699	light.Phi = pData->phi;
4700
4701	hr = pContext->pDevice->SetLight(index, &light);
4702	AssertMsgReturn(hr == D3D_OK, ("SetLight failed with %x\n", hr), VERR_INTERNAL_ERROR);
4703
4704	return VINF_SUCCESS;
4705	}
4706
4707	int vmsvga3dSetLightEnabled(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, uint32_t enabled)
4708	{
4709	HRESULT hr;
4710	PVMSVGA3DCONTEXT pContext;
4711	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4712	AssertReturn(pState, VERR_NO_MEMORY);
4713
4714	Log(("vmsvga3dSetLightEnabled %x %d -> %d\n", cid, index, enabled));
4715	AssertReturn(index < SVGA3D_MAX_LIGHTS, VERR_INVALID_PARAMETER);
4716
4717	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4718	AssertRCReturn(rc, rc);
4719
4720	/* Store for vm state save/restore */
4721	pContext->state.aLightData[index].fEnabled = !!enabled;
4722
4723	hr = pContext->pDevice->LightEnable(index, (BOOL)enabled);
4724	AssertMsgReturn(hr == D3D_OK, ("LightEnable failed with %x\n", hr), VERR_INTERNAL_ERROR);
4725
4726	return VINF_SUCCESS;
4727	}
4728
4729	int vmsvga3dSetViewPort(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
4730	{
4731	HRESULT hr;
4732	D3DVIEWPORT9 viewPort;
4733	PVMSVGA3DCONTEXT pContext;
4734	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4735	AssertReturn(pState, VERR_NO_MEMORY);
4736
4737	Log(("vmsvga3dSetViewPort %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
4738
4739	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4740	AssertRCReturn(rc, rc);
4741
4742	/* Save for vm state save/restore. */
4743	pContext->state.RectViewPort = *pRect;
4744	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_VIEWPORT;
4745
4746	hr = pContext->pDevice->GetViewport(&viewPort);
4747	AssertMsgReturn(hr == D3D_OK, ("GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
4748
4749	viewPort.X = pRect->x;
4750	viewPort.Y = pRect->y;
4751	viewPort.Width = pRect->w;
4752	viewPort.Height = pRect->h;
4753	/* viewPort.MinZ & MaxZ are not changed from the current setting. */
4754
4755	hr = pContext->pDevice->SetViewport(&viewPort);
4756	AssertMsgReturn(hr == D3D_OK, ("SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
4757
4758	return VINF_SUCCESS;
4759	}
4760
4761	int vmsvga3dSetClipPlane(PVGASTATECC pThisCC, uint32_t cid, uint32_t index, float plane[4])
4762	{
4763	HRESULT hr;
4764	PVMSVGA3DCONTEXT pContext;
4765	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4766	AssertReturn(pState, VERR_NO_MEMORY);
4767
4768	Log(("vmsvga3dSetClipPlane %x %d (%d,%d)(%d,%d)\n", cid, index, (unsigned)(plane[0] * 100.0), (unsigned)(plane[1] * 100.0), (unsigned)(plane[2] * 100.0), (unsigned)(plane[3] * 100.0)));
4769	AssertReturn(index < SVGA3D_CLIPPLANE_MAX, VERR_INVALID_PARAMETER);
4770
4771	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4772	AssertRCReturn(rc, rc);
4773
4774	/* Store for vm state save/restore. */
4775	pContext->state.aClipPlane[index].fValid = true;
4776	memcpy(pContext->state.aClipPlane[index].plane, plane, sizeof(pContext->state.aClipPlane[index].plane));
4777
4778	hr = pContext->pDevice->SetClipPlane(index, plane);
4779	AssertMsgReturn(hr == D3D_OK, ("SetClipPlane failed with %x\n", hr), VERR_INTERNAL_ERROR);
4780	return VINF_SUCCESS;
4781	}
4782
4783	int vmsvga3dCommandClear(PVGASTATECC pThisCC, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth,
4784	uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
4785	{
4786	/* From SVGA3D_BeginClear comments:
4787	*
4788	* Clear is not affected by clipping, depth test, or other
4789	* render state which affects the fragment pipeline.
4790	*
4791	* Therefore this code must ignore the current scissor rect.
4792	*/
4793
4794	DWORD clearFlagD3D = 0;
4795	D3DRECT *pRectD3D = NULL;
4796	HRESULT hr;
4797	PVMSVGA3DCONTEXT pContext;
4798	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
4799	AssertReturn(pState, VERR_NO_MEMORY);
4800
4801	Log(("vmsvga3dCommandClear %x clearFlag=%x color=%x depth=%d stencil=%x cRects=%d\n", cid, clearFlag, color, (uint32_t)(depth * 100.0), stencil, cRects));
4802
4803	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
4804	AssertRCReturn(rc, rc);
4805
4806	PVMSVGA3DSURFACE pRT;
4807	rc = vmsvga3dSurfaceFromSid(pState, pContext->state.aRenderTargets[SVGA3D_RT_COLOR0], &pRT);
4808	AssertRCReturn(rc, rc);
4809
4810	if (clearFlag & SVGA3D_CLEAR_COLOR)
4811	clearFlagD3D \|= D3DCLEAR_TARGET;
4812	if (clearFlag & SVGA3D_CLEAR_STENCIL)
4813	clearFlagD3D \|= D3DCLEAR_STENCIL;
4814	if (clearFlag & SVGA3D_CLEAR_DEPTH)
4815	clearFlagD3D \|= D3DCLEAR_ZBUFFER;
4816
4817	if (cRects)
4818	{
4819	pRectD3D = (D3DRECT )RTMemAlloc(sizeof(D3DRECT) cRects);
4820	AssertReturn(pRectD3D, VERR_NO_MEMORY);
4821
4822	for (unsigned i=0; i < cRects; i++)
4823	{
4824	Log(("vmsvga3dCommandClear: rect %d (%d,%d)(%d,%d)\n", i, pRect[i].x, pRect[i].y, pRect[i].x + pRect[i].w, pRect[i].y + pRect[i].h));
4825	pRectD3D[i].x1 = pRect[i].x;
4826	pRectD3D[i].y1 = pRect[i].y;
4827	pRectD3D[i].x2 = pRect[i].x + pRect[i].w; /* exclusive */
4828	pRectD3D[i].y2 = pRect[i].y + pRect[i].h; /* exclusive */
4829	}
4830	}
4831
4832	RECT currentScissorRect;
4833	pContext->pDevice->GetScissorRect(&currentScissorRect);
4834
4835	RECT clearScissorRect;
4836	clearScissorRect.left = 0;
4837	clearScissorRect.top = 0;
4838	clearScissorRect.right = pRT->paMipmapLevels[0].mipmapSize.width;
4839	clearScissorRect.bottom = pRT->paMipmapLevels[0].mipmapSize.height;
4840	pContext->pDevice->SetScissorRect(&clearScissorRect);
4841
4842	hr = pContext->pDevice->Clear(cRects, pRectD3D, clearFlagD3D, (D3DCOLOR)color, depth, stencil);
4843
4844	if (pRectD3D)
4845	RTMemFree(pRectD3D);
4846
4847	pContext->pDevice->SetScissorRect(&currentScissorRect);
4848
4849	AssertMsgReturn(hr == D3D_OK, ("Clear failed with %x\n", hr), VERR_INTERNAL_ERROR);
4850
4851	/* Make sure we can track drawing usage of active render targets. */
4852	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderTargets); ++i)
4853	if (pContext->state.aRenderTargets[i] != SVGA3D_INVALID_ID)
4854	vmsvga3dSurfaceTrackUsageById(pState, pContext, pContext->state.aRenderTargets[i]);
4855
4856	return VINF_SUCCESS;
4857	}
4858
4859	/* Convert VMWare vertex declaration to its D3D equivalent. */
4860	static int vmsvga3dVertexDecl2D3D(const SVGA3dVertexArrayIdentity &identity, D3DVERTEXELEMENT9 *pVertexElement)
4861	{
4862	/* usage, method and type are identical; make sure. */
4863	AssertCompile(SVGA3D_DECLTYPE_FLOAT1 == D3DDECLTYPE_FLOAT1);
4864	AssertCompile(SVGA3D_DECLTYPE_FLOAT16_4 == D3DDECLTYPE_FLOAT16_4);
4865	AssertCompile(SVGA3D_DECLMETHOD_DEFAULT == D3DDECLMETHOD_DEFAULT);
4866	AssertCompile(SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED == D3DDECLMETHOD_LOOKUPPRESAMPLED);
4867	AssertCompile(D3DDECLUSAGE_POSITION == SVGA3D_DECLUSAGE_POSITION);
4868	AssertCompile(D3DDECLUSAGE_SAMPLE == SVGA3D_DECLUSAGE_SAMPLE);
4869
4870	pVertexElement->Stream = 0;
4871	pVertexElement->Offset = 0;
4872	pVertexElement->Type = identity.type;
4873	pVertexElement->Method = identity.method;
4874	pVertexElement->Usage = identity.usage;
4875	pVertexElement->UsageIndex = identity.usageIndex;
4876	return VINF_SUCCESS;
4877	}
4878
4879	/* Convert VMWare primitive type to its D3D equivalent. */
4880	static int vmsvga3dPrimitiveType2D3D(SVGA3dPrimitiveType PrimitiveType, D3DPRIMITIVETYPE *pPrimitiveTypeD3D)
4881	{
4882	switch (PrimitiveType)
4883	{
4884	case SVGA3D_PRIMITIVE_TRIANGLELIST:
4885	*pPrimitiveTypeD3D = D3DPT_TRIANGLELIST;
4886	break;
4887	case SVGA3D_PRIMITIVE_POINTLIST:
4888	*pPrimitiveTypeD3D = D3DPT_POINTLIST;
4889	break;
4890	case SVGA3D_PRIMITIVE_LINELIST:
4891	*pPrimitiveTypeD3D = D3DPT_LINELIST;
4892	break;
4893	case SVGA3D_PRIMITIVE_LINESTRIP:
4894	*pPrimitiveTypeD3D = D3DPT_LINESTRIP;
4895	break;
4896	case SVGA3D_PRIMITIVE_TRIANGLESTRIP:
4897	*pPrimitiveTypeD3D = D3DPT_TRIANGLESTRIP;
4898	break;
4899	case SVGA3D_PRIMITIVE_TRIANGLEFAN:
4900	*pPrimitiveTypeD3D = D3DPT_TRIANGLEFAN;
4901	break;
4902	default:
4903	return VERR_INVALID_PARAMETER;
4904	}
4905	return VINF_SUCCESS;
4906	}
4907
4908
4909	static int vmsvga3dDrawPrimitivesSyncVertexBuffer(PVMSVGA3DCONTEXT pContext,
4910	PVMSVGA3DSURFACE pVertexSurface)
4911	{
4912	HRESULT hr;
4913	if ( pVertexSurface->u.pSurface
4914	&& pVertexSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER)
4915	{
4916	/* The buffer object is not an vertex one. Recreate the D3D resource. */
4917	Assert(pVertexSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_INDEX_BUFFER);
4918	D3D_RELEASE(pVertexSurface->u.pIndexBuffer);
4919	pVertexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_NONE;
4920
4921	LogFunc(("index -> vertex buffer sid=%u\n", pVertexSurface->id));
4922	}
4923
4924	bool fSync = pVertexSurface->fDirty;
4925	if (!pVertexSurface->u.pVertexBuffer)
4926	{
4927	LogFunc(("Create vertex buffer sid=%u fDirty=%d\n", pVertexSurface->id, pVertexSurface->fDirty));
4928
4929	const DWORD Usage = D3DUSAGE_DYNAMIC \| D3DUSAGE_WRITEONLY; /* possible severe performance penalty otherwise (according to d3d debug output */
4930	hr = pContext->pDevice->CreateVertexBuffer(pVertexSurface->paMipmapLevels[0].cbSurface,
4931	Usage,
4932	0, /* non-FVF */
4933	D3DPOOL_DEFAULT,
4934	&pVertexSurface->u.pVertexBuffer,
4935	NULL);
4936	AssertMsgReturn(hr == D3D_OK, ("CreateVertexBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
4937
4938	pVertexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER;
4939	pVertexSurface->idAssociatedContext = pContext->id;
4940	pVertexSurface->surfaceFlags \|= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
4941	fSync = true;
4942	}
4943
4944	if (fSync)
4945	{
4946	LogFunc(("sync vertex buffer\n"));
4947	Assert(pVertexSurface->u.pVertexBuffer);
4948
4949	void *pvData;
4950	hr = pVertexSurface->u.pVertexBuffer->Lock(0, 0, &pvData, D3DLOCK_DISCARD);
4951	AssertMsgReturn(hr == D3D_OK, ("Lock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
4952
4953	memcpy(pvData, pVertexSurface->paMipmapLevels[0].pSurfaceData, pVertexSurface->paMipmapLevels[0].cbSurface);
4954
4955	hr = pVertexSurface->u.pVertexBuffer->Unlock();
4956	AssertMsgReturn(hr == D3D_OK, ("Unlock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
4957	}
4958
4959	return VINF_SUCCESS;
4960	}
4961
4962
4963	static int vmsvga3dDrawPrimitivesSyncIndexBuffer(PVMSVGA3DCONTEXT pContext,
4964	PVMSVGA3DSURFACE pIndexSurface,
4965	uint32_t indexWidth)
4966	{
4967	HRESULT hr;
4968	if ( pIndexSurface->u.pSurface
4969	&& pIndexSurface->enmD3DResType != VMSVGA3D_D3DRESTYPE_INDEX_BUFFER)
4970	{
4971	/* The buffer object is not an index one. Must recreate the D3D resource. */
4972	Assert(pIndexSurface->enmD3DResType == VMSVGA3D_D3DRESTYPE_VERTEX_BUFFER);
4973	D3D_RELEASE(pIndexSurface->u.pVertexBuffer);
4974	pIndexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_NONE;
4975
4976	LogFunc(("vertex -> index buffer sid=%u\n", pIndexSurface->id));
4977	}
4978
4979	bool fSync = pIndexSurface->fDirty;
4980	if (!pIndexSurface->u.pIndexBuffer)
4981	{
4982	LogFunc(("Create index buffer fDirty=%d\n", pIndexSurface->fDirty));
4983
4984	const DWORD Usage = D3DUSAGE_DYNAMIC \| D3DUSAGE_WRITEONLY; /* possible severe performance penalty otherwise (according to d3d debug output */
4985	const D3DFORMAT Format = (indexWidth == sizeof(uint16_t)) ? D3DFMT_INDEX16 : D3DFMT_INDEX32;
4986	hr = pContext->pDevice->CreateIndexBuffer(pIndexSurface->paMipmapLevels[0].cbSurface,
4987	Usage,
4988	Format,
4989	D3DPOOL_DEFAULT,
4990	&pIndexSurface->u.pIndexBuffer,
4991	NULL);
4992	AssertMsgReturn(hr == D3D_OK, ("CreateIndexBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
4993
4994	pIndexSurface->enmD3DResType = VMSVGA3D_D3DRESTYPE_INDEX_BUFFER;
4995	pIndexSurface->idAssociatedContext = pContext->id;
4996	pIndexSurface->surfaceFlags \|= SVGA3D_SURFACE_HINT_INDEXBUFFER;
4997	fSync = true;
4998	}
4999
5000	if (fSync)
5001	{
5002	LogFunc(("sync index buffer\n"));
5003	Assert(pIndexSurface->u.pIndexBuffer);
5004
5005	void *pvData;
5006	hr = pIndexSurface->u.pIndexBuffer->Lock(0, 0, &pvData, D3DLOCK_DISCARD);
5007	AssertMsgReturn(hr == D3D_OK, ("Lock index failed with %x\n", hr), VERR_INTERNAL_ERROR);
5008
5009	memcpy(pvData, pIndexSurface->paMipmapLevels[0].pSurfaceData, pIndexSurface->paMipmapLevels[0].cbSurface);
5010
5011	hr = pIndexSurface->u.pIndexBuffer->Unlock();
5012	AssertMsgReturn(hr == D3D_OK, ("Unlock index failed with %x\n", hr), VERR_INTERNAL_ERROR);
5013	}
5014
5015	return VINF_SUCCESS;
5016	}
5017
5018	static int vmsvga3dDrawPrimitivesProcessVertexDecls(const uint32_t numVertexDecls,
5019	const SVGA3dVertexDecl *pVertexDecl,
5020	const uint32_t idStream,
5021	const uint32_t uVertexMinOffset,
5022	const uint32_t uVertexMaxOffset,
5023	D3DVERTEXELEMENT9 *pVertexElement)
5024	{
5025	RT_NOREF(uVertexMaxOffset); /* Logging only. */
5026	Assert(numVertexDecls);
5027
5028	/* Create a vertex declaration array */
5029	for (uint32_t iVertex = 0; iVertex < numVertexDecls; ++iVertex)
5030	{
5031	LogFunc(("vertex %d type=%s (%d) method=%s (%d) usage=%s (%d) usageIndex=%d stride=%d offset=%d (%d min=%d max=%d)\n",
5032	iVertex,
5033	vmsvgaDeclType2String(pVertexDecl[iVertex].identity.type), pVertexDecl[iVertex].identity.type,
5034	vmsvgaDeclMethod2String(pVertexDecl[iVertex].identity.method), pVertexDecl[iVertex].identity.method,
5035	vmsvgaDeclUsage2String(pVertexDecl[iVertex].identity.usage), pVertexDecl[iVertex].identity.usage,
5036	pVertexDecl[iVertex].identity.usageIndex,
5037	pVertexDecl[iVertex].array.stride,
5038	pVertexDecl[iVertex].array.offset - uVertexMinOffset,
5039	pVertexDecl[iVertex].array.offset,
5040	uVertexMinOffset, uVertexMaxOffset));
5041
5042	int rc = vmsvga3dVertexDecl2D3D(pVertexDecl[iVertex].identity, &pVertexElement[iVertex]);
5043	AssertRCReturn(rc, rc);
5044
5045	pVertexElement[iVertex].Stream = idStream;
5046	pVertexElement[iVertex].Offset = pVertexDecl[iVertex].array.offset - uVertexMinOffset;
5047
5048	#ifdef LOG_ENABLED
5049	if (pVertexDecl[iVertex].array.stride == 0)
5050	LogFunc(("stride == 0! Can be valid\n"));
5051
5052	if (pVertexElement[iVertex].Offset >= pVertexDecl[0].array.stride)
5053	LogFunc(("WARNING: offset > stride!!\n"));
5054	#endif
5055	}
5056
5057	return VINF_SUCCESS;
5058	}
5059
5060	int vmsvga3dDrawPrimitives(PVGASTATECC pThisCC, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl *pVertexDecl,
5061	uint32_t numRanges, SVGA3dPrimitiveRange *pRange,
5062	uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
5063	{
5064	static const D3DVERTEXELEMENT9 sVertexEnd = D3DDECL_END();
5065
5066	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5067	AssertReturn(pState, VERR_INTERNAL_ERROR);
5068
5069	PVMSVGA3DCONTEXT pContext;
5070	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5071	AssertRCReturn(rc, rc);
5072
5073	HRESULT hr;
5074
5075	/* SVGA driver may use the same surface for both index and vertex data. So we can not clear fDirty flag,
5076	* after updating a vertex buffer for example, because the same surface might be used for index buffer later.
5077	* So keep pointers to all used surfaces in the following two arrays and clear fDirty flag at the end.
5078	*/
5079	PVMSVGA3DSURFACE aVertexSurfaces[SVGA3D_MAX_VERTEX_ARRAYS];
5080	PVMSVGA3DSURFACE aIndexSurfaces[SVGA3D_MAX_DRAW_PRIMITIVE_RANGES];
5081	RT_ZERO(aVertexSurfaces);
5082	RT_ZERO(aIndexSurfaces);
5083
5084	LogFunc(("cid=%u numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
5085
5086	AssertReturn(numVertexDecls && numVertexDecls <= SVGA3D_MAX_VERTEX_ARRAYS, VERR_INVALID_PARAMETER);
5087	AssertReturn(numRanges && numRanges <= SVGA3D_MAX_DRAW_PRIMITIVE_RANGES, VERR_INVALID_PARAMETER);
5088	AssertReturn(!cVertexDivisor \|\| cVertexDivisor == numVertexDecls, VERR_INVALID_PARAMETER);
5089
5090	/*
5091	* Process all vertex declarations. Each vertex buffer surface is represented by one stream source id.
5092	*/
5093	D3DVERTEXELEMENT9 aVertexElements[SVGA3D_MAX_VERTEX_ARRAYS + 1];
5094
5095	uint32_t iCurrentVertex = 0;
5096	uint32_t iCurrentStreamId = 0;
5097	while (iCurrentVertex < numVertexDecls)
5098	{
5099	const uint32_t sidVertex = pVertexDecl[iCurrentVertex].array.surfaceId;
5100	const uint32_t strideVertex = pVertexDecl[iCurrentVertex].array.stride;
5101
5102	PVMSVGA3DSURFACE pVertexSurface;
5103	rc = vmsvga3dSurfaceFromSid(pState, sidVertex, &pVertexSurface);
5104	AssertRCBreak(rc);
5105
5106	rc = vmsvga3dDrawPrimitivesSyncVertexBuffer(pContext, pVertexSurface);
5107	AssertRCBreak(rc);
5108
5109	uint32_t uVertexMinOffset = UINT32_MAX;
5110	uint32_t uVertexMaxOffset = 0;
5111
5112	uint32_t iVertex;
5113	for (iVertex = iCurrentVertex; iVertex < numVertexDecls; ++iVertex)
5114	{
5115	/* Remember, so we can mark it as not dirty later. */
5116	aVertexSurfaces[iVertex] = pVertexSurface;
5117
5118	/* New surface id -> new stream id. */
5119	if (pVertexDecl[iVertex].array.surfaceId != sidVertex)
5120	break;
5121
5122	const uint32_t uVertexOffset = pVertexDecl[iVertex].array.offset;
5123	const uint32_t uNewVertexMinOffset = RT_MIN(uVertexMinOffset, uVertexOffset);
5124	const uint32_t uNewVertexMaxOffset = RT_MAX(uVertexMaxOffset, uVertexOffset);
5125
5126	/* We must put vertex declarations that start at a different element in another stream as d3d only handles offsets < stride. */
5127	if ( uNewVertexMaxOffset - uNewVertexMinOffset >= strideVertex
5128	&& strideVertex != 0)
5129	break;
5130
5131	uVertexMinOffset = uNewVertexMinOffset;
5132	uVertexMaxOffset = uNewVertexMaxOffset;
5133	}
5134
5135	rc = vmsvga3dDrawPrimitivesProcessVertexDecls(iVertex - iCurrentVertex,
5136	&pVertexDecl[iCurrentVertex],
5137	iCurrentStreamId,
5138	uVertexMinOffset,
5139	uVertexMaxOffset,
5140	&aVertexElements[iCurrentVertex]);
5141	AssertRCBreak(rc);
5142
5143	LogFunc(("SetStreamSource vertex sid=%u stream %d min offset=%d stride=%d\n",
5144	pVertexSurface->id, iCurrentStreamId, uVertexMinOffset, strideVertex));
5145
5146	hr = pContext->pDevice->SetStreamSource(iCurrentStreamId,
5147	pVertexSurface->u.pVertexBuffer,
5148	uVertexMinOffset,
5149	strideVertex);
5150	AssertMsgBreakStmt(hr == D3D_OK, ("SetStreamSource failed with %x\n", hr), rc = VERR_INTERNAL_ERROR);
5151
5152	if (cVertexDivisor)
5153	{
5154	LogFunc(("SetStreamSourceFreq[%d]=%x\n", iCurrentStreamId, pVertexDivisor[iCurrentVertex].value));
5155	HRESULT hr2 = pContext->pDevice->SetStreamSourceFreq(iCurrentStreamId,
5156	pVertexDivisor[iCurrentVertex].value);
5157	Assert(SUCCEEDED(hr2)); RT_NOREF(hr2);
5158	}
5159
5160	iCurrentVertex = iVertex;
5161	++iCurrentStreamId;
5162	}
5163
5164	/* iCurrentStreamId is equal to the total number of streams and the value is used for cleanup at the function end. */
5165
5166	AssertRCReturn(rc, rc);
5167
5168	/* Mark the end. */
5169	memcpy(&aVertexElements[numVertexDecls], &sVertexEnd, sizeof(sVertexEnd));
5170
5171	/* Check if this context already has the same vertex declaration. */
5172	if ( pContext->d3dState.pVertexDecl
5173	&& pContext->d3dState.cVertexElements == numVertexDecls + 1
5174	&& memcmp(pContext->d3dState.aVertexElements,
5175	aVertexElements,
5176	pContext->d3dState.cVertexElements * sizeof(aVertexElements[0])) == 0)
5177	{
5178	/* Same. */
5179	}
5180	else
5181	{
5182	D3D_RELEASE(pContext->d3dState.pVertexDecl);
5183
5184	pContext->d3dState.cVertexElements = numVertexDecls + 1;
5185	memcpy(pContext->d3dState.aVertexElements,
5186	aVertexElements,
5187	pContext->d3dState.cVertexElements * sizeof(aVertexElements[0]));
5188
5189	/* Create and set the vertex declaration. */
5190	hr = pContext->pDevice->CreateVertexDeclaration(&aVertexElements[0], &pContext->d3dState.pVertexDecl);
5191	AssertMsgReturn(hr == D3D_OK, ("CreateVertexDeclaration failed with %x\n", hr), VERR_INTERNAL_ERROR);
5192
5193	hr = pContext->pDevice->SetVertexDeclaration(pContext->d3dState.pVertexDecl);
5194	AssertMsgReturnStmt(hr == D3D_OK, ("SetVertexDeclaration failed with %x\n", hr),
5195	D3D_RELEASE(pContext->d3dState.pVertexDecl),
5196	VERR_INTERNAL_ERROR);
5197	}
5198
5199	/* Begin a scene before rendering anything. */
5200	hr = pContext->pDevice->BeginScene();
5201	AssertMsgReturn(hr == D3D_OK, ("BeginScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
5202
5203	/* Now draw the primitives. */
5204	for (uint32_t iPrimitive = 0; iPrimitive < numRanges; ++iPrimitive)
5205	{
5206	Log(("Primitive %d: type %s\n", iPrimitive, vmsvga3dPrimitiveType2String(pRange[iPrimitive].primType)));
5207
5208	const uint32_t sidIndex = pRange[iPrimitive].indexArray.surfaceId;
5209	PVMSVGA3DSURFACE pIndexSurface = NULL;
5210
5211	D3DPRIMITIVETYPE PrimitiveTypeD3D;
5212	rc = vmsvga3dPrimitiveType2D3D(pRange[iPrimitive].primType, &PrimitiveTypeD3D);
5213	AssertRCBreak(rc);
5214
5215	/* Triangle strips or fans with just one primitive don't make much sense and are identical to triangle lists.
5216	* Workaround for NVidia driver crash when encountering some of these.
5217	*/
5218	if ( pRange[iPrimitive].primitiveCount == 1
5219	&& ( PrimitiveTypeD3D == D3DPT_TRIANGLESTRIP
5220	\|\| PrimitiveTypeD3D == D3DPT_TRIANGLEFAN))
5221	PrimitiveTypeD3D = D3DPT_TRIANGLELIST;
5222
5223	if (sidIndex != SVGA3D_INVALID_ID)
5224	{
5225	AssertMsg(pRange[iPrimitive].indexWidth == sizeof(uint32_t) \|\| pRange[iPrimitive].indexWidth == sizeof(uint16_t),
5226	("Unsupported primitive width %d\n", pRange[iPrimitive].indexWidth));
5227
5228	rc = vmsvga3dSurfaceFromSid(pState, sidIndex, &pIndexSurface);
5229	AssertRCBreak(rc);
5230
5231	aIndexSurfaces[iPrimitive] = pIndexSurface;
5232
5233	Log(("vmsvga3dDrawPrimitives: index sid=%u\n", sidIndex));
5234
5235	rc = vmsvga3dDrawPrimitivesSyncIndexBuffer(pContext, pIndexSurface, pRange[iPrimitive].indexWidth);
5236	AssertRCBreak(rc);
5237
5238	hr = pContext->pDevice->SetIndices(pIndexSurface->u.pIndexBuffer);
5239	AssertMsg(hr == D3D_OK, ("SetIndices vertex failed with %x\n", hr));
5240	}
5241	else
5242	{
5243	hr = pContext->pDevice->SetIndices(NULL);
5244	AssertMsg(hr == D3D_OK, ("SetIndices vertex (NULL) failed with %x\n", hr));
5245	}
5246
5247	const uint32_t strideVertex = pVertexDecl[0].array.stride;
5248
5249	if (!pIndexSurface)
5250	{
5251	/* Render without an index buffer */
5252	Log(("DrawPrimitive %x primitivecount=%d index index bias=%d stride=%d\n",
5253	PrimitiveTypeD3D, pRange[iPrimitive].primitiveCount, pRange[iPrimitive].indexBias, strideVertex));
5254
5255	hr = pContext->pDevice->DrawPrimitive(PrimitiveTypeD3D,
5256	pRange[iPrimitive].indexBias,
5257	pRange[iPrimitive].primitiveCount);
5258	AssertMsgBreakStmt(hr == D3D_OK, ("DrawPrimitive failed with %x\n", hr), rc = VERR_INTERNAL_ERROR);
5259	}
5260	else
5261	{
5262	UINT numVertices;
5263	if (pVertexDecl[0].rangeHint.last)
5264	{
5265	/* Both SVGA3dArrayRangeHint definition and the SVGA driver code imply that 'last' is exclusive,
5266	* hence compute the difference.
5267	*/
5268	numVertices = pVertexDecl[0].rangeHint.last - pVertexDecl[0].rangeHint.first;
5269	}
5270	else
5271	{
5272	/* Range hint is not provided. */
5273	PVMSVGA3DSURFACE pVertexSurface = aVertexSurfaces[0];
5274	numVertices = pVertexSurface->paMipmapLevels[0].cbSurface / strideVertex
5275	- pVertexDecl[0].array.offset / strideVertex
5276	- pVertexDecl[0].rangeHint.first
5277	- pRange[iPrimitive].indexBias;
5278	}
5279
5280	/* Render with an index buffer */
5281	Log(("DrawIndexedPrimitive %x startindex=%d numVertices=%d, primitivecount=%d index format=%s index bias=%d stride=%d\n",
5282	PrimitiveTypeD3D, pVertexDecl[0].rangeHint.first, numVertices, pRange[iPrimitive].primitiveCount,
5283	(pRange[iPrimitive].indexWidth == sizeof(uint16_t)) ? "D3DFMT_INDEX16" : "D3DFMT_INDEX32",
5284	pRange[iPrimitive].indexBias, strideVertex));
5285
5286	hr = pContext->pDevice->DrawIndexedPrimitive(PrimitiveTypeD3D,
5287	pRange[iPrimitive].indexBias, /* BaseVertexIndex */
5288	0, /* MinVertexIndex */
5289	numVertices,
5290	pRange[iPrimitive].indexArray.offset / pRange[iPrimitive].indexWidth, /* StartIndex */
5291	pRange[iPrimitive].primitiveCount);
5292	AssertMsgBreakStmt(hr == D3D_OK, ("DrawIndexedPrimitive failed with %x\n", hr), rc = VERR_INTERNAL_ERROR);
5293	}
5294	}
5295
5296	/* End the scene and do some cleanup regardless of the rc. */
5297	hr = pContext->pDevice->EndScene();
5298	AssertMsgReturn(hr == D3D_OK, ("EndScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
5299
5300	/* Cleanup. */
5301	uint32_t i;
5302	/* Clear streams above 1 as they might accidentally be reused in the future. */
5303	for (i = 1; i < iCurrentStreamId; ++i)
5304	{
5305	LogFunc(("clear stream %d\n", i));
5306	HRESULT hr2 = pContext->pDevice->SetStreamSource(i, NULL, 0, 0);
5307	AssertMsg(hr2 == D3D_OK, ("SetStreamSource(%d, NULL) failed with %x\n", i, hr2)); RT_NOREF(hr2);
5308	}
5309
5310	if (cVertexDivisor)
5311	{
5312	/* "When you are finished rendering the instance data, be sure to reset the vertex stream frequency back..." */
5313	for (i = 0; i < iCurrentStreamId; ++i)
5314	{
5315	LogFunc(("reset stream freq %d\n", i));
5316	HRESULT hr2 = pContext->pDevice->SetStreamSourceFreq(i, 1);
5317	AssertMsg(hr2 == D3D_OK, ("SetStreamSourceFreq(%d, 1) failed with %x\n", i, hr2)); RT_NOREF(hr2);
5318	}
5319	}
5320
5321	if (RT_SUCCESS(rc))
5322	{
5323	for (i = 0; i < numVertexDecls; ++i)
5324	{
5325	if (aVertexSurfaces[i])
5326	{
5327	aVertexSurfaces[i]->paMipmapLevels[0].fDirty = false;
5328	aVertexSurfaces[i]->fDirty = false;
5329	}
5330	}
5331
5332	for (i = 0; i < numRanges; ++i)
5333	{
5334	if (aIndexSurfaces[i])
5335	{
5336	aIndexSurfaces[i]->paMipmapLevels[0].fDirty = false;
5337	aIndexSurfaces[i]->fDirty = false;
5338	}
5339	}
5340
5341	/* Make sure we can track drawing usage of active render targets and textures. */
5342	vmsvga3dContextTrackUsage(pThisCC, pContext);
5343	}
5344
5345	#if 0
5346	/* Dump render target to a bitmap. */
5347	if (pContext->state.aRenderTargets[SVGA3D_RT_COLOR0] != SVGA3D_INVALID_ID)
5348	{
5349	vmsvga3dUpdateHeapBuffersForSurfaces(pThisCC, pContext->state.aRenderTargets[SVGA3D_RT_COLOR0]);
5350	PVMSVGA3DSURFACE pSurface;
5351	int rc2 = vmsvga3dSurfaceFromSid(pState, pContext->state.aRenderTargets[SVGA3D_RT_COLOR0], &pSurface);
5352	if (RT_SUCCESS(rc2))
5353	vmsvga3dInfoSurfaceToBitmap(NULL, pSurface, "bmpd3d", "rt", "-post");
5354	# if 0
5355	/* Stage 0 texture. */
5356	if (pContext->aSidActiveTextures[0] != SVGA3D_INVALID_ID)
5357	{
5358	vmsvga3dUpdateHeapBuffersForSurfaces(pThisCC, pContext->aSidActiveTextures[0]);
5359	rc2 = vmsvga3dSurfaceFromSid(pState, pContext->aSidActiveTextures[0], &pSurface);
5360	if (RT_SUCCESS(rc2))
5361	vmsvga3dInfoSurfaceToBitmap(NULL, pSurface, "bmpd3d", "rt", "-post-tx");
5362	}
5363	# endif
5364	}
5365	#endif
5366
5367	return rc;
5368	}
5369
5370
5371	int vmsvga3dSetScissorRect(PVGASTATECC pThisCC, uint32_t cid, SVGA3dRect *pRect)
5372	{
5373	HRESULT hr;
5374	RECT rect;
5375	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5376	AssertReturn(pState, VERR_NO_MEMORY);
5377
5378	Log(("vmsvga3dSetScissorRect %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
5379
5380	PVMSVGA3DCONTEXT pContext;
5381	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5382	AssertRCReturn(rc, rc);
5383
5384	/* Store for vm state save/restore. */
5385	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_SCISSORRECT;
5386	pContext->state.RectScissor = *pRect;
5387
5388	rect.left = pRect->x;
5389	rect.top = pRect->y;
5390	rect.right = rect.left + pRect->w; /* exclusive */
5391	rect.bottom = rect.top + pRect->h; /* exclusive */
5392
5393	hr = pContext->pDevice->SetScissorRect(&rect);
5394	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetScissorRect: SetScissorRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
5395
5396	return VINF_SUCCESS;
5397	}
5398
5399
5400	int vmsvga3dShaderDefine(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type,
5401	uint32_t cbData, uint32_t *pShaderData)
5402	{
5403	HRESULT hr;
5404	PVMSVGA3DSHADER pShader;
5405	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5406	AssertReturn(pState, VERR_NO_MEMORY);
5407
5408	Log(("vmsvga3dShaderDefine %x shid=%x type=%s cbData=%x\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cbData));
5409	#ifdef LOG_ENABLED
5410	Log3(("Shader code:\n"));
5411	const uint32_t cTokensPerLine = 8;
5412	const uint32_t paTokens = (uint32_t )pShaderData;
5413	const uint32_t cTokens = cbData / sizeof(uint32_t);
5414	for (uint32_t iToken = 0; iToken < cTokens; ++iToken)
5415	{
5416	if ((iToken % cTokensPerLine) == 0)
5417	{
5418	if (iToken == 0)
5419	Log3(("0x%08X,", paTokens[iToken]));
5420	else
5421	Log3(("\n0x%08X,", paTokens[iToken]));
5422	}
5423	else
5424	Log3((" 0x%08X,", paTokens[iToken]));
5425	}
5426	Log3(("\n"));
5427	#endif
5428
5429	PVMSVGA3DCONTEXT pContext;
5430	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5431	AssertRCReturn(rc, rc);
5432
5433	AssertReturn(shid < SVGA3D_MAX_SHADER_IDS, VERR_INVALID_PARAMETER);
5434	if (type == SVGA3D_SHADERTYPE_VS)
5435	{
5436	if (shid >= pContext->cVertexShaders)
5437	{
5438	void pvNew = RTMemRealloc(pContext->paVertexShader, sizeof(VMSVGA3DSHADER) (shid + 1));
5439	AssertReturn(pvNew, VERR_NO_MEMORY);
5440	pContext->paVertexShader = (PVMSVGA3DSHADER)pvNew;
5441	memset(&pContext->paVertexShader[pContext->cVertexShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cVertexShaders));
5442	for (uint32_t i = pContext->cVertexShaders; i < shid + 1; i++)
5443	pContext->paVertexShader[i].id = SVGA3D_INVALID_ID;
5444	pContext->cVertexShaders = shid + 1;
5445	}
5446	/* If one already exists with this id, then destroy it now. */
5447	if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
5448	vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paVertexShader[shid].type);
5449
5450	pShader = &pContext->paVertexShader[shid];
5451	}
5452	else
5453	{
5454	Assert(type == SVGA3D_SHADERTYPE_PS);
5455	if (shid >= pContext->cPixelShaders)
5456	{
5457	void pvNew = RTMemRealloc(pContext->paPixelShader, sizeof(VMSVGA3DSHADER) (shid + 1));
5458	AssertReturn(pvNew, VERR_NO_MEMORY);
5459	pContext->paPixelShader = (PVMSVGA3DSHADER)pvNew;
5460	memset(&pContext->paPixelShader[pContext->cPixelShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cPixelShaders));
5461	for (uint32_t i = pContext->cPixelShaders; i < shid + 1; i++)
5462	pContext->paPixelShader[i].id = SVGA3D_INVALID_ID;
5463	pContext->cPixelShaders = shid + 1;
5464	}
5465	/* If one already exists with this id, then destroy it now. */
5466	if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
5467	vmsvga3dShaderDestroy(pThisCC, cid, shid, pContext->paPixelShader[shid].type);
5468
5469	pShader = &pContext->paPixelShader[shid];
5470	}
5471
5472	memset(pShader, 0, sizeof(*pShader));
5473	pShader->id = shid;
5474	pShader->cid = cid;
5475	pShader->type = type;
5476	pShader->cbData = cbData;
5477	pShader->pShaderProgram = RTMemAllocZ(cbData);
5478	AssertReturn(pShader->pShaderProgram, VERR_NO_MEMORY);
5479	memcpy(pShader->pShaderProgram, pShaderData, cbData);
5480
5481	#ifdef DUMP_SHADER_DISASSEMBLY
5482	LPD3DXBUFFER pDisassembly;
5483	hr = D3DXDisassembleShader((const DWORD *)pShaderData, FALSE, NULL, &pDisassembly);
5484	if (hr == D3D_OK)
5485	{
5486	Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
5487	D3D_RELEASE(pDisassembly);
5488	}
5489	#endif
5490
5491	switch (type)
5492	{
5493	case SVGA3D_SHADERTYPE_VS:
5494	hr = pContext->pDevice->CreateVertexShader((const DWORD *)pShaderData, &pShader->u.pVertexShader);
5495	break;
5496
5497	case SVGA3D_SHADERTYPE_PS:
5498	hr = pContext->pDevice->CreatePixelShader((const DWORD *)pShaderData, &pShader->u.pPixelShader);
5499	break;
5500
5501	default:
5502	AssertFailedReturn(VERR_INVALID_PARAMETER);
5503	}
5504	if (hr != D3D_OK)
5505	{
5506	/* Dump the shader code. */
5507	static int scLogged = 0;
5508	if (scLogged < 8)
5509	{
5510	++scLogged;
5511
5512	LogRel(("VMSVGA: Failed to create %s shader:\n", (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
5513	const uint32_t cTokensPerLine = 8;
5514	const uint32_t paTokens = (uint32_t )pShaderData;
5515	const uint32_t cTokens = cbData / sizeof(uint32_t);
5516	for (uint32_t iToken = 0; iToken < cTokens; ++iToken)
5517	{
5518	if ((iToken % cTokensPerLine) == 0)
5519	{
5520	if (iToken == 0)
5521	LogRel(("0x%08X,", paTokens[iToken]));
5522	else
5523	LogRel(("\n0x%08X,", paTokens[iToken]));
5524	}
5525	else
5526	LogRel((" 0x%08X,", paTokens[iToken]));
5527	}
5528	LogRel(("\n"));
5529	}
5530
5531	RTMemFree(pShader->pShaderProgram);
5532	memset(pShader, 0, sizeof(*pShader));
5533	pShader->id = SVGA3D_INVALID_ID;
5534	}
5535
5536	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderDefine: CreateVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5537	return VINF_SUCCESS;
5538	}
5539
5540	int vmsvga3dShaderDestroy(PVGASTATECC pThisCC, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
5541	{
5542	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5543	AssertReturn(pState, VERR_NO_MEMORY);
5544	PVMSVGA3DSHADER pShader = NULL;
5545
5546	Log(("vmsvga3dShaderDestroy %x shid=%x type=%s\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
5547
5548	PVMSVGA3DCONTEXT pContext;
5549	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5550	AssertRCReturn(rc, rc);
5551
5552	if (type == SVGA3D_SHADERTYPE_VS)
5553	{
5554	if ( shid < pContext->cVertexShaders
5555	&& pContext->paVertexShader[shid].id == shid)
5556	{
5557	pShader = &pContext->paVertexShader[shid];
5558	D3D_RELEASE(pShader->u.pVertexShader);
5559	}
5560	}
5561	else
5562	{
5563	Assert(type == SVGA3D_SHADERTYPE_PS);
5564	if ( shid < pContext->cPixelShaders
5565	&& pContext->paPixelShader[shid].id == shid)
5566	{
5567	pShader = &pContext->paPixelShader[shid];
5568	D3D_RELEASE(pShader->u.pPixelShader);
5569	}
5570	}
5571
5572	if (pShader)
5573	{
5574	if (pShader->pShaderProgram)
5575	RTMemFree(pShader->pShaderProgram);
5576
5577	memset(pShader, 0, sizeof(*pShader));
5578	pShader->id = SVGA3D_INVALID_ID;
5579	}
5580	else
5581	AssertFailedReturn(VERR_INVALID_PARAMETER);
5582
5583	return VINF_SUCCESS;
5584	}
5585
5586	int vmsvga3dShaderSet(PVGASTATECC pThisCC, PVMSVGA3DCONTEXT pContext, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
5587	{
5588	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5589	AssertReturn(pState, VERR_NO_MEMORY);
5590	HRESULT hr;
5591
5592	Log(("vmsvga3dShaderSet %x type=%s shid=%d\n", cid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", shid));
5593
5594	NOREF(pContext);
5595	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5596	AssertRCReturn(rc, rc);
5597
5598	if (type == SVGA3D_SHADERTYPE_VS)
5599	{
5600	/* Save for vm state save/restore. */
5601	pContext->state.shidVertex = shid;
5602	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_VERTEXSHADER;
5603
5604	if ( shid < pContext->cVertexShaders
5605	&& pContext->paVertexShader[shid].id == shid)
5606	{
5607	PVMSVGA3DSHADER pShader = &pContext->paVertexShader[shid];
5608	Assert(type == pShader->type);
5609
5610	hr = pContext->pDevice->SetVertexShader(pShader->u.pVertexShader);
5611	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5612	}
5613	else
5614	if (shid == SVGA_ID_INVALID)
5615	{
5616	/* Unselect shader. */
5617	hr = pContext->pDevice->SetVertexShader(NULL);
5618	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5619	}
5620	else
5621	AssertFailedReturn(VERR_INVALID_PARAMETER);
5622	}
5623	else
5624	{
5625	/* Save for vm state save/restore. */
5626	pContext->state.shidPixel = shid;
5627	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_PIXELSHADER;
5628
5629	Assert(type == SVGA3D_SHADERTYPE_PS);
5630	if ( shid < pContext->cPixelShaders
5631	&& pContext->paPixelShader[shid].id == shid)
5632	{
5633	PVMSVGA3DSHADER pShader = &pContext->paPixelShader[shid];
5634	Assert(type == pShader->type);
5635
5636	hr = pContext->pDevice->SetPixelShader(pShader->u.pPixelShader);
5637	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5638	}
5639	else
5640	if (shid == SVGA_ID_INVALID)
5641	{
5642	/* Unselect shader. */
5643	hr = pContext->pDevice->SetPixelShader(NULL);
5644	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5645	}
5646	else
5647	AssertFailedReturn(VERR_INVALID_PARAMETER);
5648	}
5649
5650	return VINF_SUCCESS;
5651	}
5652
5653	int vmsvga3dShaderSetConst(PVGASTATECC pThisCC, uint32_t cid, uint32_t reg, SVGA3dShaderType type,
5654	SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
5655	{
5656	HRESULT hr;
5657	PVMSVGA3DSTATE pState = pThisCC->svga.p3dState;
5658	AssertReturn(pState, VERR_NO_MEMORY);
5659
5660	Log(("vmsvga3dShaderSetConst %x reg=%x type=%s ctype=%x\n", cid, reg, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", ctype));
5661
5662	PVMSVGA3DCONTEXT pContext;
5663	int rc = vmsvga3dContextFromCid(pState, cid, &pContext);
5664	AssertRCReturn(rc, rc);
5665
5666	for (uint32_t i = 0; i < cRegisters; i++)
5667	{
5668	#ifdef LOG_ENABLED
5669	switch (ctype)
5670	{
5671	case SVGA3D_CONST_TYPE_FLOAT:
5672	{
5673	float pValuesF = (float )pValues;
5674	Log(("ConstantF %d: value=" FLOAT_FMT_STR ", " FLOAT_FMT_STR ", " FLOAT_FMT_STR ", " FLOAT_FMT_STR "\n",
5675	reg + i, FLOAT_FMT_ARGS(pValuesF[i4 + 0]), FLOAT_FMT_ARGS(pValuesF[i4 + 1]), FLOAT_FMT_ARGS(pValuesF[i4 + 2]), FLOAT_FMT_ARGS(pValuesF[i4 + 3])));
5676	break;
5677	}
5678
5679	case SVGA3D_CONST_TYPE_INT:
5680	Log(("ConstantI %d: value=%d, %d, %d, %d\n", reg + i, pValues[i4 + 0], pValues[i4 + 1], pValues[i4 + 2], pValues[i4 + 3]));
5681	break;
5682
5683	case SVGA3D_CONST_TYPE_BOOL:
5684	Log(("ConstantB %d: value=%d, %d, %d, %d\n", reg + i, pValues[i4 + 0], pValues[i4 + 1], pValues[i4 + 2], pValues[i4 + 3]));
5685	break;
5686	}
5687	#endif
5688	vmsvga3dSaveShaderConst(pContext, reg + i, type, ctype, pValues[i4 + 0], pValues[i4 + 1], pValues[i4 + 2], pValues[i4 + 3]);
5689	}
5690
5691	switch (type)
5692	{
5693	case SVGA3D_SHADERTYPE_VS:
5694	switch (ctype)
5695	{
5696	case SVGA3D_CONST_TYPE_FLOAT:
5697	hr = pContext->pDevice->SetVertexShaderConstantF(reg, (const float *)pValues, cRegisters);
5698	break;
5699
5700	case SVGA3D_CONST_TYPE_INT:
5701	hr = pContext->pDevice->SetVertexShaderConstantI(reg, (const int *)pValues, cRegisters);
5702	break;
5703
5704	case SVGA3D_CONST_TYPE_BOOL:
5705	hr = pContext->pDevice->SetVertexShaderConstantB(reg, (const BOOL *)pValues, cRegisters);
5706	break;
5707
5708	default:
5709	AssertFailedReturn(VERR_INVALID_PARAMETER);
5710	}
5711	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSetConst: SetVertexShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5712	break;
5713
5714	case SVGA3D_SHADERTYPE_PS:
5715	switch (ctype)
5716	{
5717	case SVGA3D_CONST_TYPE_FLOAT:
5718	{
5719	hr = pContext->pDevice->SetPixelShaderConstantF(reg, (const float *)pValues, cRegisters);
5720	break;
5721	}
5722
5723	case SVGA3D_CONST_TYPE_INT:
5724	hr = pContext->pDevice->SetPixelShaderConstantI(reg, (const int *)pValues, cRegisters);
5725	break;
5726
5727	case SVGA3D_CONST_TYPE_BOOL:
5728	hr = pContext->pDevice->SetPixelShaderConstantB(reg, (const BOOL *)pValues, cRegisters);
5729	break;
5730
5731	default:
5732	AssertFailedReturn(VERR_INVALID_PARAMETER);
5733	}
5734	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSetConst: SetPixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5735	break;
5736
5737	default:
5738	AssertFailedReturn(VERR_INVALID_PARAMETER);
5739	}
5740	return VINF_SUCCESS;
5741	}
5742
5743	int vmsvga3dOcclusionQueryCreate(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
5744	{
5745	RT_NOREF(pState);
5746	HRESULT hr = pContext->pDevice->CreateQuery(D3DQUERYTYPE_OCCLUSION, &pContext->occlusion.pQuery);
5747	AssertMsgReturn(hr == D3D_OK, ("CreateQuery(D3DQUERYTYPE_OCCLUSION) failed with %x\n", hr), VERR_INTERNAL_ERROR);
5748	return VINF_SUCCESS;
5749	}
5750
5751	int vmsvga3dOcclusionQueryDelete(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
5752	{
5753	RT_NOREF(pState);
5754	D3D_RELEASE(pContext->occlusion.pQuery);
5755	return VINF_SUCCESS;
5756	}
5757
5758	int vmsvga3dOcclusionQueryBegin(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
5759	{
5760	RT_NOREF(pState);
5761	HRESULT hr = pContext->occlusion.pQuery->Issue(D3DISSUE_BEGIN);
5762	AssertMsgReturnStmt(hr == D3D_OK, ("D3DISSUE_BEGIN(D3DQUERYTYPE_OCCLUSION) failed with %x\n", hr),
5763	D3D_RELEASE(pContext->occlusion.pQuery), VERR_INTERNAL_ERROR);
5764	return VINF_SUCCESS;
5765	}
5766
5767	int vmsvga3dOcclusionQueryEnd(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext)
5768	{
5769	RT_NOREF(pState);
5770	HRESULT hr = pContext->occlusion.pQuery->Issue(D3DISSUE_END);
5771	AssertMsgReturnStmt(hr == D3D_OK, ("D3DISSUE_END(D3DQUERYTYPE_OCCLUSION) failed with %x\n", hr),
5772	D3D_RELEASE(pContext->occlusion.pQuery), VERR_INTERNAL_ERROR);
5773	return VINF_SUCCESS;
5774	}
5775
5776	int vmsvga3dOcclusionQueryGetData(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t *pu32Pixels)
5777	{
5778	RT_NOREF(pState);
5779	HRESULT hr = D3D_OK;
5780	/* Wait until the data becomes available. */
5781	DWORD dwPixels = 0;
5782	do
5783	{
5784	hr = pContext->occlusion.pQuery->GetData((void *)&dwPixels, sizeof(DWORD), D3DGETDATA_FLUSH);
5785	} while (hr == S_FALSE);
5786
5787	AssertMsgReturnStmt(hr == D3D_OK, ("GetData(D3DQUERYTYPE_OCCLUSION) failed with %x\n", hr),
5788	D3D_RELEASE(pContext->occlusion.pQuery), VERR_INTERNAL_ERROR);
5789
5790	LogFunc(("Query result: dwPixels %d\n", dwPixels));
5791	*pu32Pixels = dwPixels;
5792	return VINF_SUCCESS;
5793	}
5794
5795	static void vmsvgaDumpD3DCaps(D3DCAPS9 pCaps, D3DADAPTER_IDENTIFIER9 const pai9)
5796	{
5797	bool const fBufferingSaved = RTLogRelSetBuffering(true /fBuffered/);
5798
5799	LogRel(("\nD3D9 adapter: %s %RX16:%RX16 [%s, version %d.%d.%d.%d]\n",
5800	pai9->Description, pai9->VendorId, pai9->DeviceId, pai9->Driver,
5801	RT_HI_U16(pai9->DriverVersion.HighPart), RT_LO_U16(pai9->DriverVersion.HighPart),
5802	RT_HI_U16(pai9->DriverVersion.LowPart), RT_LO_U16(pai9->DriverVersion.LowPart)));
5803
5804	LogRel(("\nD3D device caps: DevCaps2:\n"));
5805	if (pCaps->DevCaps2 & D3DDEVCAPS2_ADAPTIVETESSRTPATCH)
5806	LogRel((" - D3DDEVCAPS2_ADAPTIVETESSRTPATCH\n"));
5807	if (pCaps->DevCaps2 & D3DDEVCAPS2_ADAPTIVETESSNPATCH)
5808	LogRel((" - D3DDEVCAPS2_ADAPTIVETESSNPATCH\n"));
5809	if (pCaps->DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES)
5810	LogRel((" - D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES\n"));
5811	if (pCaps->DevCaps2 & D3DDEVCAPS2_DMAPNPATCH)
5812	LogRel((" - D3DDEVCAPS2_DMAPNPATCH\n"));
5813	if (pCaps->DevCaps2 & D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH)
5814	LogRel((" - D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH\n"));
5815	if (pCaps->DevCaps2 & D3DDEVCAPS2_STREAMOFFSET)
5816	LogRel((" - D3DDEVCAPS2_STREAMOFFSET\n"));
5817	if (pCaps->DevCaps2 & D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET)
5818	LogRel((" - D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET\n"));
5819
5820	LogRel(("\nCaps2:\n"));
5821	if (pCaps->Caps2 & D3DCAPS2_CANAUTOGENMIPMAP)
5822	LogRel((" - D3DCAPS2_CANAUTOGENMIPMAP\n"));
5823	if (pCaps->Caps2 & D3DCAPS2_CANCALIBRATEGAMMA)
5824	LogRel((" - D3DCAPS2_CANCALIBRATEGAMMA\n"));
5825	if (pCaps->Caps2 & D3DCAPS2_CANSHARERESOURCE)
5826	LogRel((" - D3DCAPS2_CANSHARERESOURCE\n"));
5827	if (pCaps->Caps2 & D3DCAPS2_CANMANAGERESOURCE)
5828	LogRel((" - D3DCAPS2_CANMANAGERESOURCE\n"));
5829	if (pCaps->Caps2 & D3DCAPS2_DYNAMICTEXTURES)
5830	LogRel((" - D3DCAPS2_DYNAMICTEXTURES\n"));
5831	if (pCaps->Caps2 & D3DCAPS2_FULLSCREENGAMMA)
5832	LogRel((" - D3DCAPS2_FULLSCREENGAMMA\n"));
5833
5834	LogRel(("\nCaps3:\n"));
5835	if (pCaps->Caps3 & D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD)
5836	LogRel((" - D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD\n"));
5837	if (pCaps->Caps3 & D3DCAPS3_COPY_TO_VIDMEM)
5838	LogRel((" - D3DCAPS3_COPY_TO_VIDMEM\n"));
5839	if (pCaps->Caps3 & D3DCAPS3_COPY_TO_SYSTEMMEM)
5840	LogRel((" - D3DCAPS3_COPY_TO_SYSTEMMEM\n"));
5841	if (pCaps->Caps3 & D3DCAPS3_DXVAHD)
5842	LogRel((" - D3DCAPS3_DXVAHD\n"));
5843	if (pCaps->Caps3 & D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION)
5844	LogRel((" - D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION\n"));
5845
5846	LogRel(("\nPresentationIntervals:\n"));
5847	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
5848	LogRel((" - D3DPRESENT_INTERVAL_IMMEDIATE\n"));
5849	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_ONE)
5850	LogRel((" - D3DPRESENT_INTERVAL_ONE\n"));
5851	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_TWO)
5852	LogRel((" - D3DPRESENT_INTERVAL_TWO\n"));
5853	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_THREE)
5854	LogRel((" - D3DPRESENT_INTERVAL_THREE\n"));
5855	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)
5856	LogRel((" - D3DPRESENT_INTERVAL_FOUR\n"));
5857
5858	LogRel(("\nDevcaps:\n"));
5859	if (pCaps->DevCaps & D3DDEVCAPS_CANBLTSYSTONONLOCAL)
5860	LogRel((" - D3DDEVCAPS_CANBLTSYSTONONLOCAL\n"));
5861	if (pCaps->DevCaps & D3DDEVCAPS_CANRENDERAFTERFLIP)
5862	LogRel((" - D3DDEVCAPS_CANRENDERAFTERFLIP\n"));
5863	if (pCaps->DevCaps & D3DDEVCAPS_DRAWPRIMITIVES2)
5864	LogRel((" - D3DDEVCAPS_DRAWPRIMITIVES2\n"));
5865	if (pCaps->DevCaps & D3DDEVCAPS_DRAWPRIMITIVES2EX)
5866	LogRel((" - D3DDEVCAPS_DRAWPRIMITIVES2EX\n"));
5867	if (pCaps->DevCaps & D3DDEVCAPS_DRAWPRIMTLVERTEX)
5868	LogRel((" - D3DDEVCAPS_DRAWPRIMTLVERTEX\n"));
5869	if (pCaps->DevCaps & D3DDEVCAPS_EXECUTESYSTEMMEMORY)
5870	LogRel((" - D3DDEVCAPS_EXECUTESYSTEMMEMORY\n"));
5871	if (pCaps->DevCaps & D3DDEVCAPS_EXECUTEVIDEOMEMORY)
5872	LogRel((" - D3DDEVCAPS_EXECUTEVIDEOMEMORY\n"));
5873	if (pCaps->DevCaps & D3DDEVCAPS_HWRASTERIZATION)
5874	LogRel((" - D3DDEVCAPS_HWRASTERIZATION\n"));
5875	if (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
5876	LogRel((" - D3DDEVCAPS_HWTRANSFORMANDLIGHT\n"));
5877	if (pCaps->DevCaps & D3DDEVCAPS_NPATCHES)
5878	LogRel((" - D3DDEVCAPS_NPATCHES\n"));
5879	if (pCaps->DevCaps & D3DDEVCAPS_PUREDEVICE)
5880	LogRel((" - D3DDEVCAPS_PUREDEVICE\n"));
5881	if (pCaps->DevCaps & D3DDEVCAPS_QUINTICRTPATCHES)
5882	LogRel((" - D3DDEVCAPS_QUINTICRTPATCHES\n"));
5883	if (pCaps->DevCaps & D3DDEVCAPS_RTPATCHES)
5884	LogRel((" - D3DDEVCAPS_RTPATCHES\n"));
5885	if (pCaps->DevCaps & D3DDEVCAPS_RTPATCHHANDLEZERO)
5886	LogRel((" - D3DDEVCAPS_RTPATCHHANDLEZERO\n"));
5887	if (pCaps->DevCaps & D3DDEVCAPS_SEPARATETEXTUREMEMORIES)
5888	LogRel((" - D3DDEVCAPS_SEPARATETEXTUREMEMORIES\n"));
5889	if (pCaps->DevCaps & D3DDEVCAPS_TEXTURENONLOCALVIDMEM)
5890	LogRel((" - D3DDEVCAPS_TEXTURENONLOCALVIDMEM\n"));
5891	if (pCaps->DevCaps & D3DDEVCAPS_TEXTURESYSTEMMEMORY)
5892	LogRel((" - D3DDEVCAPS_TEXTURESYSTEMMEMORY\n"));
5893	if (pCaps->DevCaps & D3DDEVCAPS_TEXTUREVIDEOMEMORY)
5894	LogRel((" - D3DDEVCAPS_TEXTUREVIDEOMEMORY\n"));
5895	if (pCaps->DevCaps & D3DDEVCAPS_TLVERTEXSYSTEMMEMORY)
5896	LogRel((" - D3DDEVCAPS_TLVERTEXSYSTEMMEMORY\n"));
5897	if (pCaps->DevCaps & D3DDEVCAPS_TLVERTEXVIDEOMEMORY)
5898	LogRel((" - D3DDEVCAPS_TLVERTEXVIDEOMEMORY\n"));
5899
5900	LogRel(("\nTextureCaps:\n"));
5901	if (pCaps->TextureCaps & D3DPTEXTURECAPS_ALPHA)
5902	LogRel((" - D3DPTEXTURECAPS_ALPHA\n"));
5903	if (pCaps->TextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE)
5904	LogRel((" - D3DPTEXTURECAPS_ALPHAPALETTE\n"));
5905	if (pCaps->TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
5906	LogRel((" - D3DPTEXTURECAPS_CUBEMAP\n"));
5907	if (pCaps->TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2)
5908	LogRel((" - D3DPTEXTURECAPS_CUBEMAP_POW2\n"));
5909	if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP)
5910	LogRel((" - D3DPTEXTURECAPS_MIPCUBEMAP\n"));
5911	if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPMAP)
5912	LogRel((" - D3DPTEXTURECAPS_MIPMAP\n"));
5913	if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPVOLUMEMAP)
5914	LogRel((" - D3DPTEXTURECAPS_MIPVOLUMEMAP\n"));
5915	if (pCaps->TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL)
5916	LogRel((" - D3DPTEXTURECAPS_NONPOW2CONDITIONAL\n"));
5917	if (pCaps->TextureCaps & D3DPTEXTURECAPS_POW2)
5918	LogRel((" - D3DPTEXTURECAPS_POW2\n"));
5919	if (pCaps->TextureCaps & D3DPTEXTURECAPS_NOPROJECTEDBUMPENV)
5920	LogRel((" - D3DPTEXTURECAPS_NOPROJECTEDBUMPENV\n"));
5921	if (pCaps->TextureCaps & D3DPTEXTURECAPS_PERSPECTIVE)
5922	LogRel((" - D3DPTEXTURECAPS_PERSPECTIVE\n"));
5923	if (pCaps->TextureCaps & D3DPTEXTURECAPS_POW2)
5924	LogRel((" - D3DPTEXTURECAPS_POW2\n"));
5925	if (pCaps->TextureCaps & D3DPTEXTURECAPS_PROJECTED)
5926	LogRel((" - D3DPTEXTURECAPS_PROJECTED\n"));
5927	if (pCaps->TextureCaps & D3DPTEXTURECAPS_SQUAREONLY)
5928	LogRel((" - D3DPTEXTURECAPS_SQUAREONLY\n"));
5929	if (pCaps->TextureCaps & D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE)
5930	LogRel((" - D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE\n"));
5931	if (pCaps->TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)
5932	LogRel((" - D3DPTEXTURECAPS_VOLUMEMAP\n"));
5933	if (pCaps->TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP_POW2)
5934	LogRel((" - D3DPTEXTURECAPS_VOLUMEMAP_POW2\n"));
5935
5936	LogRel(("\nTextureFilterCaps\n"));
5937	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
5938	LogRel((" - D3DPTFILTERCAPS_CONVOLUTIONMONO\n"));
5939	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
5940	LogRel((" - D3DPTFILTERCAPS_MAGFPOINT\n"));
5941	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
5942	LogRel((" - D3DPTFILTERCAPS_MAGFLINEAR\n"));
5943	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
5944	LogRel((" - D3DPTFILTERCAPS_MAGFANISOTROPIC\n"));
5945	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
5946	LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
5947	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
5948	LogRel((" - D3DPTFILTERCAPS_MAGFGAUSSIANQUAD\n"));
5949	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
5950	LogRel((" - D3DPTFILTERCAPS_MINFPOINT\n"));
5951	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
5952	LogRel((" - D3DPTFILTERCAPS_MINFLINEAR\n"));
5953	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
5954	LogRel((" - D3DPTFILTERCAPS_MINFANISOTROPIC\n"));
5955	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
5956	LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
5957	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
5958	LogRel((" - D3DPTFILTERCAPS_MINFGAUSSIANQUAD\n"));
5959	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
5960	LogRel((" - D3DPTFILTERCAPS_MIPFPOINT\n"));
5961	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
5962	LogRel((" - D3DPTFILTERCAPS_MIPFLINEAR\n"));
5963
5964	LogRel(("\nCubeTextureFilterCaps\n"));
5965	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
5966	LogRel((" - D3DPTFILTERCAPS_CONVOLUTIONMONO\n"));
5967	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
5968	LogRel((" - D3DPTFILTERCAPS_MAGFPOINT\n"));
5969	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
5970	LogRel((" - D3DPTFILTERCAPS_MAGFLINEAR\n"));
5971	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
5972	LogRel((" - D3DPTFILTERCAPS_MAGFANISOTROPIC\n"));
5973	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
5974	LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
5975	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
5976	LogRel((" - D3DPTFILTERCAPS_MAGFGAUSSIANQUAD\n"));
5977	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
5978	LogRel((" - D3DPTFILTERCAPS_MINFPOINT\n"));
5979	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
5980	LogRel((" - D3DPTFILTERCAPS_MINFLINEAR\n"));
5981	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
5982	LogRel((" - D3DPTFILTERCAPS_MINFANISOTROPIC\n"));
5983	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
5984	LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
5985	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
5986	LogRel((" - D3DPTFILTERCAPS_MINFGAUSSIANQUAD\n"));
5987	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
5988	LogRel((" - D3DPTFILTERCAPS_MIPFPOINT\n"));
5989	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
5990	LogRel((" - D3DPTFILTERCAPS_MIPFLINEAR\n"));
5991
5992	LogRel(("\nVolumeTextureFilterCaps\n"));
5993	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
5994	LogRel((" - D3DPTFILTERCAPS_CONVOLUTIONMONO\n"));
5995	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
5996	LogRel((" - D3DPTFILTERCAPS_MAGFPOINT\n"));
5997	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
5998	LogRel((" - D3DPTFILTERCAPS_MAGFLINEAR\n"));
5999	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
6000	LogRel((" - D3DPTFILTERCAPS_MAGFANISOTROPIC\n"));
6001	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
6002	LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
6003	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
6004	LogRel((" - D3DPTFILTERCAPS_MAGFGAUSSIANQUAD\n"));
6005	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
6006	LogRel((" - D3DPTFILTERCAPS_MINFPOINT\n"));
6007	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
6008	LogRel((" - D3DPTFILTERCAPS_MINFLINEAR\n"));
6009	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
6010	LogRel((" - D3DPTFILTERCAPS_MINFANISOTROPIC\n"));
6011	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
6012	LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
6013	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
6014	LogRel((" - D3DPTFILTERCAPS_MINFGAUSSIANQUAD\n"));
6015	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
6016	LogRel((" - D3DPTFILTERCAPS_MIPFPOINT\n"));
6017	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
6018	LogRel((" - D3DPTFILTERCAPS_MIPFLINEAR\n"));
6019
6020	LogRel(("\nTextureAddressCaps:\n"));
6021	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_BORDER)
6022	LogRel((" - D3DPTADDRESSCAPS_BORDER\n"));
6023	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_CLAMP)
6024	LogRel((" - D3DPTADDRESSCAPS_CLAMP\n"));
6025	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_INDEPENDENTUV)
6026	LogRel((" - D3DPTADDRESSCAPS_INDEPENDENTUV\n"));
6027	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_MIRROR)
6028	LogRel((" - D3DPTADDRESSCAPS_MIRROR\n"));
6029	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_MIRRORONCE)
6030	LogRel((" - D3DPTADDRESSCAPS_MIRRORONCE\n"));
6031	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_WRAP)
6032	LogRel((" - D3DPTADDRESSCAPS_WRAP\n"));
6033
6034	LogRel(("\nTextureOpCaps:\n"));
6035	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_DISABLE)
6036	LogRel((" - D3DTEXOPCAPS_DISABLE\n"));
6037	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SELECTARG1)
6038	LogRel((" - D3DTEXOPCAPS_SELECTARG1\n"));
6039	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SELECTARG2)
6040	LogRel((" - D3DTEXOPCAPS_SELECTARG2\n"));
6041	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE)
6042	LogRel((" - D3DTEXOPCAPS_MODULATE\n"));
6043	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE2X)
6044	LogRel((" - D3DTEXOPCAPS_MODULATE2X\n"));
6045	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE4X)
6046	LogRel((" - D3DTEXOPCAPS_MODULATE4X\n"));
6047	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADD)
6048	LogRel((" - D3DTEXOPCAPS_ADD\n"));
6049	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADDSIGNED)
6050	LogRel((" - D3DTEXOPCAPS_ADDSIGNED\n"));
6051	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADDSIGNED2X)
6052	LogRel((" - D3DTEXOPCAPS_ADDSIGNED2X\n"));
6053	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SUBTRACT)
6054	LogRel((" - D3DTEXOPCAPS_SUBTRACT\n"));
6055	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADDSMOOTH)
6056	LogRel((" - D3DTEXOPCAPS_ADDSMOOTH\n"));
6057	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDDIFFUSEALPHA)
6058	LogRel((" - D3DTEXOPCAPS_BLENDDIFFUSEALPHA\n"));
6059	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDTEXTUREALPHA)
6060	LogRel((" - D3DTEXOPCAPS_BLENDTEXTUREALPHA\n"));
6061	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDFACTORALPHA)
6062	LogRel((" - D3DTEXOPCAPS_BLENDFACTORALPHA\n"));
6063	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDTEXTUREALPHAPM)
6064	LogRel((" - D3DTEXOPCAPS_BLENDTEXTUREALPHAPM\n"));
6065	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDCURRENTALPHA)
6066	LogRel((" - D3DTEXOPCAPS_BLENDCURRENTALPHA\n"));
6067	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_PREMODULATE)
6068	LogRel((" - D3DTEXOPCAPS_PREMODULATE\n"));
6069	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR)
6070	LogRel((" - D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR\n"));
6071	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA)
6072	LogRel((" - D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA\n"));
6073	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR)
6074	LogRel((" - D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR\n"));
6075	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA)
6076	LogRel((" - D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA\n"));
6077	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP)
6078	LogRel((" - D3DTEXOPCAPS_BUMPENVMAP\n"));
6079	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAPLUMINANCE)
6080	LogRel((" - D3DTEXOPCAPS_BUMPENVMAPLUMINANCE\n"));
6081	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)
6082	LogRel((" - D3DTEXOPCAPS_DOTPRODUCT3\n"));
6083	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MULTIPLYADD)
6084	LogRel((" - D3DTEXOPCAPS_MULTIPLYADD\n"));
6085	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_LERP)
6086	LogRel((" - D3DTEXOPCAPS_LERP\n"));
6087
6088
6089	LogRel(("\n"));
6090	LogRel(("PixelShaderVersion: %#x (%u.%u)\n", pCaps->PixelShaderVersion,
6091	D3DSHADER_VERSION_MAJOR(pCaps->PixelShaderVersion), D3DSHADER_VERSION_MINOR(pCaps->PixelShaderVersion)));
6092	LogRel(("VertexShaderVersion: %#x (%u.%u)\n", pCaps->VertexShaderVersion,
6093	D3DSHADER_VERSION_MAJOR(pCaps->VertexShaderVersion), D3DSHADER_VERSION_MINOR(pCaps->VertexShaderVersion)));
6094
6095	LogRel(("\n"));
6096	RTLogRelSetBuffering(fBufferingSaved);
6097	}
6098

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA-SVGA3d-win.cpp@ 82609

Download in other formats: