DevVGA-SVGA3d-win.cpp@ 54532

Last change on this file since 54532 was 53780, checked in by vboxsync, 10 years ago
logging adjustments
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 254.4 KB

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

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

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

Download in other formats: