DevVGA-SVGA3d-win.cpp@ 60016

Last change on this file since 60016 was 60016, checked in by vboxsync, 9 years ago
Graphics/DevVGA-SVGA3d-win: typo (thanks PVS)
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 231.6 KB

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

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

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

Download in other formats: