DevVGA-SVGA3d-win.cpp@ 53752

Last change on this file since 53752 was 53749, checked in by vboxsync, 10 years ago
Use a context configured with the legacy OpenGL profile for getting information not available when using the OpenGL32Core profile.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 253.7 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, uint32_t cCopyBoxes, SVGA3dCopyBox *pBoxes)
2308	{
2309	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
2310	PVMSVGA3DSURFACE pSurface;
2311	PVMSVGA3DMIPMAPLEVEL pMipLevel;
2312	uint32_t sid = host.sid;
2313	int rc = VINF_SUCCESS;
2314
2315	AssertReturn(pState, VERR_NO_MEMORY);
2316	AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
2317	AssertReturn(sid < pState->cSurfaces && pState->paSurface[sid].id == sid, VERR_INVALID_PARAMETER);
2318
2319	pSurface = &pState->paSurface[sid];
2320	AssertReturn(pSurface->faces[0].numMipLevels > host.mipmap, VERR_INVALID_PARAMETER);
2321	pMipLevel = &pSurface->pMipmapLevels[host.mipmap];
2322
2323	if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
2324	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));
2325	else
2326	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));
2327
2328	if (!pSurface->u.pSurface)
2329	{
2330	AssertReturn(pSurface->pMipmapLevels[host.mipmap].pSurfaceData, VERR_INTERNAL_ERROR);
2331
2332	for (unsigned i = 0; i < cCopyBoxes; i++)
2333	{
2334	unsigned uDestOffset;
2335	unsigned cbSrcPitch;
2336
2337	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));
2338	/* Apparently we're supposed to clip it (gmr test sample) */
2339	if (pBoxes[i].x + pBoxes[i].w > pMipLevel->size.width)
2340	pBoxes[i].w = pMipLevel->size.width - pBoxes[i].x;
2341	if (pBoxes[i].y + pBoxes[i].h > pMipLevel->size.height)
2342	pBoxes[i].h = pMipLevel->size.height - pBoxes[i].y;
2343	if (pBoxes[i].z + pBoxes[i].d > pMipLevel->size.depth)
2344	pBoxes[i].d = pMipLevel->size.depth - pBoxes[i].z;
2345
2346	if ( !pBoxes[i].w
2347	\|\| !pBoxes[i].h
2348	\|\| !pBoxes[i].d
2349	\|\| pBoxes[i].x > pMipLevel->size.width
2350	\|\| pBoxes[i].y > pMipLevel->size.height
2351	\|\| pBoxes[i].z > pMipLevel->size.depth)
2352	{
2353	Log(("Empty box; skip\n"));
2354	continue;
2355	}
2356
2357	uDestOffset = pBoxes[i].x * pSurface->cbBlock + pBoxes[i].y * pMipLevel->cbSurfacePitch + pBoxes[i].z * pMipLevel->size.height * pMipLevel->cbSurfacePitch;
2358	AssertReturn(uDestOffset + pBoxes[i].w * pSurface->cbBlock * pBoxes[i].h * pBoxes[i].d <= pMipLevel->cbSurface, VERR_INTERNAL_ERROR);
2359
2360	cbSrcPitch = (guest.pitch == 0) ? pBoxes[i].w * pSurface->cbBlock : guest.pitch;
2361
2362	rc = vmsvgaGMRTransfer(pThis,
2363	transfer,
2364	(uint8_t *)pMipLevel->pSurfaceData + uDestOffset,
2365	pMipLevel->cbSurfacePitch,
2366	guest.ptr,
2367	pBoxes[i].srcx * pSurface->cbBlock + (pBoxes[i].srcy + pBoxes[i].srcz * pBoxes[i].h) * cbSrcPitch,
2368	cbSrcPitch,
2369	pBoxes[i].w * pSurface->cbBlock,
2370	pBoxes[i].d * pBoxes[i].h);
2371
2372	Log4(("first line:\n%.*Rhxd\n", pMipLevel->cbSurfacePitch, pMipLevel->pSurfaceData));
2373
2374	AssertRC(rc);
2375	}
2376	pSurface->pMipmapLevels[host.mipmap].fDirty = true;
2377	pSurface->fDirty = true;
2378	}
2379	else
2380	{
2381	HRESULT hr = D3D_OK;
2382	DWORD dwFlags = 0;
2383
2384	/* Flush the drawing pipeline for this surface as it could be used in a shared context. */
2385	vmsvga3dSurfaceFlush(pThis, pSurface);
2386
2387	if (transfer == SVGA3D_READ_HOST_VRAM)
2388	dwFlags \|= D3DLOCK_READONLY;
2389
2390	for (unsigned i = 0; i < cCopyBoxes; i++)
2391	{
2392	bool fTexture = false;
2393	bool fVertex = false;
2394	bool fRenderTargetTexture = false;
2395	unsigned cbSrcPitch;
2396
2397	/* Apparently we're supposed to clip it (gmr test sample) */
2398	if (pBoxes[i].x + pBoxes[i].w > pMipLevel->size.width)
2399	pBoxes[i].w = pMipLevel->size.width - pBoxes[i].x;
2400	if (pBoxes[i].y + pBoxes[i].h > pMipLevel->size.height)
2401	pBoxes[i].h = pMipLevel->size.height - pBoxes[i].y;
2402	if (pBoxes[i].z + pBoxes[i].d > pMipLevel->size.depth)
2403	pBoxes[i].d = pMipLevel->size.depth - pBoxes[i].z;
2404
2405	Assert((pBoxes[i].d == 1 \|\| pBoxes[i].d == 0) && pBoxes[i].z == 0);
2406
2407	if ( !pBoxes[i].w
2408	\|\| !pBoxes[i].h
2409	\|\| pBoxes[i].x > pMipLevel->size.width
2410	\|\| pBoxes[i].y > pMipLevel->size.height)
2411	{
2412	Log(("Empty box; skip\n"));
2413	continue;
2414	}
2415
2416	cbSrcPitch = (guest.pitch == 0) ? pBoxes[i].w * pSurface->cbBlock : guest.pitch;
2417
2418	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))
2419	{
2420	case SVGA3D_SURFACE_HINT_TEXTURE \| SVGA3D_SURFACE_HINT_RENDERTARGET:
2421	fRenderTargetTexture = true;
2422	/* no break */
2423	case SVGA3D_SURFACE_HINT_TEXTURE:
2424	fTexture = true;
2425	/* no break */
2426	case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
2427	if (pSurface->fStencilAsTexture)
2428	fTexture = true;
2429	/* no break */
2430	case SVGA3D_SURFACE_HINT_RENDERTARGET:
2431	{
2432	D3DLOCKED_RECT LockedRect;
2433	RECT Rect;
2434
2435	Rect.left = pBoxes[i].x;
2436	Rect.top = pBoxes[i].y;
2437	Rect.right = pBoxes[i].x + pBoxes[i].w; /* exclusive */
2438	Rect.bottom = pBoxes[i].y + pBoxes[i].h; /* exclusive */
2439
2440	/* @todo inefficient for VRAM buffers!! */
2441	if (fTexture)
2442	{
2443	if (pSurface->bounce.pTexture)
2444	{
2445	if ( transfer == SVGA3D_READ_HOST_VRAM
2446	&& fRenderTargetTexture
2447	&& i == 0 /* only the first time */)
2448	{
2449	IDirect3DSurface9 pSrc, pDest;
2450
2451	/* @todo stricter checks for associated context */
2452	uint32_t cid = pSurface->idAssociatedContext;
2453	if ( cid >= pState->cContexts
2454	\|\| pState->paContext[cid].id != cid)
2455	{
2456	Log(("vmsvga3dSurfaceDMA invalid context id (%x - %x)!\n", cid, (cid >= pState->cContexts) ? -1 : pState->paContext[cid].id));
2457	AssertFailedReturn(VERR_INVALID_PARAMETER);
2458	}
2459	PVMSVGA3DCONTEXT pContext = &pState->paContext[cid];
2460
2461	/* @todo only sync when something was actually rendered (since the last sync) */
2462	Log(("vmsvga3dSurfaceDMA: sync bounce buffer\n"));
2463	hr = pSurface->bounce.pTexture->GetSurfaceLevel(host.mipmap, &pDest);
2464	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
2465
2466	hr = pSurface->u.pTexture->GetSurfaceLevel(host.mipmap, &pSrc);
2467	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
2468
2469	hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
2470	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
2471
2472	pSrc->Release();
2473	pDest->Release();
2474	}
2475
2476	hr = pSurface->bounce.pTexture->LockRect(host.mipmap, /* texture level */
2477	&LockedRect,
2478	&Rect,
2479	dwFlags);
2480	}
2481	else
2482	hr = pSurface->u.pTexture->LockRect(host.mipmap, /* texture level */
2483	&LockedRect,
2484	&Rect,
2485	dwFlags);
2486	}
2487	else
2488	hr = pSurface->u.pSurface->LockRect(&LockedRect,
2489	&Rect,
2490	dwFlags);
2491	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2492
2493	if (fTexture)
2494	Log(("Lock TEXTURE (bounce=%d) memory for rectangle (%d,%d)(%d,%d)\n", !!(pSurface->bounce.pTexture), Rect.left, Rect.top, Rect.right, Rect.bottom));
2495	else
2496	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));
2497
2498	rc = vmsvgaGMRTransfer(pThis,
2499	transfer,
2500	(uint8_t *)LockedRect.pBits,
2501	LockedRect.Pitch,
2502	guest.ptr,
2503	pBoxes[i].srcx * pSurface->cbBlock + pBoxes[i].srcy * cbSrcPitch,
2504	cbSrcPitch,
2505	pBoxes[i].w * pSurface->cbBlock,
2506	pBoxes[i].h);
2507	AssertRC(rc);
2508
2509	Log4(("first line:\n%.Rhxd\n", pBoxes[i].w pSurface->cbBlock, LockedRect.pBits));
2510
2511	if (fTexture)
2512	{
2513	if (pSurface->bounce.pTexture)
2514	{
2515	hr = pSurface->bounce.pTexture->UnlockRect(host.mipmap);
2516	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2517
2518	if (transfer == SVGA3D_WRITE_HOST_VRAM)
2519	{
2520	/* @todo stricter checks for associated context */
2521	uint32_t cid = pSurface->idAssociatedContext;
2522	if ( cid >= pState->cContexts
2523	\|\| pState->paContext[cid].id != cid)
2524	{
2525	Log(("vmsvga3dSurfaceDMA invalid context id!\n"));
2526	AssertFailedReturn(VERR_INVALID_PARAMETER);
2527	}
2528	PVMSVGA3DCONTEXT pContext = &pState->paContext[cid];
2529
2530	Log(("vmsvga3dSurfaceDMA: sync texture from bounce buffer\n"));
2531
2532	/* Copy the new contents to the actual texture object. */
2533	hr = pContext->pDevice->UpdateTexture(pSurface->bounce.pTexture, pSurface->u.pTexture);
2534	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UpdateTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
2535
2536	/* Track the copy operation. */
2537	vmsvga3dSurfaceTrackUsage(pThis, pContext, pSurface->id);
2538	}
2539	}
2540	else
2541	hr = pSurface->u.pTexture->UnlockRect(host.mipmap);
2542	}
2543	else
2544	hr = pSurface->u.pSurface->UnlockRect();
2545	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceDMA: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2546	break;
2547	}
2548
2549	case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
2550	fVertex = true;
2551	/* no break */
2552
2553	case SVGA3D_SURFACE_HINT_INDEXBUFFER:
2554	{
2555	uint8_t *pData;
2556	unsigned uDestOffset;
2557
2558	uDestOffset = pBoxes[i].x * pSurface->cbBlock + pBoxes[i].y * pSurface->pMipmapLevels[host.mipmap].cbSurfacePitch;
2559	AssertReturn(uDestOffset + pBoxes[i].w * pSurface->cbBlock + (pBoxes[i].h - 1) * pSurface->pMipmapLevels[host.mipmap].cbSurfacePitch <= pSurface->pMipmapLevels[host.mipmap].cbSurface, VERR_INTERNAL_ERROR);
2560
2561	/* @todo lock only as much as we really need */
2562	if (fVertex)
2563	hr = pSurface->u.pVertexBuffer->Lock(0, 0, (void **)&pData, dwFlags);
2564	else
2565	hr = pSurface->u.pIndexBuffer->Lock(0, 0, (void **)&pData, dwFlags);
2566	AssertMsg(hr == D3D_OK, ("vmsvga3dSurfaceDMA: Lock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
2567
2568	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));
2569
2570	rc = vmsvgaGMRTransfer(pThis,
2571	transfer,
2572	pData + uDestOffset,
2573	pSurface->pMipmapLevels[host.mipmap].cbSurfacePitch,
2574	guest.ptr,
2575	pBoxes[i].srcx * pSurface->cbBlock + pBoxes[i].srcy * cbSrcPitch,
2576	cbSrcPitch,
2577	pBoxes[i].w * pSurface->cbBlock,
2578	pBoxes[i].h);
2579	AssertRC(rc);
2580
2581	Log4(("first line:\n%.*Rhxd\n", cbSrcPitch, pData));
2582
2583	if (fVertex)
2584	hr = pSurface->u.pVertexBuffer->Unlock();
2585	else
2586	hr = pSurface->u.pIndexBuffer->Unlock();
2587	AssertMsg(hr == D3D_OK, ("vmsvga3dSurfaceDMA: Unlock %s failed with %x\n", (fVertex) ? "vertex" : "index", hr));
2588	break;
2589	}
2590
2591	default:
2592	AssertFailed();
2593	break;
2594	}
2595	}
2596	}
2597	return rc;
2598	}
2599
2600	int vmsvga3dSurfaceBlitToScreen(PVGASTATE pThis, uint32_t dest, SVGASignedRect destRect, SVGA3dSurfaceImageId src, SVGASignedRect srcRect, uint32_t cRects, SVGASignedRect *pRect)
2601	{
2602	/* Requires SVGA_FIFO_CAP_SCREEN_OBJECT support */
2603	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));
2604	for (uint32_t i = 0; i < cRects; i++)
2605	{
2606	Log(("vmsvga3dSurfaceBlitToScreen: clipping rect %d (%d,%d)(%d,%d)\n", i, pRect[i].left, pRect[i].top, pRect[i].right, pRect[i].bottom));
2607	}
2608
2609	/* @todo Only screen 0 for now. */
2610	AssertReturn(dest == 0, VERR_INTERNAL_ERROR);
2611	AssertReturn(src.mipmap == 0 && src.face == 0, VERR_INVALID_PARAMETER);
2612	/* @todo scaling */
2613	AssertReturn(destRect.right - destRect.left == srcRect.right - srcRect.left && destRect.bottom - destRect.top == srcRect.bottom - srcRect.top, VERR_INVALID_PARAMETER);
2614
2615	if (cRects == 0)
2616	{
2617	/* easy case; no clipping */
2618	SVGA3dCopyBox box;
2619	SVGA3dGuestImage dest;
2620
2621	box.x = destRect.left;
2622	box.y = destRect.top;
2623	box.z = 0;
2624	box.w = destRect.right - destRect.left;
2625	box.h = destRect.bottom - destRect.top;
2626	box.d = 1;
2627	box.srcx = srcRect.left;
2628	box.srcy = srcRect.top;
2629	box.srcz = 0;
2630
2631	dest.ptr.gmrId = SVGA_GMR_FRAMEBUFFER;
2632	dest.ptr.offset = 0;
2633	dest.pitch = pThis->svga.cbScanline;
2634
2635	int rc = vmsvga3dSurfaceDMA(pThis, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
2636	AssertRCReturn(rc, rc);
2637
2638	vgaR3UpdateDisplay(pThis, box.x, box.y, box.w, box.h);
2639	return VINF_SUCCESS;
2640	}
2641	else
2642	{
2643	SVGA3dGuestImage dest;
2644	SVGA3dCopyBox box;
2645
2646	box.srcz = 0;
2647	box.z = 0;
2648	box.d = 1;
2649
2650	dest.ptr.gmrId = SVGA_GMR_FRAMEBUFFER;
2651	dest.ptr.offset = 0;
2652	dest.pitch = pThis->svga.cbScanline;
2653
2654	/* @todo merge into one SurfaceDMA call */
2655	for (uint32_t i = 0; i < cRects; i++)
2656	{
2657	/* The clipping rectangle is relative to the top-left corner of srcRect & destRect. Adjust here. */
2658	box.srcx = srcRect.left + pRect[i].left;
2659	box.srcy = srcRect.top + pRect[i].top;
2660
2661	box.x = pRect[i].left + destRect.left;
2662	box.y = pRect[i].top + destRect.top;
2663	box.z = 0;
2664	box.w = pRect[i].right - pRect[i].left;
2665	box.h = pRect[i].bottom - pRect[i].top;
2666
2667	int rc = vmsvga3dSurfaceDMA(pThis, dest, src, SVGA3D_READ_HOST_VRAM, 1, &box);
2668	AssertRCReturn(rc, rc);
2669
2670	vgaR3UpdateDisplay(pThis, box.x, box.y, box.w, box.h);
2671	}
2672
2673	#if 0
2674	{
2675	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
2676	HRESULT hr;
2677	PVMSVGA3DSURFACE pSurface;
2678	PVMSVGA3DCONTEXT pContext;
2679	uint32_t sid = src.sid;
2680	AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
2681	AssertReturn(sid < pState->cSurfaces && pState->paSurface[sid].id == sid, VERR_INVALID_PARAMETER);
2682
2683	pSurface = &pState->paSurface[sid];
2684	uint32_t cid;
2685
2686	/* @todo stricter checks for associated context */
2687	cid = pSurface->idAssociatedContext;
2688
2689	if ( cid >= pState->cContexts
2690	\|\| pState->paContext[cid].id != cid)
2691	{
2692	Log(("vmsvga3dGenerateMipmaps invalid context id!\n"));
2693	return VERR_INVALID_PARAMETER;
2694	}
2695	pContext = &pState->paContext[cid];
2696
2697	if (pSurface->id == 0x5e)
2698	{
2699	IDirect3DSurface9 *pSrc;
2700
2701	hr = pSurface->u.pTexture->GetSurfaceLevel(0/* Texture level */,
2702	&pSrc);
2703	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceStretchBlt: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
2704
2705	pContext->pDevice->ColorFill(pSrc, NULL, (D3DCOLOR)0x11122255);
2706	pSrc->Release();
2707	}
2708	}
2709	#endif
2710
2711	return VINF_SUCCESS;
2712	}
2713	}
2714
2715	int vmsvga3dGenerateMipmaps(PVGASTATE pThis, uint32_t sid, SVGA3dTextureFilter filter)
2716	{
2717	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
2718	PVMSVGA3DSURFACE pSurface;
2719	int rc = VINF_SUCCESS;
2720	HRESULT hr;
2721
2722	AssertReturn(pState, VERR_NO_MEMORY);
2723	AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
2724	AssertReturn(sid < pState->cSurfaces && pState->paSurface[sid].id == sid, VERR_INVALID_PARAMETER);
2725
2726	pSurface = &pState->paSurface[sid];
2727	AssertReturn(pSurface->idAssociatedContext != SVGA3D_INVALID_ID, VERR_INTERNAL_ERROR);
2728
2729	Assert(filter != SVGA3D_TEX_FILTER_FLATCUBIC);
2730	Assert(filter != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
2731	pSurface->autogenFilter = filter;
2732
2733	Log(("vmsvga3dGenerateMipmaps: sid=%x filter=%d\n", sid, filter));
2734
2735	if (!pSurface->u.pSurface)
2736	{
2737	PVMSVGA3DCONTEXT pContext;
2738	uint32_t cid;
2739
2740	/* @todo stricter checks for associated context */
2741	cid = pSurface->idAssociatedContext;
2742
2743	if ( cid >= pState->cContexts
2744	\|\| pState->paContext[cid].id != cid)
2745	{
2746	Log(("vmsvga3dGenerateMipmaps invalid context id!\n"));
2747	return VERR_INVALID_PARAMETER;
2748	}
2749	pContext = &pState->paContext[cid];
2750
2751	/* Unknown surface type; turn it into a texture. */
2752	Log(("vmsvga3dGenerateMipmaps: unknown src surface id=%x type=%d format=%d -> create texture\n", sid, pSurface->flags, pSurface->format));
2753	rc = vmsvga3dCreateTexture(pContext, cid, pSurface);
2754	AssertRCReturn(rc, rc);
2755	}
2756	else
2757	{
2758	hr = pSurface->u.pTexture->SetAutoGenFilterType((D3DTEXTUREFILTERTYPE)filter);
2759	AssertMsg(hr == D3D_OK, ("vmsvga3dGenerateMipmaps: SetAutoGenFilterType failed with %x\n", hr));
2760	}
2761
2762	/* Generate the mip maps. */
2763	pSurface->u.pTexture->GenerateMipSubLevels();
2764
2765	return VINF_SUCCESS;
2766	}
2767
2768	int vmsvga3dCommandPresent(PVGASTATE pThis, uint32_t sid, uint32_t cRects, SVGA3dCopyRect *pRect)
2769	{
2770	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
2771	PVMSVGA3DSURFACE pSurface;
2772	int rc = VINF_SUCCESS;
2773	PVMSVGA3DCONTEXT pContext;
2774	uint32_t cid;
2775	HRESULT hr;
2776	IDirect3DSurface9 *pBackBuffer;
2777	IDirect3DSurface9 *pSurfaceD3D;
2778	struct
2779	{
2780	uint32_t x;
2781	uint32_t y;
2782	uint32_t cx;
2783	uint32_t cy;
2784	} srcViewPort;
2785
2786	AssertReturn(pState, VERR_NO_MEMORY);
2787	AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
2788	AssertReturn(sid < pState->cSurfaces && pState->paSurface[sid].id == sid, VERR_INVALID_PARAMETER);
2789
2790	pSurface = &pState->paSurface[sid];
2791	AssertReturn(pSurface->idAssociatedContext != SVGA3D_INVALID_ID, VERR_INTERNAL_ERROR);
2792
2793	/* @todo stricter checks for associated context */
2794	cid = pSurface->idAssociatedContext;
2795	Log(("vmsvga3dCommandPresent: sid=%x cRects=%d cid=%x\n", sid, cRects, cid));
2796	for (uint32_t i=0; i < cRects; i++)
2797	{
2798	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));
2799	}
2800
2801	if ( cid >= pState->cContexts
2802	\|\| pState->paContext[cid].id != cid)
2803	{
2804	Log(("vmsvga3dCommandPresent invalid context id!\n"));
2805	return VERR_INVALID_PARAMETER;
2806	}
2807	pContext = &pState->paContext[cid];
2808
2809	hr = pContext->pDevice->GetBackBuffer(0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer);
2810	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: GetBackBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
2811
2812	if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
2813	{
2814	hr = pSurface->u.pTexture->GetSurfaceLevel(0, &pSurfaceD3D);
2815	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
2816	}
2817	else
2818	pSurfaceD3D = pSurface->u.pSurface;
2819
2820	/* Source surface different size? */
2821	if (pSurface->pMipmapLevels[0].size.width != pThis->svga.uWidth \|\|
2822	pSurface->pMipmapLevels[0].size.height != pThis->svga.uHeight)
2823	{
2824	float xMultiplier = (float)pSurface->pMipmapLevels[0].size.width / (float)pThis->svga.uWidth;
2825	float yMultiplier = (float)pSurface->pMipmapLevels[0].size.height / (float)pThis->svga.uHeight;
2826
2827	srcViewPort.x = (uint32_t)((float)pThis->svga.viewport.x * xMultiplier);
2828	srcViewPort.y = (uint32_t)((float)pThis->svga.viewport.y * yMultiplier);
2829	srcViewPort.cx = (uint32_t)((float)pThis->svga.viewport.cx * xMultiplier);
2830	srcViewPort.cy = (uint32_t)((float)pThis->svga.viewport.cy * yMultiplier);
2831	}
2832	else
2833	{
2834	srcViewPort.x = pThis->svga.viewport.x;
2835	srcViewPort.y = pThis->svga.viewport.y;
2836	srcViewPort.cx = pThis->svga.viewport.cx;
2837	srcViewPort.cy = pThis->svga.viewport.cy;
2838	}
2839
2840	/* @note the viewport doesn't affect blitting. */
2841	if (cRects == 0)
2842	{
2843	RECT rectDest, rectSrc;
2844
2845	rectSrc.left = srcViewPort.x;
2846	rectSrc.top = srcViewPort.y;
2847	rectSrc.right = rectSrc.left + srcViewPort.cx;
2848	rectSrc.bottom = rectSrc.top + srcViewPort.cy;
2849	rectDest.left = 0;
2850	rectDest.top = 0;
2851	rectDest.right = pThis->svga.viewport.cx;
2852	rectDest.bottom = pThis->svga.viewport.cy;
2853	hr = pContext->pDevice->StretchRect(pSurfaceD3D, &rectSrc, pBackBuffer, &rectDest, D3DTEXF_NONE);
2854	}
2855	else
2856	{
2857	for (uint32_t i = 0; i < cRects; i++)
2858	{
2859	RECT rectSrc;
2860	RECT rectDest;
2861
2862	if ( pRect[i].x + pRect[i].w <= pThis->svga.viewport.x
2863	\|\| pThis->svga.viewport.x + pThis->svga.viewport.cx <= pRect[i].x
2864	\|\| pRect[i].y + pRect[i].h <= pThis->svga.viewport.y
2865	\|\| pThis->svga.viewport.y + pThis->svga.viewport.cy <= pRect[i].y)
2866	{
2867	/* Intersection is empty; skip */
2868	continue;
2869	}
2870
2871	rectSrc.left = RT_MAX(pRect[i].srcx, srcViewPort.x);
2872	rectSrc.top = RT_MAX(pRect[i].srcy, srcViewPort.y);
2873	rectSrc.right = RT_MIN(pRect[i].srcx + pRect[i].w, srcViewPort.x + srcViewPort.cx);
2874	rectSrc.bottom = RT_MIN(pRect[i].srcy + pRect[i].h, srcViewPort.y + srcViewPort.cy);
2875	rectDest.left = RT_MAX(pRect[i].x, pThis->svga.viewport.x) - pThis->svga.viewport.x;
2876	rectDest.top = RT_MAX(pRect[i].y, pThis->svga.viewport.y) - pThis->svga.viewport.y;
2877	rectDest.right = RT_MIN(pRect[i].x + pRect[i].w, pThis->svga.viewport.x + pThis->svga.viewport.cx) - pThis->svga.viewport.x;
2878	rectDest.bottom = RT_MIN(pRect[i].y + pRect[i].h, pThis->svga.viewport.y + pThis->svga.viewport.cy) - pThis->svga.viewport.y;
2879
2880	hr = pContext->pDevice->StretchRect(pSurfaceD3D, &rectSrc, pBackBuffer, &rectDest, D3DTEXF_NONE);
2881	AssertBreak(hr == D3D_OK);
2882	}
2883	}
2884
2885	if (pSurface->flags & SVGA3D_SURFACE_HINT_TEXTURE)
2886	pSurfaceD3D->Release();
2887
2888	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: StretchRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
2889
2890	hr = pContext->pDevice->Present(NULL, NULL, NULL, NULL);
2891	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandPresent: Present failed with %x\n", hr), VERR_INTERNAL_ERROR);
2892
2893	pBackBuffer->Release();
2894	return VINF_SUCCESS;
2895	}
2896
2897
2898	/**
2899	* Create a new 3d context
2900	*
2901	* @returns VBox status code.
2902	* @param pThis VGA device instance data.
2903	* @param cid Context id
2904	* @param fLegacy OpenGL(+darwin) specific argument, ignored.
2905	*/
2906	int vmsvga3dContextDefine(PVGASTATE pThis, uint32_t cid, bool fLegacy)
2907	{
2908	int rc;
2909	PVMSVGA3DCONTEXT pContext;
2910	HRESULT hr;
2911	D3DPRESENT_PARAMETERS PresParam;
2912	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
2913
2914	AssertReturn(pState, VERR_NO_MEMORY);
2915	AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
2916
2917	Log(("vmsvga3dContextDefine id %x\n", cid));
2918
2919	if (cid >= pState->cContexts)
2920	{
2921	pState->paContext = (PVMSVGA3DCONTEXT)RTMemRealloc(pState->paContext, sizeof(VMSVGA3DCONTEXT) * (cid + 1));
2922	AssertReturn(pState->paContext, VERR_NO_MEMORY);
2923	memset(&pState->paContext[pState->cContexts], 0, sizeof(VMSVGA3DCONTEXT) * (cid + 1 - pState->cContexts));
2924	for (uint32_t i = pState->cContexts; i < cid + 1; i++)
2925	pState->paContext[i].id = SVGA3D_INVALID_ID;
2926
2927	pState->cContexts = cid + 1;
2928	}
2929	/* If one already exists with this id, then destroy it now. */
2930	if (pState->paContext[cid].id != SVGA3D_INVALID_ID)
2931	vmsvga3dContextDestroy(pThis, cid);
2932
2933	pContext = &pState->paContext[cid];
2934	memset(pContext, 0, sizeof(*pContext));
2935	pContext->id = cid;
2936	for (uint32_t i = 0; i< RT_ELEMENTS(pContext->aSidActiveTexture); i++)
2937	pContext->aSidActiveTexture[i] = SVGA3D_INVALID_ID;
2938	pContext->sidRenderTarget = SVGA3D_INVALID_ID;
2939	pContext->state.shidVertex = SVGA3D_INVALID_ID;
2940	pContext->state.shidPixel = SVGA3D_INVALID_ID;
2941
2942	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderTargets); i++)
2943	pContext->state.aRenderTargets[i] = SVGA3D_INVALID_ID;
2944
2945	/* Create a context window. */
2946	CREATESTRUCT cs;
2947
2948	AssertReturn(pThis->svga.u64HostWindowId, VERR_INTERNAL_ERROR);
2949
2950	cs.lpCreateParams = NULL;
2951	cs.dwExStyle = WS_EX_NOACTIVATE \| WS_EX_NOPARENTNOTIFY \| WS_EX_TRANSPARENT;
2952	#ifdef DEBUG_GFX_WINDOW
2953	cs.lpszName = (char *)RTMemAllocZ(256);
2954	RTStrPrintf((char *)cs.lpszName, 256, "Context %d OpenGL Window", cid);
2955	#else
2956	cs.lpszName = NULL;
2957	#endif
2958	cs.lpszClass = NULL;
2959	#ifdef DEBUG_GFX_WINDOW
2960	cs.style = WS_CLIPSIBLINGS \| WS_CLIPCHILDREN \| WS_VISIBLE \| WS_CAPTION;
2961	#else
2962	cs.style = WS_CLIPSIBLINGS \| WS_CLIPCHILDREN \| WS_DISABLED \| WS_CHILD \| WS_VISIBLE;
2963	#endif
2964	cs.x = 0;
2965	cs.y = 0;
2966	cs.cx = pThis->svga.uWidth;
2967	cs.cy = pThis->svga.uHeight;
2968	cs.hwndParent = (HWND)pThis->svga.u64HostWindowId;
2969	cs.hMenu = NULL;
2970	cs.hInstance = pState->hInstance;
2971
2972	rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_CREATEWINDOW, (WPARAM)&pContext->hwnd, (LPARAM)&cs);
2973	AssertRCReturn(rc, rc);
2974
2975	/* Changed when the function returns. */
2976	PresParam.BackBufferWidth = 0;
2977	PresParam.BackBufferHeight = 0;
2978	PresParam.BackBufferFormat = D3DFMT_UNKNOWN;
2979	PresParam.BackBufferCount = 0;
2980
2981	PresParam.MultiSampleType = D3DMULTISAMPLE_NONE;
2982	PresParam.MultiSampleQuality = 0;
2983	PresParam.SwapEffect = D3DSWAPEFFECT_FLIP;
2984	PresParam.hDeviceWindow = pContext->hwnd;
2985	PresParam.Windowed = TRUE; /* @todo */
2986	PresParam.EnableAutoDepthStencil = FALSE;
2987	PresParam.AutoDepthStencilFormat = D3DFMT_UNKNOWN; /* not relevant */
2988	PresParam.Flags = 0;
2989	PresParam.FullScreen_RefreshRateInHz = 0; /* windowed -> 0 */
2990	/* @todo consider using D3DPRESENT_DONOTWAIT so we don't wait for the GPU during Present calls. */
2991	PresParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
2992
2993	#ifdef VBOX_VMSVGA3D_WITH_OPENGL
2994	hr = pState->pD3D9->CreateDevice(D3DADAPTER_DEFAULT,
2995	D3DDEVTYPE_HAL,
2996	pContext->hwnd,
2997	D3DCREATE_MULTITHREADED \| D3DCREATE_MIXED_VERTEXPROCESSING, //D3DCREATE_HARDWARE_VERTEXPROCESSING,
2998	&PresParam,
2999	&pContext->pDevice);
3000	#else
3001	hr = pState->pD3D9->CreateDeviceEx(D3DADAPTER_DEFAULT,
3002	D3DDEVTYPE_HAL,
3003	pContext->hwnd,
3004	D3DCREATE_MULTITHREADED \| D3DCREATE_MIXED_VERTEXPROCESSING, //D3DCREATE_HARDWARE_VERTEXPROCESSING,
3005	&PresParam,
3006	NULL,
3007	&pContext->pDevice);
3008	#endif
3009	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dContextDefine: CreateDevice failed with %x\n", hr), VERR_INTERNAL_ERROR);
3010
3011	Log(("vmsvga3dContextDefine: Backbuffer (%d,%d) count=%d format=%x\n", PresParam.BackBufferWidth, PresParam.BackBufferHeight, PresParam.BackBufferCount, PresParam.BackBufferFormat));
3012	return VINF_SUCCESS;
3013	}
3014
3015	/**
3016	* Destroy an existing 3d context
3017	*
3018	* @returns VBox status code.
3019	* @param pThis VGA device instance data.
3020	* @param cid Context id
3021	*/
3022	int vmsvga3dContextDestroy(PVGASTATE pThis, uint32_t cid)
3023	{
3024	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
3025	AssertReturn(pState, VERR_NO_MEMORY);
3026
3027	AssertReturn(cid < SVGA3D_MAX_CONTEXT_IDS, VERR_INVALID_PARAMETER);
3028
3029	if ( cid < pState->cContexts
3030	&& pState->paContext[cid].id == cid)
3031	{
3032	PVMSVGA3DCONTEXT pContext = &pState->paContext[cid];
3033
3034	Log(("vmsvga3dContextDestroy id %x\n", cid));
3035
3036	/* Check for all surfaces that are associated with this context to remove all dependencies */
3037	for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
3038	{
3039	PVMSVGA3DSURFACE pSurface = &pState->paSurface[sid];
3040	if ( pSurface->id == sid
3041	&& pSurface->idAssociatedContext == cid)
3042	{
3043	int rc;
3044
3045	Log(("vmsvga3dContextDestroy: remove all dependencies for surface %x\n", sid));
3046
3047	uint32_t surfaceFlags = pSurface->flags;
3048	SVGA3dSurfaceFormat format = pSurface->format;
3049	SVGA3dSurfaceFace face[SVGA3D_MAX_SURFACE_FACES];
3050	uint32_t multisampleCount = pSurface->multiSampleCount;
3051	SVGA3dTextureFilter autogenFilter = pSurface->autogenFilter;
3052	SVGA3dSize *pMipLevelSize;
3053	uint32_t cFaces = pSurface->cFaces;
3054
3055	pMipLevelSize = (SVGA3dSize )RTMemAllocZ(pSurface->faces[0].numMipLevels pSurface->cFaces * sizeof(SVGA3dSize));
3056	AssertReturn(pMipLevelSize, VERR_NO_MEMORY);
3057
3058	for (uint32_t face=0; face < pSurface->cFaces; face++)
3059	{
3060	for (uint32_t i = 0; i < pSurface->faces[0].numMipLevels; i++)
3061	{
3062	uint32_t idx = i + face * pSurface->faces[0].numMipLevels;
3063	memcpy(&pMipLevelSize[idx], &pSurface->pMipmapLevels[idx].size, sizeof(SVGA3dSize));
3064	}
3065	}
3066	memcpy(face, pSurface->faces, sizeof(pSurface->faces));
3067
3068	/* Recreate the surface with the original settings; destroys the contents, but that seems fairly safe since the context is also destroyed. */
3069	/** @todo not safe with shared objects */
3070	Assert(pSurface->pSharedObjectTree == NULL);
3071
3072	rc = vmsvga3dSurfaceDestroy(pThis, sid);
3073	AssertRC(rc);
3074
3075	rc = vmsvga3dSurfaceDefine(pThis, sid, surfaceFlags, format, face, multisampleCount, autogenFilter, face[0].numMipLevels * cFaces, pMipLevelSize);
3076	AssertRC(rc);
3077
3078	Assert(!pSurface->u.pSurface);
3079	}
3080	else
3081	{
3082	/* Check for a shared surface object. */
3083	PVMSVGA3DSHAREDSURFACE pSharedSurface = (PVMSVGA3DSHAREDSURFACE)RTAvlU32Get(&pSurface->pSharedObjectTree, cid);
3084	if (pSharedSurface)
3085	{
3086	Log(("vmsvga3dContextDestroy: remove shared dependency for surface %x\n", sid));
3087
3088	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))
3089	{
3090	case SVGA3D_SURFACE_HINT_TEXTURE:
3091	case SVGA3D_SURFACE_HINT_TEXTURE \| SVGA3D_SURFACE_HINT_RENDERTARGET:
3092	Assert(pSharedSurface->u.pTexture);
3093	if (pSharedSurface->u.pTexture)
3094	pSharedSurface->u.pTexture->Release();
3095	break;
3096
3097	default:
3098	AssertFailed();
3099	break;
3100	}
3101	RTAvlU32Remove(&pSurface->pSharedObjectTree, cid);
3102	RTMemFree(pSharedSurface);
3103	}
3104	}
3105	}
3106
3107	/* Destroy all leftover pixel shaders. */
3108	for (uint32_t i = 0; i < pContext->cPixelShaders; i++)
3109	{
3110	if (pContext->paPixelShader[i].id != SVGA3D_INVALID_ID)
3111	vmsvga3dShaderDestroy(pThis, pContext->paPixelShader[i].cid, pContext->paPixelShader[i].id, pContext->paPixelShader[i].type);
3112	}
3113	if (pContext->paPixelShader)
3114	RTMemFree(pContext->paPixelShader);
3115
3116	/* Destroy all leftover vertex shaders. */
3117	for (uint32_t i = 0; i < pContext->cVertexShaders; i++)
3118	{
3119	if (pContext->paVertexShader[i].id != SVGA3D_INVALID_ID)
3120	vmsvga3dShaderDestroy(pThis, pContext->paVertexShader[i].cid, pContext->paVertexShader[i].id, pContext->paVertexShader[i].type);
3121	}
3122	if (pContext->paVertexShader)
3123	RTMemFree(pContext->paVertexShader);
3124
3125	if (pContext->state.paVertexShaderConst)
3126	RTMemFree(pContext->state.paVertexShaderConst);
3127	if (pContext->state.paPixelShaderConst)
3128	RTMemFree(pContext->state.paPixelShaderConst);
3129
3130	/* Release the D3D device object */
3131	pContext->pDevice->Release();
3132
3133	/* Destroy the window we've created. */
3134	int rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_DESTROYWINDOW, (WPARAM)pContext->hwnd, 0);
3135	AssertRC(rc);
3136
3137	memset(pContext, 0, sizeof(*pContext));
3138	pContext->id = SVGA3D_INVALID_ID;
3139	}
3140	else
3141	AssertFailed();
3142
3143	return VINF_SUCCESS;
3144	}
3145
3146	#ifdef VBOX_VMSVGA3D_WITH_OPENGL
3147	#define vmsvga3dContextTrackUsage(pThis, pContext)
3148	#else
3149	static int vmsvga3dContextTrackUsage(PVGASTATE pThis, PVMSVGA3DCONTEXT pContext)
3150	{
3151	/* Inject fences to make sure we can track surface usage in case the client wants to reuse it in another context. */
3152	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->aSidActiveTexture); i++)
3153	{
3154	if (pContext->aSidActiveTexture[i] != SVGA3D_INVALID_ID)
3155	vmsvga3dSurfaceTrackUsage(pThis, pContext, pContext->aSidActiveTexture[i]);
3156	}
3157	if (pContext->sidRenderTarget != SVGA3D_INVALID_ID)
3158	vmsvga3dSurfaceTrackUsage(pThis, pContext, pContext->sidRenderTarget);
3159	return VINF_SUCCESS;
3160	}
3161	#endif
3162
3163	/* Handle resize */
3164	int vmsvga3dChangeMode(PVGASTATE pThis)
3165	{
3166	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
3167	AssertReturn(pState, VERR_NO_MEMORY);
3168
3169	/* Resize all active contexts. */
3170	for (uint32_t i = 0; i < pState->cContexts; i++)
3171	{
3172	PVMSVGA3DCONTEXT pContext = &pState->paContext[i];
3173	uint32_t cid = pContext->id;
3174
3175	if (cid != SVGA3D_INVALID_ID)
3176	{
3177	CREATESTRUCT cs;
3178	D3DPRESENT_PARAMETERS PresParam;
3179	D3DVIEWPORT9 viewportOrg;
3180	HRESULT hr;
3181
3182	#ifdef VMSVGA3D_DIRECT3D9_RESET
3183	/* Sync back all surface data as everything is lost after the Reset. */
3184	for (uint32_t sid = 0; sid < pState->cSurfaces; sid++)
3185	{
3186	PVMSVGA3DSURFACE pSurface = &pState->paSurface[sid];
3187	if ( pSurface->id == sid
3188	&& pSurface->idAssociatedContext == cid
3189	&& pSurface->u.pSurface)
3190	{
3191	Log(("vmsvga3dChangeMode: sync back data of surface sid=%x (fDirty=%d)\n", sid, pSurface->fDirty));
3192
3193	/* Reallocate our surface memory buffers. */
3194	for (uint32_t i = 0; i < pSurface->cMipLevels; i++)
3195	{
3196	PVMSVGA3DMIPMAPLEVEL pMipmapLevel = &pSurface->pMipmapLevels[i];
3197
3198	pMipmapLevel->pSurfaceData = RTMemAllocZ(pMipmapLevel->cbSurface);
3199	AssertReturn(pMipmapLevel->pSurfaceData, VERR_NO_MEMORY);
3200
3201	if (!pSurface->fDirty)
3202	{
3203	D3DLOCKED_RECT LockedRect;
3204
3205	if (pSurface->bounce.pTexture)
3206	{
3207	IDirect3DSurface9 pSrc, pDest;
3208
3209	/* @todo only sync when something was actually rendered (since the last sync) */
3210	Log(("vmsvga3dChangeMode: sync bounce buffer (level %d)\n", i));
3211	hr = pSurface->bounce.pTexture->GetSurfaceLevel(i, &pDest);
3212	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
3213
3214	hr = pSurface->u.pTexture->GetSurfaceLevel(i, &pSrc);
3215	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
3216
3217	hr = pContext->pDevice->GetRenderTargetData(pSrc, pDest);
3218	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetRenderTargetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
3219
3220	pSrc->Release();
3221	pDest->Release();
3222
3223	hr = pSurface->bounce.pTexture->LockRect(i,
3224	&LockedRect,
3225	NULL,
3226	D3DLOCK_READONLY);
3227	}
3228	else
3229	hr = pSurface->u.pTexture->LockRect(i,
3230	&LockedRect,
3231	NULL,
3232	D3DLOCK_READONLY);
3233	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
3234
3235	/* Copy the data one line at a time in case the internal pitch is different. */
3236	for (uint32_t j = 0; j < pMipmapLevel->size.height; j++)
3237	{
3238	memcpy((uint8_t )pMipmapLevel->pSurfaceData + j pMipmapLevel->cbSurfacePitch, (uint8_t )LockedRect.pBits + j LockedRect.Pitch, pMipmapLevel->cbSurfacePitch);
3239	}
3240
3241	if (pSurface->bounce.pTexture)
3242	hr = pSurface->bounce.pTexture->UnlockRect(i);
3243	else
3244	hr = pSurface->u.pTexture->UnlockRect(i);
3245	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
3246	}
3247	}
3248
3249
3250	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))
3251	{
3252	case SVGA3D_SURFACE_CUBEMAP:
3253	AssertFailed(); /* @todo */
3254	break;
3255
3256	case SVGA3D_SURFACE_HINT_INDEXBUFFER:
3257	pSurface->u.pIndexBuffer->Release();
3258	break;
3259
3260	case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
3261	pSurface->u.pVertexBuffer->Release();
3262	pSurface->u.pVertexBuffer = NULL;
3263	break;
3264
3265	case SVGA3D_SURFACE_HINT_TEXTURE:
3266	case SVGA3D_SURFACE_HINT_TEXTURE \| SVGA3D_SURFACE_HINT_RENDERTARGET:
3267	pSurface->u.pTexture->Release();
3268	pSurface->u.pTexture = NULL;
3269	if (pSurface->bounce.pTexture)
3270	{
3271	pSurface->bounce.pTexture->Release();
3272	pSurface->bounce.pTexture = NULL;
3273	}
3274	break;
3275
3276	case SVGA3D_SURFACE_HINT_RENDERTARGET:
3277	case SVGA3D_SURFACE_HINT_DEPTHSTENCIL:
3278	if (pSurface->fStencilAsTexture)
3279	pSurface->u.pTexture->Release();
3280	else
3281	pSurface->u.pSurface->Release();
3282	pSurface->u.pSurface = NULL;
3283	break;
3284
3285	default:
3286	break;
3287	}
3288	RTAvlU32Destroy(&pSurface->pSharedObjectTree, vmsvga3dSharedSurfaceDestroyTree, pSurface);
3289	Assert(pSurface->pSharedObjectTree == NULL);
3290
3291	pSurface->idAssociatedContext = SVGA3D_INVALID_ID;
3292	pSurface->hSharedObject = 0;
3293	}
3294	}
3295	#endif /* #ifdef VMSVGA3D_DIRECT3D9_RESET */
3296	memset(&cs, 0, sizeof(cs));
3297	cs.cx = pThis->svga.uWidth;
3298	cs.cy = pThis->svga.uHeight;
3299
3300	Log(("vmsvga3dChangeMode: Resize window %x of context %d to (%d,%d)\n", pContext->hwnd, pContext->id, cs.cx, cs.cy));
3301
3302	hr = pContext->pDevice->GetViewport(&viewportOrg);
3303	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
3304
3305	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)));
3306
3307	/* Resize the window. */
3308	int rc = vmsvga3dSendThreadMessage(pState->pWindowThread, pState->WndRequestSem, WM_VMSVGA3D_RESIZEWINDOW, (WPARAM)pContext->hwnd, (LPARAM)&cs);
3309	AssertRC(rc);
3310
3311	/* Changed when the function returns. */
3312	PresParam.BackBufferWidth = 0;
3313	PresParam.BackBufferHeight = 0;
3314	PresParam.BackBufferFormat = D3DFMT_UNKNOWN;
3315	PresParam.BackBufferCount = 0;
3316
3317	PresParam.MultiSampleType = D3DMULTISAMPLE_NONE;
3318	PresParam.MultiSampleQuality = 0;
3319	PresParam.SwapEffect = D3DSWAPEFFECT_FLIP;
3320	PresParam.hDeviceWindow = pContext->hwnd;
3321	PresParam.Windowed = TRUE; /* @todo */
3322	PresParam.EnableAutoDepthStencil = FALSE;
3323	PresParam.AutoDepthStencilFormat = D3DFMT_UNKNOWN; /* not relevant */
3324	PresParam.Flags = 0;
3325	PresParam.FullScreen_RefreshRateInHz = 0; /* windowed -> 0 */
3326	/* @todo consider using D3DPRESENT_DONOTWAIT so we don't wait for the GPU during Present calls. */
3327	PresParam.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;;
3328
3329	#ifdef VBOX_VMSVGA3D_WITH_OPENGL
3330	hr = pContext->pDevice->Reset(&PresParam);
3331	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: Reset failed with %x\n", hr), VERR_INTERNAL_ERROR);
3332	#else
3333	/* ResetEx does not trash the device state */
3334	hr = pContext->pDevice->ResetEx(&PresParam, NULL);
3335	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: Reset failed with %x\n", hr), VERR_INTERNAL_ERROR);
3336	#endif
3337	Log(("vmsvga3dChangeMode: Backbuffer (%d,%d) count=%d format=%x\n", PresParam.BackBufferWidth, PresParam.BackBufferHeight, PresParam.BackBufferCount, PresParam.BackBufferFormat));
3338
3339	/* ResetEx changes the viewport; restore it again. */
3340	hr = pContext->pDevice->SetViewport(&viewportOrg);
3341	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
3342
3343	#ifdef LOG_ENABLED
3344	{
3345	D3DVIEWPORT9 viewport;
3346	hr = pContext->pDevice->GetViewport(&viewport);
3347	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dChangeMode: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
3348
3349	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)));
3350	}
3351	#endif
3352
3353	/* First set the render targets as they change the internal state (reset viewport etc) */
3354	Log(("vmsvga3dChangeMode: Recreate render targets BEGIN\n"));
3355	for (uint32_t j = 0; j < RT_ELEMENTS(pContext->state.aRenderTargets); j++)
3356	{
3357	if (pContext->state.aRenderTargets[j] != SVGA3D_INVALID_ID)
3358	{
3359	SVGA3dSurfaceImageId target;
3360
3361	target.sid = pContext->state.aRenderTargets[j];
3362	target.face = 0;
3363	target.mipmap = 0;
3364	rc = vmsvga3dSetRenderTarget(pThis, cid, (SVGA3dRenderTargetType)j, target);
3365	AssertRCReturn(rc, rc);
3366	}
3367	}
3368
3369	#ifdef VMSVGA3D_DIRECT3D9_RESET
3370	/* Recreate the render state */
3371	Log(("vmsvga3dChangeMode: Recreate render state BEGIN\n"));
3372	for (uint32_t i = 0; i < RT_ELEMENTS(pContext->state.aRenderState); i++)
3373	{
3374	SVGA3dRenderState *pRenderState = &pContext->state.aRenderState[i];
3375
3376	if (pRenderState->state != SVGA3D_RS_INVALID)
3377	vmsvga3dSetRenderState(pThis, pContext->id, 1, pRenderState);
3378	}
3379	Log(("vmsvga3dChangeMode: Recreate render state END\n"));
3380
3381	/* Recreate the texture state */
3382	Log(("vmsvga3dChangeMode: Recreate texture state BEGIN\n"));
3383	for (uint32_t iStage = 0; iStage < SVGA3D_MAX_TEXTURE_STAGE; iStage++)
3384	{
3385	for (uint32_t j = 0; j < SVGA3D_TS_MAX; j++)
3386	{
3387	SVGA3dTextureState *pTextureState = &pContext->state.aTextureState[iStage][j];
3388
3389	if (pTextureState->name != SVGA3D_RS_INVALID)
3390	vmsvga3dSetTextureState(pThis, pContext->id, 1, pTextureState);
3391	}
3392	}
3393	Log(("vmsvga3dChangeMode: Recreate texture state END\n"));
3394
3395	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_SCISSORRECT)
3396	vmsvga3dSetScissorRect(pThis, cid, &pContext->state.RectScissor);
3397	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_ZRANGE)
3398	vmsvga3dSetZRange(pThis, cid, pContext->state.zRange);
3399	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
3400	vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
3401	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VERTEXSHADER)
3402	vmsvga3dShaderSet(pThis, cid, SVGA3D_SHADERTYPE_VS, pContext->state.shidVertex);
3403	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_PIXELSHADER)
3404	vmsvga3dShaderSet(pThis, cid, SVGA3D_SHADERTYPE_PS, pContext->state.shidPixel);
3405	/** @todo restore more state data */
3406	#endif /* #ifdef VMSVGA3D_DIRECT3D9_RESET */
3407	}
3408	}
3409	return VINF_SUCCESS;
3410	}
3411
3412
3413	int vmsvga3dSetTransform(PVGASTATE pThis, uint32_t cid, SVGA3dTransformType type, float matrix[16])
3414	{
3415	D3DTRANSFORMSTATETYPE d3dState;
3416	HRESULT hr;
3417	PVMSVGA3DCONTEXT pContext;
3418	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
3419	AssertReturn(pState, VERR_NO_MEMORY);
3420
3421	Log(("vmsvga3dSetTransform %x %s\n", cid, vmsvgaTransformToString(type)));
3422
3423	if ( cid >= pState->cContexts
3424	\|\| pState->paContext[cid].id != cid)
3425	{
3426	Log(("vmsvga3dSetTransform invalid context id!\n"));
3427	return VERR_INVALID_PARAMETER;
3428	}
3429	pContext = &pState->paContext[cid];
3430
3431	switch (type)
3432	{
3433	case SVGA3D_TRANSFORM_VIEW:
3434	d3dState = D3DTS_VIEW;
3435	break;
3436	case SVGA3D_TRANSFORM_PROJECTION:
3437	d3dState = D3DTS_PROJECTION;
3438	break;
3439	case SVGA3D_TRANSFORM_TEXTURE0:
3440	d3dState = D3DTS_TEXTURE0;
3441	break;
3442	case SVGA3D_TRANSFORM_TEXTURE1:
3443	d3dState = D3DTS_TEXTURE1;
3444	break;
3445	case SVGA3D_TRANSFORM_TEXTURE2:
3446	d3dState = D3DTS_TEXTURE2;
3447	break;
3448	case SVGA3D_TRANSFORM_TEXTURE3:
3449	d3dState = D3DTS_TEXTURE3;
3450	break;
3451	case SVGA3D_TRANSFORM_TEXTURE4:
3452	d3dState = D3DTS_TEXTURE4;
3453	break;
3454	case SVGA3D_TRANSFORM_TEXTURE5:
3455	d3dState = D3DTS_TEXTURE5;
3456	break;
3457	case SVGA3D_TRANSFORM_TEXTURE6:
3458	d3dState = D3DTS_TEXTURE6;
3459	break;
3460	case SVGA3D_TRANSFORM_TEXTURE7:
3461	d3dState = D3DTS_TEXTURE7;
3462	break;
3463	case SVGA3D_TRANSFORM_WORLD:
3464	d3dState = D3DTS_WORLD;
3465	break;
3466	case SVGA3D_TRANSFORM_WORLD1:
3467	d3dState = D3DTS_WORLD1;
3468	break;
3469	case SVGA3D_TRANSFORM_WORLD2:
3470	d3dState = D3DTS_WORLD2;
3471	break;
3472	case SVGA3D_TRANSFORM_WORLD3:
3473	d3dState = D3DTS_WORLD3;
3474	break;
3475
3476	default:
3477	Log(("vmsvga3dSetTransform: unknown type!!\n"));
3478	return VERR_INVALID_PARAMETER;
3479	}
3480
3481	/* Save this matrix for vm state save/restore. */
3482	pContext->state.aTransformState[type].fValid = true;
3483	memcpy(pContext->state.aTransformState[type].matrix, matrix, sizeof(pContext->state.aTransformState[type].matrix));
3484	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_TRANSFORM;
3485
3486	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)));
3487	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)));
3488	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)));
3489	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)));
3490	hr = pContext->pDevice->SetTransform(d3dState, (const D3DMATRIX *)matrix);
3491	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTransform: SetTransform failed with %x\n", hr), VERR_INTERNAL_ERROR);
3492	return VINF_SUCCESS;
3493	}
3494
3495	int vmsvga3dSetZRange(PVGASTATE pThis, uint32_t cid, SVGA3dZRange zRange)
3496	{
3497	D3DVIEWPORT9 viewport;
3498	HRESULT hr;
3499	PVMSVGA3DCONTEXT pContext;
3500	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
3501	AssertReturn(pState, VERR_NO_MEMORY);
3502
3503	Log(("vmsvga3dSetZRange %x min=%d max=%d\n", cid, (uint32_t)(zRange.min * 100.0), (uint32_t)(zRange.max * 100.0)));
3504
3505	if ( cid >= pState->cContexts
3506	\|\| pState->paContext[cid].id != cid)
3507	{
3508	Log(("vmsvga3dSetZRange invalid context id!\n"));
3509	return VERR_INVALID_PARAMETER;
3510	}
3511	pContext = &pState->paContext[cid];
3512	pContext->state.zRange = zRange;
3513	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_ZRANGE;
3514
3515	hr = pContext->pDevice->GetViewport(&viewport);
3516	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetZRange: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
3517
3518	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)));
3519	/* @todo convert the depth range from -1-1 to 0-1 although we shouldn't be getting such values in the first place... */
3520	if (zRange.min < 0.0)
3521	zRange.min = 0.0;
3522	if (zRange.max > 1.0)
3523	zRange.max = 1.0;
3524
3525	viewport.MinZ = zRange.min;
3526	viewport.MaxZ = zRange.max;
3527	hr = pContext->pDevice->SetViewport(&viewport);
3528	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetZRange: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
3529	return VINF_SUCCESS;
3530	}
3531
3532	/**
3533	* Convert SVGA blend op value to its D3D equivalent
3534	*/
3535	static DWORD vmsvga3dBlendOp2D3D(uint32_t blendOp, DWORD defaultBlendOp)
3536	{
3537	switch (blendOp)
3538	{
3539	case SVGA3D_BLENDOP_ZERO:
3540	return D3DBLEND_ZERO;
3541	case SVGA3D_BLENDOP_ONE:
3542	return D3DBLEND_ONE;
3543	case SVGA3D_BLENDOP_SRCCOLOR:
3544	return D3DBLEND_SRCCOLOR;
3545	case SVGA3D_BLENDOP_INVSRCCOLOR:
3546	return D3DBLEND_INVSRCCOLOR;
3547	case SVGA3D_BLENDOP_SRCALPHA:
3548	return D3DBLEND_SRCALPHA;
3549	case SVGA3D_BLENDOP_INVSRCALPHA:
3550	return D3DBLEND_INVSRCALPHA;
3551	case SVGA3D_BLENDOP_DESTALPHA:
3552	return D3DBLEND_DESTALPHA;
3553	case SVGA3D_BLENDOP_INVDESTALPHA:
3554	return D3DBLEND_INVDESTALPHA;
3555	case SVGA3D_BLENDOP_DESTCOLOR:
3556	return D3DBLEND_DESTCOLOR;
3557	case SVGA3D_BLENDOP_INVDESTCOLOR:
3558	return D3DBLEND_INVDESTCOLOR;
3559	case SVGA3D_BLENDOP_SRCALPHASAT:
3560	return D3DBLEND_SRCALPHASAT;
3561	case SVGA3D_BLENDOP_BLENDFACTOR:
3562	return D3DBLEND_BLENDFACTOR;
3563	case SVGA3D_BLENDOP_INVBLENDFACTOR:
3564	return D3DBLEND_INVBLENDFACTOR;
3565	default:
3566	AssertFailed();
3567	return defaultBlendOp;
3568	}
3569	}
3570
3571	int vmsvga3dSetRenderState(PVGASTATE pThis, uint32_t cid, uint32_t cRenderStates, SVGA3dRenderState *pRenderState)
3572	{
3573	DWORD val;
3574	HRESULT hr;
3575	PVMSVGA3DCONTEXT pContext;
3576	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
3577	AssertReturn(pState, VERR_NO_MEMORY);
3578
3579	Log(("vmsvga3dSetRenderState %x cRenderStates=%d\n", cid, cRenderStates));
3580
3581	if ( cid >= pState->cContexts
3582	\|\| pState->paContext[cid].id != cid)
3583	{
3584	Log(("vmsvga3dSetRenderState invalid context id!\n"));
3585	return VERR_INVALID_PARAMETER;
3586	}
3587	pContext = &pState->paContext[cid];
3588
3589	for (unsigned i = 0; i < cRenderStates; i++)
3590	{
3591	D3DRENDERSTATETYPE renderState = D3DRS_FORCE_DWORD;
3592
3593	Log(("vmsvga3dSetRenderState: state=%s (%d) val=%x\n", vmsvga3dGetRenderStateName(pRenderState[i].state), pRenderState[i].state, pRenderState[i].uintValue));
3594	/* Save the render state for vm state saving. */
3595	if (pRenderState[i].state < SVGA3D_RS_MAX)
3596	pContext->state.aRenderState[pRenderState[i].state] = pRenderState[i];
3597
3598	switch (pRenderState[i].state)
3599	{
3600	case SVGA3D_RS_ZENABLE: /* SVGA3dBool */
3601	renderState = D3DRS_ZENABLE;
3602	val = pRenderState[i].uintValue;
3603	Assert(val == D3DZB_FALSE \|\| val == D3DZB_TRUE);
3604	break;
3605
3606	case SVGA3D_RS_ZWRITEENABLE: /* SVGA3dBool */
3607	renderState = D3DRS_ZWRITEENABLE;
3608	val = pRenderState[i].uintValue;
3609	break;
3610
3611	case SVGA3D_RS_ALPHATESTENABLE: /* SVGA3dBool */
3612	renderState = D3DRS_ALPHATESTENABLE;
3613	val = pRenderState[i].uintValue;
3614	break;
3615
3616	case SVGA3D_RS_DITHERENABLE: /* SVGA3dBool */
3617	renderState = D3DRS_DITHERENABLE;
3618	val = pRenderState[i].uintValue;
3619	break;
3620
3621	case SVGA3D_RS_BLENDENABLE: /* SVGA3dBool */
3622	renderState = D3DRS_ALPHABLENDENABLE;
3623	val = pRenderState[i].uintValue;
3624	break;
3625
3626	case SVGA3D_RS_FOGENABLE: /* SVGA3dBool */
3627	renderState = D3DRS_FOGENABLE;
3628	val = pRenderState[i].uintValue;
3629	break;
3630
3631	case SVGA3D_RS_SPECULARENABLE: /* SVGA3dBool */
3632	renderState = D3DRS_SPECULARENABLE;
3633	val = pRenderState[i].uintValue;
3634	break;
3635
3636	case SVGA3D_RS_LIGHTINGENABLE: /* SVGA3dBool */
3637	renderState = D3DRS_LIGHTING;
3638	val = pRenderState[i].uintValue;
3639	break;
3640
3641	case SVGA3D_RS_NORMALIZENORMALS: /* SVGA3dBool */
3642	renderState = D3DRS_NORMALIZENORMALS;
3643	val = pRenderState[i].uintValue;
3644	break;
3645
3646	case SVGA3D_RS_POINTSPRITEENABLE: /* SVGA3dBool */
3647	renderState = D3DRS_POINTSPRITEENABLE;
3648	val = pRenderState[i].uintValue;
3649	break;
3650
3651	case SVGA3D_RS_POINTSCALEENABLE: /* SVGA3dBool */
3652	renderState = D3DRS_POINTSCALEENABLE;
3653	val = pRenderState[i].uintValue;
3654	break;
3655
3656	case SVGA3D_RS_POINTSIZE: /* float */
3657	renderState = D3DRS_POINTSIZE;
3658	val = pRenderState[i].uintValue;
3659	Log(("SVGA3D_RS_POINTSIZE: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
3660	break;
3661
3662	case SVGA3D_RS_POINTSIZEMIN: /* float */
3663	renderState = D3DRS_POINTSIZE_MIN;
3664	val = pRenderState[i].uintValue;
3665	Log(("SVGA3D_RS_POINTSIZEMIN: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
3666	break;
3667
3668	case SVGA3D_RS_POINTSIZEMAX: /* float */
3669	renderState = D3DRS_POINTSIZE_MAX;
3670	val = pRenderState[i].uintValue;
3671	Log(("SVGA3D_RS_POINTSIZEMAX: %d\n", (uint32_t) (pRenderState[i].floatValue * 100.0)));
3672	break;
3673
3674	case SVGA3D_RS_POINTSCALE_A: /* float */
3675	renderState = D3DRS_POINTSCALE_A;
3676	val = pRenderState[i].uintValue;
3677	break;
3678
3679	case SVGA3D_RS_POINTSCALE_B: /* float */
3680	renderState = D3DRS_POINTSCALE_B;
3681	val = pRenderState[i].uintValue;
3682	break;
3683
3684	case SVGA3D_RS_POINTSCALE_C: /* float */
3685	renderState = D3DRS_POINTSCALE_C;
3686	val = pRenderState[i].uintValue;
3687	break;
3688
3689	case SVGA3D_RS_AMBIENT: /* SVGA3dColor - identical */
3690	renderState = D3DRS_AMBIENT;
3691	val = pRenderState[i].uintValue;
3692	break;
3693
3694	case SVGA3D_RS_CLIPPLANEENABLE: /* SVGA3dClipPlanes - identical */
3695	renderState = D3DRS_CLIPPLANEENABLE;
3696	val = pRenderState[i].uintValue;
3697	break;
3698
3699	case SVGA3D_RS_FOGCOLOR: /* SVGA3dColor - identical */
3700	renderState = D3DRS_FOGCOLOR;
3701	val = pRenderState[i].uintValue;
3702	break;
3703
3704	case SVGA3D_RS_FOGSTART: /* float */
3705	renderState = D3DRS_FOGSTART;
3706	val = pRenderState[i].uintValue;
3707	break;
3708
3709	case SVGA3D_RS_FOGEND: /* float */
3710	renderState = D3DRS_FOGEND;
3711	val = pRenderState[i].uintValue;
3712	break;
3713
3714	case SVGA3D_RS_FOGDENSITY: /* float */
3715	renderState = D3DRS_FOGDENSITY;
3716	val = pRenderState[i].uintValue;
3717	break;
3718
3719	case SVGA3D_RS_RANGEFOGENABLE: /* SVGA3dBool */
3720	renderState = D3DRS_RANGEFOGENABLE;
3721	val = pRenderState[i].uintValue;
3722	break;
3723
3724	case SVGA3D_RS_FOGMODE: /* SVGA3dFogMode */
3725	{
3726	SVGA3dFogMode mode;
3727	mode.uintValue = pRenderState[i].uintValue;
3728
3729	switch (mode.s.function)
3730	{
3731	case SVGA3D_FOGFUNC_INVALID:
3732	val = D3DFOG_NONE;
3733	break;
3734	case SVGA3D_FOGFUNC_EXP:
3735	val = D3DFOG_EXP;
3736	break;
3737	case SVGA3D_FOGFUNC_EXP2:
3738	val = D3DFOG_EXP2;
3739	break;
3740	case SVGA3D_FOGFUNC_LINEAR:
3741	val = D3DFOG_LINEAR;
3742	break;
3743	case SVGA3D_FOGFUNC_PER_VERTEX: /* unable to find a d3d9 equivalent */
3744	AssertMsgFailedReturn(("Unsupported fog function SVGA3D_FOGFUNC_PER_VERTEX\n"), VERR_INTERNAL_ERROR);
3745	break;
3746	default:
3747	AssertMsgFailedReturn(("Unexpected fog function %d\n", mode.s.function), VERR_INTERNAL_ERROR);
3748	break;
3749	}
3750
3751	/* The fog type determines the render state. */
3752	switch (mode.s.type)
3753	{
3754	case SVGA3D_FOGTYPE_VERTEX:
3755	renderState = D3DRS_FOGVERTEXMODE;
3756	break;
3757	case SVGA3D_FOGTYPE_PIXEL:
3758	renderState = D3DRS_FOGTABLEMODE;
3759	break;
3760	default:
3761	AssertMsgFailedReturn(("Unexpected fog type %d\n", mode.s.type), VERR_INTERNAL_ERROR);
3762	break;
3763	}
3764
3765	/* Set the fog base to depth or range. */
3766	switch (mode.s.base)
3767	{
3768	case SVGA3D_FOGBASE_DEPTHBASED:
3769	hr = pContext->pDevice->SetRenderState(D3DRS_RANGEFOGENABLE, FALSE);
3770	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState SVGA3D_FOGBASE_DEPTHBASED failed with %x\n", hr), VERR_INTERNAL_ERROR);
3771	break;
3772	case SVGA3D_FOGBASE_RANGEBASED:
3773	hr = pContext->pDevice->SetRenderState(D3DRS_RANGEFOGENABLE, TRUE);
3774	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState SVGA3D_FOGBASE_RANGEBASED failed with %x\n", hr), VERR_INTERNAL_ERROR);
3775	break;
3776	default:
3777	/* ignore */
3778	AssertMsgFailed(("Unexpected fog base %d\n", mode.s.base));
3779	break;
3780	}
3781	break;
3782	}
3783
3784	case SVGA3D_RS_FILLMODE: /* SVGA3dFillMode */
3785	{
3786	SVGA3dFillMode mode;
3787
3788	mode.uintValue = pRenderState[i].uintValue;
3789
3790	switch (mode.s.mode)
3791	{
3792	case SVGA3D_FILLMODE_POINT:
3793	val = D3DFILL_POINT;
3794	break;
3795	case SVGA3D_FILLMODE_LINE:
3796	val = D3DFILL_WIREFRAME;
3797	break;
3798	case SVGA3D_FILLMODE_FILL:
3799	val = D3DFILL_SOLID;
3800	break;
3801	default:
3802	AssertMsgFailedReturn(("Unexpected fill mode %d\n", mode.s.mode), VERR_INTERNAL_ERROR);
3803	break;
3804	}
3805	/* @todo ignoring face for now. */
3806	renderState = D3DRS_FILLMODE;
3807	break;
3808	}
3809
3810	case SVGA3D_RS_SHADEMODE: /* SVGA3dShadeMode */
3811	renderState = D3DRS_SHADEMODE;
3812	AssertCompile(D3DSHADE_FLAT == SVGA3D_SHADEMODE_FLAT);
3813	val = pRenderState[i].uintValue; /* SVGA3dShadeMode == D3DSHADEMODE */
3814	break;
3815
3816	case SVGA3D_RS_LINEPATTERN: /* SVGA3dLinePattern */
3817	/* No longer supported by d3d; mesagl comments suggest not all backends support it */
3818	/* @todo */
3819	Log(("WARNING: SVGA3D_RS_LINEPATTERN %x not supported!!\n", pRenderState[i].uintValue));
3820	/*
3821	renderState = D3DRS_LINEPATTERN;
3822	val = pRenderState[i].uintValue;
3823	*/
3824	break;
3825
3826	case SVGA3D_RS_SRCBLEND: /* SVGA3dBlendOp */
3827	renderState = D3DRS_SRCBLEND;
3828	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ONE /* default */);
3829	break;
3830
3831	case SVGA3D_RS_DSTBLEND: /* SVGA3dBlendOp */
3832	renderState = D3DRS_DESTBLEND;
3833	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ZERO /* default */);
3834	break;
3835
3836	case SVGA3D_RS_BLENDEQUATION: /* SVGA3dBlendEquation - identical */
3837	AssertCompile(SVGA3D_BLENDEQ_MAXIMUM == D3DBLENDOP_MAX);
3838	renderState = D3DRS_BLENDOP;
3839	val = pRenderState[i].uintValue;
3840	break;
3841
3842	case SVGA3D_RS_CULLMODE: /* SVGA3dFace */
3843	{
3844	switch (pRenderState[i].uintValue)
3845	{
3846	case SVGA3D_FACE_NONE:
3847	val = D3DCULL_NONE;
3848	break;
3849	case SVGA3D_FACE_FRONT:
3850	val = D3DCULL_CW;
3851	break;
3852	case SVGA3D_FACE_BACK:
3853	val = D3DCULL_CCW;
3854	break;
3855	case SVGA3D_FACE_FRONT_BACK:
3856	AssertFailed();
3857	val = D3DCULL_CW;
3858	break;
3859	default:
3860	AssertMsgFailedReturn(("Unexpected cull mode %d\n", pRenderState[i].uintValue), VERR_INTERNAL_ERROR);
3861	break;
3862	}
3863	renderState = D3DRS_CULLMODE;
3864	break;
3865	}
3866
3867	case SVGA3D_RS_ZFUNC: /* SVGA3dCmpFunc - identical */
3868	AssertCompile(SVGA3D_CMP_ALWAYS == D3DCMP_ALWAYS);
3869	renderState = D3DRS_ZFUNC;
3870	val = pRenderState[i].uintValue;
3871	break;
3872
3873	case SVGA3D_RS_ALPHAFUNC: /* SVGA3dCmpFunc - identical */
3874	renderState = D3DRS_ALPHAFUNC;
3875	val = pRenderState[i].uintValue;
3876	break;
3877
3878	case SVGA3D_RS_STENCILENABLE: /* SVGA3dBool */
3879	renderState = D3DRS_STENCILENABLE;
3880	val = pRenderState[i].uintValue;
3881	break;
3882
3883	case SVGA3D_RS_STENCILREF: /* uint32_t */
3884	renderState = D3DRS_STENCILREF;
3885	val = pRenderState[i].uintValue;
3886	break;
3887
3888	case SVGA3D_RS_STENCILMASK: /* uint32_t */
3889	renderState = D3DRS_STENCILMASK;
3890	val = pRenderState[i].uintValue;
3891	break;
3892
3893	case SVGA3D_RS_STENCILWRITEMASK: /* uint32_t */
3894	renderState = D3DRS_STENCILWRITEMASK;
3895	val = pRenderState[i].uintValue;
3896	break;
3897
3898	case SVGA3D_RS_STENCILFUNC: /* SVGA3dCmpFunc - identical */
3899	renderState = D3DRS_STENCILFUNC;
3900	val = pRenderState[i].uintValue;
3901	break;
3902
3903	case SVGA3D_RS_STENCILFAIL: /* SVGA3dStencilOp - identical */
3904	AssertCompile(D3DSTENCILOP_KEEP == SVGA3D_STENCILOP_KEEP);
3905	AssertCompile(D3DSTENCILOP_DECR == SVGA3D_STENCILOP_DECR);
3906	renderState = D3DRS_STENCILFAIL;
3907	val = pRenderState[i].uintValue;
3908	break;
3909
3910	case SVGA3D_RS_STENCILZFAIL: /* SVGA3dStencilOp - identical */
3911	renderState = D3DRS_STENCILZFAIL;
3912	val = pRenderState[i].uintValue;
3913	break;
3914
3915	case SVGA3D_RS_STENCILPASS: /* SVGA3dStencilOp - identical */
3916	renderState = D3DRS_STENCILPASS;
3917	val = pRenderState[i].uintValue;
3918	break;
3919
3920	case SVGA3D_RS_ALPHAREF: /* float (0.0 .. 1.0) */
3921	renderState = D3DRS_ALPHAREF;
3922	val = pRenderState[i].uintValue;
3923	break;
3924
3925	case SVGA3D_RS_FRONTWINDING: /* SVGA3dFrontWinding */
3926	Assert(pRenderState[i].uintValue == SVGA3D_FRONTWINDING_CW);
3927	/*
3928	renderState = D3DRS_FRONTWINDING; //D3DRS_TWOSIDEDSTENCILMODE
3929	val = pRenderState[i].uintValue;
3930	*/
3931	break;
3932
3933	case SVGA3D_RS_COORDINATETYPE: /* SVGA3dCoordinateType */
3934	Assert(pRenderState[i].uintValue == SVGA3D_COORDINATE_LEFTHANDED);
3935	/* @todo setup a view matrix to scale the world space by -1 in the z-direction for right handed coordinates. */
3936	/*
3937	renderState = D3DRS_COORDINATETYPE;
3938	val = pRenderState[i].uintValue;
3939	*/
3940	break;
3941
3942	case SVGA3D_RS_ZBIAS: /* float */
3943	/* @todo unknown meaning; depth bias is not identical
3944	renderState = D3DRS_DEPTHBIAS;
3945	val = pRenderState[i].uintValue;
3946	*/
3947	Log(("vmsvga3dSetRenderState: WARNING unsupported SVGA3D_RS_ZBIAS\n"));
3948	break;
3949
3950	case SVGA3D_RS_SLOPESCALEDEPTHBIAS: /* float */
3951	renderState = D3DRS_SLOPESCALEDEPTHBIAS;
3952	val = pRenderState[i].uintValue;
3953	break;
3954
3955	case SVGA3D_RS_DEPTHBIAS: /* float */
3956	renderState = D3DRS_DEPTHBIAS;
3957	val = pRenderState[i].uintValue;
3958	break;
3959
3960	case SVGA3D_RS_COLORWRITEENABLE: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
3961	renderState = D3DRS_COLORWRITEENABLE;
3962	val = pRenderState[i].uintValue;
3963	break;
3964
3965	case SVGA3D_RS_VERTEXMATERIALENABLE: /* SVGA3dBool */
3966	//AssertFailed();
3967	renderState = D3DRS_INDEXEDVERTEXBLENDENABLE; /* correct?? */
3968	val = pRenderState[i].uintValue;
3969	break;
3970
3971	case SVGA3D_RS_DIFFUSEMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3972	AssertCompile(D3DMCS_COLOR2 == SVGA3D_VERTEXMATERIAL_SPECULAR);
3973	renderState = D3DRS_DIFFUSEMATERIALSOURCE;
3974	val = pRenderState[i].uintValue;
3975	break;
3976
3977	case SVGA3D_RS_SPECULARMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3978	renderState = D3DRS_SPECULARMATERIALSOURCE;
3979	val = pRenderState[i].uintValue;
3980	break;
3981
3982	case SVGA3D_RS_AMBIENTMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3983	renderState = D3DRS_AMBIENTMATERIALSOURCE;
3984	val = pRenderState[i].uintValue;
3985	break;
3986
3987	case SVGA3D_RS_EMISSIVEMATERIALSOURCE: /* SVGA3dVertexMaterial - identical */
3988	renderState = D3DRS_EMISSIVEMATERIALSOURCE;
3989	val = pRenderState[i].uintValue;
3990	break;
3991
3992	case SVGA3D_RS_TEXTUREFACTOR: /* SVGA3dColor - identical */
3993	renderState = D3DRS_TEXTUREFACTOR;
3994	val = pRenderState[i].uintValue;
3995	break;
3996
3997	case SVGA3D_RS_LOCALVIEWER: /* SVGA3dBool */
3998	renderState = D3DRS_LOCALVIEWER;
3999	val = pRenderState[i].uintValue;
4000	break;
4001
4002	case SVGA3D_RS_SCISSORTESTENABLE: /* SVGA3dBool */
4003	renderState = D3DRS_SCISSORTESTENABLE;
4004	val = pRenderState[i].uintValue;
4005	break;
4006
4007	case SVGA3D_RS_BLENDCOLOR: /* SVGA3dColor - identical */
4008	renderState = D3DRS_BLENDFACTOR;
4009	val = pRenderState[i].uintValue;
4010	break;
4011
4012	case SVGA3D_RS_STENCILENABLE2SIDED: /* SVGA3dBool */
4013	renderState = D3DRS_TWOSIDEDSTENCILMODE;
4014	val = pRenderState[i].uintValue;
4015	break;
4016
4017	case SVGA3D_RS_CCWSTENCILFUNC: /* SVGA3dCmpFunc - identical */
4018	renderState = D3DRS_CCW_STENCILFUNC;
4019	val = pRenderState[i].uintValue;
4020	break;
4021
4022	case SVGA3D_RS_CCWSTENCILFAIL: /* SVGA3dStencilOp - identical */
4023	renderState = D3DRS_CCW_STENCILFAIL;
4024	val = pRenderState[i].uintValue;
4025	break;
4026
4027	case SVGA3D_RS_CCWSTENCILZFAIL: /* SVGA3dStencilOp - identical */
4028	renderState = D3DRS_CCW_STENCILZFAIL;
4029	val = pRenderState[i].uintValue;
4030	break;
4031
4032	case SVGA3D_RS_CCWSTENCILPASS: /* SVGA3dStencilOp - identical */
4033	renderState = D3DRS_CCW_STENCILPASS;
4034	val = pRenderState[i].uintValue;
4035	break;
4036
4037	case SVGA3D_RS_VERTEXBLEND: /* SVGA3dVertexBlendFlags - identical */
4038	AssertCompile(SVGA3D_VBLEND_DISABLE == D3DVBF_DISABLE);
4039	renderState = D3DRS_VERTEXBLEND;
4040	val = pRenderState[i].uintValue;
4041	break;
4042
4043	case SVGA3D_RS_OUTPUTGAMMA: /* float */
4044	//AssertFailed();
4045	/*
4046	D3DRS_SRGBWRITEENABLE ??
4047	renderState = D3DRS_OUTPUTGAMMA;
4048	val = pRenderState[i].uintValue;
4049	*/
4050	break;
4051
4052	case SVGA3D_RS_ZVISIBLE: /* SVGA3dBool */
4053	AssertFailed();
4054	/*
4055	renderState = D3DRS_ZVISIBLE;
4056	val = pRenderState[i].uintValue;
4057	*/
4058	break;
4059
4060	case SVGA3D_RS_LASTPIXEL: /* SVGA3dBool */
4061	renderState = D3DRS_LASTPIXEL;
4062	val = pRenderState[i].uintValue;
4063	break;
4064
4065	case SVGA3D_RS_CLIPPING: /* SVGA3dBool */
4066	renderState = D3DRS_CLIPPING;
4067	val = pRenderState[i].uintValue;
4068	break;
4069
4070	case SVGA3D_RS_WRAP0: /* SVGA3dWrapFlags - identical */
4071	Assert(SVGA3D_WRAPCOORD_3 == D3DWRAPCOORD_3);
4072	renderState = D3DRS_WRAP0;
4073	val = pRenderState[i].uintValue;
4074	break;
4075
4076	case SVGA3D_RS_WRAP1: /* SVGA3dWrapFlags - identical */
4077	renderState = D3DRS_WRAP1;
4078	val = pRenderState[i].uintValue;
4079	break;
4080
4081	case SVGA3D_RS_WRAP2: /* SVGA3dWrapFlags - identical */
4082	renderState = D3DRS_WRAP2;
4083	val = pRenderState[i].uintValue;
4084	break;
4085
4086	case SVGA3D_RS_WRAP3: /* SVGA3dWrapFlags - identical */
4087	renderState = D3DRS_WRAP3;
4088	val = pRenderState[i].uintValue;
4089	break;
4090
4091	case SVGA3D_RS_WRAP4: /* SVGA3dWrapFlags - identical */
4092	renderState = D3DRS_WRAP4;
4093	val = pRenderState[i].uintValue;
4094	break;
4095
4096	case SVGA3D_RS_WRAP5: /* SVGA3dWrapFlags - identical */
4097	renderState = D3DRS_WRAP5;
4098	val = pRenderState[i].uintValue;
4099	break;
4100
4101	case SVGA3D_RS_WRAP6: /* SVGA3dWrapFlags - identical */
4102	renderState = D3DRS_WRAP6;
4103	val = pRenderState[i].uintValue;
4104	break;
4105
4106	case SVGA3D_RS_WRAP7: /* SVGA3dWrapFlags - identical */
4107	renderState = D3DRS_WRAP7;
4108	val = pRenderState[i].uintValue;
4109	break;
4110
4111	case SVGA3D_RS_WRAP8: /* SVGA3dWrapFlags - identical */
4112	renderState = D3DRS_WRAP8;
4113	val = pRenderState[i].uintValue;
4114	break;
4115
4116	case SVGA3D_RS_WRAP9: /* SVGA3dWrapFlags - identical */
4117	renderState = D3DRS_WRAP9;
4118	val = pRenderState[i].uintValue;
4119	break;
4120
4121	case SVGA3D_RS_WRAP10: /* SVGA3dWrapFlags - identical */
4122	renderState = D3DRS_WRAP10;
4123	val = pRenderState[i].uintValue;
4124	break;
4125
4126	case SVGA3D_RS_WRAP11: /* SVGA3dWrapFlags - identical */
4127	renderState = D3DRS_WRAP11;
4128	val = pRenderState[i].uintValue;
4129	break;
4130
4131	case SVGA3D_RS_WRAP12: /* SVGA3dWrapFlags - identical */
4132	renderState = D3DRS_WRAP12;
4133	val = pRenderState[i].uintValue;
4134	break;
4135
4136	case SVGA3D_RS_WRAP13: /* SVGA3dWrapFlags - identical */
4137	renderState = D3DRS_WRAP13;
4138	val = pRenderState[i].uintValue;
4139	break;
4140
4141	case SVGA3D_RS_WRAP14: /* SVGA3dWrapFlags - identical */
4142	renderState = D3DRS_WRAP14;
4143	val = pRenderState[i].uintValue;
4144	break;
4145
4146	case SVGA3D_RS_WRAP15: /* SVGA3dWrapFlags - identical */
4147	renderState = D3DRS_WRAP15;
4148	val = pRenderState[i].uintValue;
4149	break;
4150
4151	case SVGA3D_RS_MULTISAMPLEANTIALIAS: /* SVGA3dBool */
4152	renderState = D3DRS_MULTISAMPLEANTIALIAS;
4153	val = pRenderState[i].uintValue;
4154	break;
4155
4156	case SVGA3D_RS_MULTISAMPLEMASK: /* uint32_t */
4157	renderState = D3DRS_MULTISAMPLEMASK;
4158	val = pRenderState[i].uintValue;
4159	break;
4160
4161	case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE: /* SVGA3dBool */
4162	renderState = D3DRS_INDEXEDVERTEXBLENDENABLE;
4163	val = pRenderState[i].uintValue;
4164	break;
4165
4166	case SVGA3D_RS_TWEENFACTOR: /* float */
4167	renderState = D3DRS_TWEENFACTOR;
4168	val = pRenderState[i].uintValue;
4169	break;
4170
4171	case SVGA3D_RS_ANTIALIASEDLINEENABLE: /* SVGA3dBool */
4172	renderState = D3DRS_ANTIALIASEDLINEENABLE;
4173	val = pRenderState[i].uintValue;
4174	break;
4175
4176	case SVGA3D_RS_COLORWRITEENABLE1: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
4177	renderState = D3DRS_COLORWRITEENABLE1;
4178	val = pRenderState[i].uintValue;
4179	break;
4180
4181	case SVGA3D_RS_COLORWRITEENABLE2: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
4182	renderState = D3DRS_COLORWRITEENABLE2;
4183	val = pRenderState[i].uintValue;
4184	break;
4185
4186	case SVGA3D_RS_COLORWRITEENABLE3: /* SVGA3dColorMask - identical to D3DCOLORWRITEENABLE_* */
4187	renderState = D3DRS_COLORWRITEENABLE3;
4188	val = pRenderState[i].uintValue;
4189	break;
4190
4191	case SVGA3D_RS_SEPARATEALPHABLENDENABLE: /* SVGA3dBool */
4192	renderState = D3DRS_SEPARATEALPHABLENDENABLE;
4193	val = pRenderState[i].uintValue;
4194	break;
4195
4196	case SVGA3D_RS_SRCBLENDALPHA: /* SVGA3dBlendOp */
4197	renderState = D3DRS_SRCBLENDALPHA;
4198	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ONE /* default */);
4199	break;
4200
4201	case SVGA3D_RS_DSTBLENDALPHA: /* SVGA3dBlendOp */
4202	renderState = D3DRS_DESTBLENDALPHA;
4203	val = vmsvga3dBlendOp2D3D(pRenderState[i].uintValue, D3DBLEND_ZERO /* default */);
4204	break;
4205
4206	case SVGA3D_RS_BLENDEQUATIONALPHA: /* SVGA3dBlendEquation - identical */
4207	renderState = D3DRS_BLENDOPALPHA;
4208	val = pRenderState[i].uintValue;
4209	break;
4210
4211	case SVGA3D_RS_TRANSPARENCYANTIALIAS: /* SVGA3dTransparencyAntialiasType */
4212	AssertFailed();
4213	/*
4214	renderState = D3DRS_TRANSPARENCYANTIALIAS;
4215	val = pRenderState[i].uintValue;
4216	*/
4217	break;
4218
4219	case SVGA3D_RS_LINEAA: /* SVGA3dBool */
4220	renderState = D3DRS_ANTIALIASEDLINEENABLE;
4221	val = pRenderState[i].uintValue;
4222	break;
4223
4224	case SVGA3D_RS_LINEWIDTH: /* float */
4225	AssertFailed();
4226	/*
4227	renderState = D3DRS_LINEWIDTH;
4228	val = pRenderState[i].uintValue;
4229	*/
4230	break;
4231	}
4232
4233	if (renderState != D3DRS_FORCE_DWORD)
4234	{
4235	hr = pContext->pDevice->SetRenderState(renderState, val);
4236	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderState: SetRenderState failed with %x\n", hr), VERR_INTERNAL_ERROR);
4237	}
4238	}
4239
4240	return VINF_SUCCESS;
4241	}
4242
4243	int vmsvga3dSetRenderTarget(PVGASTATE pThis, uint32_t cid, SVGA3dRenderTargetType type, SVGA3dSurfaceImageId target)
4244	{
4245	HRESULT hr;
4246	PVMSVGA3DCONTEXT pContext;
4247	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
4248	PVMSVGA3DSURFACE pRenderTarget;
4249
4250	AssertReturn(pState, VERR_NO_MEMORY);
4251	AssertReturn(type < SVGA3D_RT_MAX, VERR_INVALID_PARAMETER);
4252	AssertReturn(target.face == 0, VERR_INVALID_PARAMETER);
4253	AssertReturn(target.mipmap == 0, VERR_INVALID_PARAMETER);
4254
4255	Log(("vmsvga3dSetRenderTarget cid=%x type=%x surface id=%x\n", cid, type, target.sid));
4256
4257	if ( cid >= pState->cContexts
4258	\|\| pState->paContext[cid].id != cid)
4259	{
4260	Log(("vmsvga3dSetRenderTarget invalid context id!\n"));
4261	return VERR_INVALID_PARAMETER;
4262	}
4263	pContext = &pState->paContext[cid];
4264
4265	/* Save for vm state save/restore. */
4266	pContext->state.aRenderTargets[type] = target.sid;
4267
4268	if (target.sid == SVGA3D_INVALID_ID)
4269	{
4270	/* Disable render target. */
4271	switch (type)
4272	{
4273	case SVGA3D_RT_DEPTH:
4274	hr = pContext->pDevice->SetDepthStencilSurface(NULL);
4275	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
4276	break;
4277
4278	case SVGA3D_RT_STENCIL:
4279	/* ignore; correct?? */
4280	break;
4281
4282	case SVGA3D_RT_COLOR0:
4283	case SVGA3D_RT_COLOR1:
4284	case SVGA3D_RT_COLOR2:
4285	case SVGA3D_RT_COLOR3:
4286	case SVGA3D_RT_COLOR4:
4287	case SVGA3D_RT_COLOR5:
4288	case SVGA3D_RT_COLOR6:
4289	case SVGA3D_RT_COLOR7:
4290	pContext->sidRenderTarget = SVGA3D_INVALID_ID;
4291
4292	if (pState->fSupportedSurfaceNULL)
4293	{
4294	/* Create a dummy render target to satisfy D3D. This path is usually taken only to render into a depth buffer without
4295	* wishing to update an actual color render target
4296	*/
4297	IDirect3DSurface9* pDummyRenderTarget;
4298	hr = pContext->pDevice->CreateRenderTarget(pThis->svga.uWidth,
4299	pThis->svga.uHeight,
4300	FOURCC_NULL,
4301	D3DMULTISAMPLE_NONE,
4302	0,
4303	FALSE,
4304	&pDummyRenderTarget,
4305	NULL);
4306
4307	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: CreateRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
4308
4309	hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pDummyRenderTarget);
4310	pDummyRenderTarget->Release();
4311	}
4312	else
4313	hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, NULL);
4314
4315	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
4316	break;
4317
4318	default:
4319	AssertFailedReturn(VERR_INVALID_PARAMETER);
4320	}
4321	return VINF_SUCCESS;
4322	}
4323
4324	AssertReturn(target.sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
4325	AssertReturn(target.sid < pState->cSurfaces && pState->paSurface[target.sid].id == target.sid, VERR_INVALID_PARAMETER);
4326	pRenderTarget = &pState->paSurface[target.sid];
4327
4328	switch (type)
4329	{
4330	case SVGA3D_RT_DEPTH:
4331	case SVGA3D_RT_STENCIL:
4332	if (!pRenderTarget->u.pSurface)
4333	{
4334	DWORD cQualityLevels = 0;
4335
4336	/* Query the nr of quality levels for this particular format */
4337	if (pRenderTarget->multiSampleTypeD3D != D3DMULTISAMPLE_NONE)
4338	{
4339	hr = pState->pD3D9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
4340	D3DDEVTYPE_HAL,
4341	pRenderTarget->formatD3D,
4342	TRUE, /* Windowed */
4343	pRenderTarget->multiSampleTypeD3D,
4344	&cQualityLevels);
4345	Assert(hr == D3D_OK \|\| hr == D3DERR_NOTAVAILABLE);
4346	}
4347
4348	if ( pState->fSupportedSurfaceINTZ
4349	&& pRenderTarget->multiSampleTypeD3D == D3DMULTISAMPLE_NONE
4350	&& ( pRenderTarget->formatD3D == D3DFMT_D24S8
4351	\|\| pRenderTarget->formatD3D == D3DFMT_D24X8))
4352	{
4353	Log(("vmsvga3dSetRenderTarget: Creating stencil surface as texture!\n"));
4354	int rc = vmsvga3dCreateTexture(pContext, cid, pRenderTarget);
4355	AssertRC(rc); /* non-fatal */
4356	}
4357
4358	if (!pRenderTarget->fStencilAsTexture)
4359	{
4360	Log(("vmsvga3dSetRenderTarget DEPTH/STENCIL; cQualityLevels=%d\n", cQualityLevels));
4361	hr = pContext->pDevice->CreateDepthStencilSurface(pRenderTarget->pMipmapLevels[0].size.width,
4362	pRenderTarget->pMipmapLevels[0].size.height,
4363	pRenderTarget->formatD3D,
4364	pRenderTarget->multiSampleTypeD3D,
4365	((cQualityLevels >= 1) ? cQualityLevels - 1 : 0), /* 0 - (levels-1) */
4366	FALSE, /* not discardable */
4367	&pRenderTarget->u.pSurface,
4368	NULL);
4369	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: CreateDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
4370	}
4371
4372	pRenderTarget->idAssociatedContext = cid;
4373
4374	#if 0 /* doesn't work */
4375	if ( !pRenderTarget->fStencilAsTexture
4376	&& pRenderTarget->fDirty)
4377	{
4378	Log(("vmsvga3dSetRenderTarget: sync dirty depth/stencil buffer\n"));
4379	Assert(pRenderTarget->faces[0].numMipLevels == 1);
4380
4381	for (uint32_t i = 0; i < pRenderTarget->faces[0].numMipLevels; i++)
4382	{
4383	if (pRenderTarget->pMipmapLevels[i].fDirty)
4384	{
4385	D3DLOCKED_RECT LockedRect;
4386
4387	hr = pRenderTarget->u.pSurface->LockRect(&LockedRect,
4388	NULL, /* entire surface */
4389	0);
4390
4391	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: LockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
4392
4393	Log(("vmsvga3dSetRenderTarget: sync dirty texture mipmap level %d (pitch %x vs %x)\n", i, LockedRect.Pitch, pRenderTarget->pMipmapLevels[i].cbSurfacePitch));
4394
4395	uint8_t pDest = (uint8_t )LockedRect.pBits;
4396	uint8_t pSrc = (uint8_t )pRenderTarget->pMipmapLevels[i].pSurfaceData;
4397	for (uint32_t j = 0; j < pRenderTarget->pMipmapLevels[i].size.height; j++)
4398	{
4399	memcpy(pDest, pSrc, pRenderTarget->pMipmapLevels[i].cbSurfacePitch);
4400
4401	pDest += LockedRect.Pitch;
4402	pSrc += pRenderTarget->pMipmapLevels[i].cbSurfacePitch;
4403	}
4404
4405	hr = pRenderTarget->u.pSurface->UnlockRect();
4406	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: UnlockRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
4407
4408	pRenderTarget->pMipmapLevels[i].fDirty = false;
4409	}
4410	}
4411	}
4412	#endif
4413	}
4414	Assert(pRenderTarget->idAssociatedContext == cid);
4415
4416	/* @todo Assert(!pRenderTarget->fDirty); */
4417
4418	AssertReturn(pRenderTarget->u.pSurface, VERR_INVALID_PARAMETER);
4419
4420	pRenderTarget->fUsageD3D \|= D3DUSAGE_DEPTHSTENCIL;
4421	pRenderTarget->flags \|= SVGA3D_SURFACE_HINT_DEPTHSTENCIL;
4422
4423	if (pRenderTarget->fStencilAsTexture)
4424	{
4425	IDirect3DSurface9 *pStencilSurface;
4426
4427	hr = pRenderTarget->u.pTexture->GetSurfaceLevel(0, &pStencilSurface);
4428	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
4429
4430	hr = pContext->pDevice->SetDepthStencilSurface(pStencilSurface);
4431	pStencilSurface->Release();
4432	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
4433	}
4434	else
4435	{
4436	hr = pContext->pDevice->SetDepthStencilSurface(pRenderTarget->u.pSurface);
4437	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetDepthStencilSurface failed with %x\n", hr), VERR_INTERNAL_ERROR);
4438	}
4439	break;
4440
4441	case SVGA3D_RT_COLOR0:
4442	case SVGA3D_RT_COLOR1:
4443	case SVGA3D_RT_COLOR2:
4444	case SVGA3D_RT_COLOR3:
4445	case SVGA3D_RT_COLOR4:
4446	case SVGA3D_RT_COLOR5:
4447	case SVGA3D_RT_COLOR6:
4448	case SVGA3D_RT_COLOR7:
4449	{
4450	IDirect3DSurface9 *pSurface;
4451	bool fTexture = false;
4452	bool fShared = false;
4453
4454	/* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
4455	vmsvga3dSurfaceFlush(pThis, pRenderTarget);
4456
4457	if (pRenderTarget->flags & SVGA3D_SURFACE_HINT_TEXTURE)
4458	{
4459	fTexture = true;
4460
4461	/* A texture surface can be used as a render target to fill it and later on used as a texture. */
4462	if (!pRenderTarget->u.pTexture)
4463	{
4464	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));
4465	int rc = vmsvga3dCreateTexture(pContext, cid, pRenderTarget);
4466	AssertRCReturn(rc, rc);
4467	}
4468
4469	#ifndef VBOX_VMSVGA3D_WITH_OPENGL
4470	if (pRenderTarget->idAssociatedContext != cid)
4471	{
4472	Log(("vmsvga3dSetRenderTarget; using texture %x created for another context (%d vs %d)\n", target.sid, pRenderTarget->idAssociatedContext, cid));
4473
4474	PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pRenderTarget);
4475	AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
4476
4477	hr = pSharedSurface->u.pTexture->GetSurfaceLevel(0 /* Texture level 0 */,
4478	&pSurface);
4479
4480	fShared = true;
4481	}
4482	else
4483	#endif
4484	hr = pRenderTarget->u.pTexture->GetSurfaceLevel(0 /* Texture level 0 */,
4485	&pSurface);
4486
4487	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: GetSurfaceLevel failed with %x\n", hr), VERR_INTERNAL_ERROR);
4488	}
4489	else
4490	{
4491	if (!pRenderTarget->u.pSurface)
4492	{
4493	DWORD cQualityLevels = 0;
4494
4495	/* Query the nr of quality levels for this particular format */
4496	if (pRenderTarget->multiSampleTypeD3D != D3DMULTISAMPLE_NONE)
4497	{
4498	hr = pState->pD3D9->CheckDeviceMultiSampleType(D3DADAPTER_DEFAULT,
4499	D3DDEVTYPE_HAL,
4500	pRenderTarget->formatD3D,
4501	TRUE, /* Windowed */
4502	pRenderTarget->multiSampleTypeD3D,
4503	&cQualityLevels);
4504	Assert(hr == D3D_OK \|\| hr == D3DERR_NOTAVAILABLE);
4505	}
4506
4507	Log(("vmsvga3dSetRenderTarget COLOR; cQualityLevels=%d\n", cQualityLevels));
4508	Log(("Create rendertarget (%d,%d) format=%x multisample=%x\n", pRenderTarget->pMipmapLevels[0].size.width, pRenderTarget->pMipmapLevels[0].size.height, pRenderTarget->formatD3D, pRenderTarget->multiSampleTypeD3D));
4509
4510	hr = pContext->pDevice->CreateRenderTarget(pRenderTarget->pMipmapLevels[0].size.width,
4511	pRenderTarget->pMipmapLevels[0].size.height,
4512	pRenderTarget->formatD3D,
4513	pRenderTarget->multiSampleTypeD3D,
4514	((cQualityLevels >= 1) ? cQualityLevels - 1 : 0), /* 0 - (levels-1) */
4515	TRUE, /* lockable */
4516	&pRenderTarget->u.pSurface,
4517	NULL);
4518	AssertReturn(hr == D3D_OK, VERR_INTERNAL_ERROR);
4519
4520	pRenderTarget->idAssociatedContext = cid;
4521	}
4522	else
4523	AssertReturn(pRenderTarget->fUsageD3D & D3DUSAGE_RENDERTARGET, VERR_INVALID_PARAMETER);
4524
4525	Assert(pRenderTarget->idAssociatedContext == cid);
4526	pSurface = pRenderTarget->u.pSurface;
4527	}
4528
4529	AssertReturn(pRenderTarget->u.pSurface, VERR_INVALID_PARAMETER);
4530	Assert(!pRenderTarget->fDirty);
4531
4532	pRenderTarget->fUsageD3D \|= D3DUSAGE_RENDERTARGET;
4533	pRenderTarget->flags \|= SVGA3D_SURFACE_HINT_RENDERTARGET;
4534
4535	hr = pContext->pDevice->SetRenderTarget(type - SVGA3D_RT_COLOR0, pSurface);
4536	if (fTexture)
4537	pSurface->Release(); /* Release reference to texture level 0 */
4538	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetRenderTarget: SetRenderTarget failed with %x\n", hr), VERR_INTERNAL_ERROR);
4539
4540	pContext->sidRenderTarget = target.sid;
4541
4542	/* Changing the render target resets the viewport; restore it here. */
4543	if (pContext->state.u32UpdateFlags & VMSVGA3D_UPDATE_VIEWPORT)
4544	vmsvga3dSetViewPort(pThis, cid, &pContext->state.RectViewPort);
4545
4546	break;
4547	}
4548
4549	default:
4550	AssertFailedReturn(VERR_INVALID_PARAMETER);
4551	}
4552
4553	return VINF_SUCCESS;
4554	}
4555
4556	/**
4557	* Convert SVGA texture combiner value to its D3D equivalent
4558	*/
4559	static DWORD vmsvga3dTextureCombiner2D3D(uint32_t value)
4560	{
4561	switch (value)
4562	{
4563	case SVGA3D_TC_DISABLE:
4564	return D3DTOP_DISABLE;
4565	case SVGA3D_TC_SELECTARG1:
4566	return D3DTOP_SELECTARG1;
4567	case SVGA3D_TC_SELECTARG2:
4568	return D3DTOP_SELECTARG2;
4569	case SVGA3D_TC_MODULATE:
4570	return D3DTOP_MODULATE;
4571	case SVGA3D_TC_ADD:
4572	return D3DTOP_ADD;
4573	case SVGA3D_TC_ADDSIGNED:
4574	return D3DTOP_ADDSIGNED;
4575	case SVGA3D_TC_SUBTRACT:
4576	return D3DTOP_SUBTRACT;
4577	case SVGA3D_TC_BLENDTEXTUREALPHA:
4578	return D3DTOP_BLENDTEXTUREALPHA;
4579	case SVGA3D_TC_BLENDDIFFUSEALPHA:
4580	return D3DTOP_BLENDDIFFUSEALPHA;
4581	case SVGA3D_TC_BLENDCURRENTALPHA:
4582	return D3DTOP_BLENDCURRENTALPHA;
4583	case SVGA3D_TC_BLENDFACTORALPHA:
4584	return D3DTOP_BLENDFACTORALPHA;
4585	case SVGA3D_TC_MODULATE2X:
4586	return D3DTOP_MODULATE2X;
4587	case SVGA3D_TC_MODULATE4X:
4588	return D3DTOP_MODULATE4X;
4589	case SVGA3D_TC_DSDT:
4590	AssertFailed(); /* @todo ??? */
4591	return D3DTOP_DISABLE;
4592	case SVGA3D_TC_DOTPRODUCT3:
4593	return D3DTOP_DOTPRODUCT3;
4594	case SVGA3D_TC_BLENDTEXTUREALPHAPM:
4595	return D3DTOP_BLENDTEXTUREALPHAPM;
4596	case SVGA3D_TC_ADDSIGNED2X:
4597	return D3DTOP_ADDSIGNED2X;
4598	case SVGA3D_TC_ADDSMOOTH:
4599	return D3DTOP_ADDSMOOTH;
4600	case SVGA3D_TC_PREMODULATE:
4601	return D3DTOP_PREMODULATE;
4602	case SVGA3D_TC_MODULATEALPHA_ADDCOLOR:
4603	return D3DTOP_MODULATEALPHA_ADDCOLOR;
4604	case SVGA3D_TC_MODULATECOLOR_ADDALPHA:
4605	return D3DTOP_MODULATECOLOR_ADDALPHA;
4606	case SVGA3D_TC_MODULATEINVALPHA_ADDCOLOR:
4607	return D3DTOP_MODULATEINVALPHA_ADDCOLOR;
4608	case SVGA3D_TC_MODULATEINVCOLOR_ADDALPHA:
4609	return D3DTOP_MODULATEINVCOLOR_ADDALPHA;
4610	case SVGA3D_TC_BUMPENVMAPLUMINANCE:
4611	return D3DTOP_BUMPENVMAPLUMINANCE;
4612	case SVGA3D_TC_MULTIPLYADD:
4613	return D3DTOP_MULTIPLYADD;
4614	case SVGA3D_TC_LERP:
4615	return D3DTOP_LERP;
4616	default:
4617	AssertFailed();
4618	return D3DTOP_DISABLE;
4619	}
4620	}
4621
4622	/**
4623	* Convert SVGA texture arg data value to its D3D equivalent
4624	*/
4625	static DWORD vmsvga3dTextureArgData2D3D(uint32_t value)
4626	{
4627	switch (value)
4628	{
4629	case SVGA3D_TA_CONSTANT:
4630	return D3DTA_CONSTANT;
4631	case SVGA3D_TA_PREVIOUS:
4632	return D3DTA_CURRENT; /* current = previous */
4633	case SVGA3D_TA_DIFFUSE:
4634	return D3DTA_DIFFUSE;
4635	case SVGA3D_TA_TEXTURE:
4636	return D3DTA_TEXTURE;
4637	case SVGA3D_TA_SPECULAR:
4638	return D3DTA_SPECULAR;
4639	default:
4640	AssertFailed();
4641	return 0;
4642	}
4643	}
4644
4645	/**
4646	* Convert SVGA texture transform flag value to its D3D equivalent
4647	*/
4648	static DWORD vmsvga3dTextTransformFlags2D3D(uint32_t value)
4649	{
4650	switch (value)
4651	{
4652	case SVGA3D_TEX_TRANSFORM_OFF:
4653	return D3DTTFF_DISABLE;
4654	case SVGA3D_TEX_TRANSFORM_S:
4655	return D3DTTFF_COUNT1; /* @todo correct? */
4656	case SVGA3D_TEX_TRANSFORM_T:
4657	return D3DTTFF_COUNT2; /* @todo correct? */
4658	case SVGA3D_TEX_TRANSFORM_R:
4659	return D3DTTFF_COUNT3; /* @todo correct? */
4660	case SVGA3D_TEX_TRANSFORM_Q:
4661	return D3DTTFF_COUNT4; /* @todo correct? */
4662	case SVGA3D_TEX_PROJECTED:
4663	return D3DTTFF_PROJECTED;
4664	default:
4665	AssertFailed();
4666	return 0;
4667	}
4668	}
4669
4670	int vmsvga3dSetTextureState(PVGASTATE pThis, uint32_t cid, uint32_t cTextureStates, SVGA3dTextureState *pTextureState)
4671	{
4672	DWORD val;
4673	HRESULT hr;
4674	PVMSVGA3DCONTEXT pContext;
4675	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
4676	AssertReturn(pState, VERR_NO_MEMORY);
4677
4678	Log(("vmsvga3dSetTextureState %x cTextureState=%d\n", cid, cTextureStates));
4679
4680	if ( cid >= pState->cContexts
4681	\|\| pState->paContext[cid].id != cid)
4682	{
4683	Log(("vmsvga3dSetTextureState invalid context id!\n"));
4684	return VERR_INVALID_PARAMETER;
4685	}
4686	pContext = &pState->paContext[cid];
4687
4688	for (unsigned i = 0; i < cTextureStates; i++)
4689	{
4690	D3DTEXTURESTAGESTATETYPE textureType = D3DTSS_FORCE_DWORD;
4691	D3DSAMPLERSTATETYPE samplerType = D3DSAMP_FORCE_DWORD;
4692
4693	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));
4694	/* Record the texture state for vm state saving. */
4695	if ( pTextureState[i].stage < SVGA3D_MAX_TEXTURE_STAGE
4696	&& pTextureState[i].name < SVGA3D_TS_MAX)
4697	{
4698	pContext->state.aTextureState[pTextureState[i].stage][pTextureState[i].name] = pTextureState[i];
4699	}
4700
4701	switch (pTextureState[i].name)
4702	{
4703	case SVGA3D_TS_COLOROP: /* SVGA3dTextureCombiner */
4704	textureType = D3DTSS_COLOROP;
4705	val = vmsvga3dTextureCombiner2D3D(pTextureState[i].value);
4706	break;
4707
4708	case SVGA3D_TS_COLORARG0: /* SVGA3dTextureArgData */
4709	textureType = D3DTSS_COLORARG0;
4710	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4711	break;
4712
4713	case SVGA3D_TS_COLORARG1: /* SVGA3dTextureArgData */
4714	textureType = D3DTSS_COLORARG1;
4715	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4716	break;
4717
4718	case SVGA3D_TS_COLORARG2: /* SVGA3dTextureArgData */
4719	textureType = D3DTSS_COLORARG2;
4720	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4721	break;
4722
4723	case SVGA3D_TS_ALPHAOP: /* SVGA3dTextureCombiner */
4724	textureType = D3DTSS_ALPHAOP;
4725	val = vmsvga3dTextureCombiner2D3D(pTextureState[i].value);
4726	break;
4727
4728	case SVGA3D_TS_ALPHAARG0: /* SVGA3dTextureArgData */
4729	textureType = D3DTSS_ALPHAARG0;
4730	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4731	break;
4732
4733	case SVGA3D_TS_ALPHAARG1: /* SVGA3dTextureArgData */
4734	textureType = D3DTSS_ALPHAARG1;
4735	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4736	break;
4737
4738	case SVGA3D_TS_ALPHAARG2: /* SVGA3dTextureArgData */
4739	textureType = D3DTSS_ALPHAARG2;
4740	val = vmsvga3dTextureArgData2D3D(pTextureState[i].value);
4741	break;
4742
4743	case SVGA3D_TS_BUMPENVMAT00: /* float */
4744	textureType = D3DTSS_BUMPENVMAT00;
4745	val = pTextureState[i].value;
4746	break;
4747
4748	case SVGA3D_TS_BUMPENVMAT01: /* float */
4749	textureType = D3DTSS_BUMPENVMAT01;
4750	val = pTextureState[i].value;
4751	break;
4752
4753	case SVGA3D_TS_BUMPENVMAT10: /* float */
4754	textureType = D3DTSS_BUMPENVMAT10;
4755	val = pTextureState[i].value;
4756	break;
4757
4758	case SVGA3D_TS_BUMPENVMAT11: /* float */
4759	textureType = D3DTSS_BUMPENVMAT11;
4760	val = pTextureState[i].value;
4761	break;
4762
4763	case SVGA3D_TS_TEXCOORDINDEX: /* uint32_t */
4764	textureType = D3DTSS_TEXCOORDINDEX;
4765	val = pTextureState[i].value;
4766	break;
4767
4768	case SVGA3D_TS_BUMPENVLSCALE: /* float */
4769	textureType = D3DTSS_BUMPENVLSCALE;
4770	val = pTextureState[i].value;
4771	break;
4772
4773	case SVGA3D_TS_BUMPENVLOFFSET: /* float */
4774	textureType = D3DTSS_BUMPENVLOFFSET;
4775	val = pTextureState[i].value;
4776	break;
4777
4778	case SVGA3D_TS_TEXTURETRANSFORMFLAGS: /* SVGA3dTexTransformFlags */
4779	textureType = D3DTSS_TEXTURETRANSFORMFLAGS;
4780	val = vmsvga3dTextTransformFlags2D3D(pTextureState[i].value);
4781	break;
4782
4783	case SVGA3D_TS_BIND_TEXTURE: /* SVGA3dSurfaceId */
4784	if (pTextureState[i].value == SVGA3D_INVALID_ID)
4785	{
4786	Log(("SVGA3D_TS_BIND_TEXTURE: stage %d, texture surface id=%x\n", pTextureState[i].stage, pTextureState[i].value));
4787
4788	pContext->aSidActiveTexture[pTextureState[i].stage] = SVGA3D_INVALID_ID;
4789	/* Unselect the currently associated texture. */
4790	hr = pContext->pDevice->SetTexture(pTextureState[i].stage,
4791	NULL);
4792	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
4793	}
4794	else
4795	{
4796	HRESULT hr;
4797	uint32_t sid = pTextureState[i].value;
4798
4799	AssertReturn(sid < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
4800	AssertReturn(sid < pState->cSurfaces && pState->paSurface[sid].id == sid, VERR_INVALID_PARAMETER);
4801
4802	PVMSVGA3DSURFACE pSurface = &pState->paSurface[sid];
4803
4804	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));
4805
4806	if (!pSurface->u.pTexture)
4807	{
4808	Assert(pSurface->idAssociatedContext == SVGA3D_INVALID_ID);
4809	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));
4810	int rc = vmsvga3dCreateTexture(pContext, cid, pSurface);
4811	AssertRCReturn(rc, rc);
4812	}
4813	else
4814	{
4815	/* Must flush the other context's 3d pipeline to make sure all drawing is complete for the surface we're about to use. */
4816	vmsvga3dSurfaceFlush(pThis, pSurface);
4817	}
4818
4819	#ifndef VBOX_VMSVGA3D_WITH_OPENGL
4820	if (pSurface->idAssociatedContext != cid)
4821	{
4822	Log(("vmsvga3dSetTextureState; using texture %x created for another context (%d vs %d)\n", sid, pSurface->idAssociatedContext, cid));
4823
4824	PVMSVGA3DSHAREDSURFACE pSharedSurface = vmsvga3dSurfaceGetSharedCopy(pThis, pContext, pSurface);
4825	AssertReturn(pSharedSurface, VERR_INTERNAL_ERROR);
4826
4827	hr = pContext->pDevice->SetTexture(pTextureState[i].stage,
4828	pSharedSurface->u.pTexture);
4829	}
4830	else
4831	#endif
4832	hr = pContext->pDevice->SetTexture(pTextureState[i].stage,
4833	pSurface->u.pTexture);
4834
4835	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTexture failed with %x\n", hr), VERR_INTERNAL_ERROR);
4836
4837	pContext->aSidActiveTexture[pTextureState[i].stage] = sid;
4838	}
4839	/* Finished; continue with the next one. */
4840	continue;
4841
4842	case SVGA3D_TS_ADDRESSW: /* SVGA3dTextureAddress */
4843	samplerType = D3DSAMP_ADDRESSW;
4844	val = pTextureState[i].value; /* Identical otherwise */
4845	Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
4846	break;
4847
4848	case SVGA3D_TS_ADDRESSU: /* SVGA3dTextureAddress */
4849	samplerType = D3DSAMP_ADDRESSU;
4850	val = pTextureState[i].value; /* Identical otherwise */
4851	Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
4852	break;
4853
4854	case SVGA3D_TS_ADDRESSV: /* SVGA3dTextureAddress */
4855	samplerType = D3DSAMP_ADDRESSV;
4856	val = pTextureState[i].value; /* Identical otherwise */
4857	Assert(pTextureState[i].value != SVGA3D_TEX_ADDRESS_EDGE);
4858	break;
4859
4860	case SVGA3D_TS_MIPFILTER: /* SVGA3dTextureFilter */
4861	samplerType = D3DSAMP_MIPFILTER;
4862	val = pTextureState[i].value; /* Identical otherwise */
4863	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
4864	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
4865	break;
4866
4867	case SVGA3D_TS_MAGFILTER: /* SVGA3dTextureFilter */
4868	samplerType = D3DSAMP_MAGFILTER;
4869	val = pTextureState[i].value; /* Identical otherwise */
4870	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
4871	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
4872	break;
4873
4874	case SVGA3D_TS_MINFILTER: /* SVGA3dTextureFilter */
4875	samplerType = D3DSAMP_MINFILTER;
4876	val = pTextureState[i].value; /* Identical otherwise */
4877	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_FLATCUBIC);
4878	Assert(pTextureState[i].value != SVGA3D_TEX_FILTER_GAUSSIANCUBIC);
4879	break;
4880
4881	case SVGA3D_TS_BORDERCOLOR: /* SVGA3dColor */
4882	samplerType = D3DSAMP_BORDERCOLOR;
4883	val = pTextureState[i].value; /* Identical */
4884	break;
4885
4886	case SVGA3D_TS_TEXTURE_LOD_BIAS: /* float */
4887	samplerType = D3DSAMP_MIPMAPLODBIAS;
4888	val = pTextureState[i].value; /* Identical */
4889	break;
4890
4891	case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL: /* uint32_t */
4892	samplerType = D3DSAMP_MAXMIPLEVEL;
4893	val = pTextureState[i].value; /* Identical?? */
4894	break;
4895
4896	case SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL: /* uint32_t */
4897	samplerType = D3DSAMP_MAXANISOTROPY;
4898	val = pTextureState[i].value; /* Identical?? */
4899	break;
4900
4901	case SVGA3D_TS_GAMMA: /* float */
4902	samplerType = D3DSAMP_SRGBTEXTURE;
4903	/* Boolean in D3D */
4904	if (pTextureState[i].floatValue == 1.0f)
4905	val = FALSE;
4906	else
4907	val = TRUE;
4908	break;
4909
4910	/* Internal commands, that don't map directly to the SetTextureStageState API. */
4911	case SVGA3D_TS_TEXCOORDGEN: /* SVGA3dTextureCoordGen */
4912	AssertFailed();
4913	break;
4914	}
4915
4916	if (textureType != D3DTSS_FORCE_DWORD)
4917	{
4918	hr = pContext->pDevice->SetTextureStageState(pTextureState[i].stage, textureType, val);
4919	}
4920	else
4921	{
4922	Assert(samplerType != D3DSAMP_FORCE_DWORD);
4923	hr = pContext->pDevice->SetSamplerState(pTextureState[i].stage, samplerType, val);
4924	}
4925
4926	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetTextureState: SetTextureStageState failed with %x\n", hr), VERR_INTERNAL_ERROR);
4927	}
4928
4929	return VINF_SUCCESS;
4930	}
4931
4932	int vmsvga3dSetMaterial(PVGASTATE pThis, uint32_t cid, SVGA3dFace face, SVGA3dMaterial *pMaterial)
4933	{
4934	HRESULT hr;
4935	D3DMATERIAL9 material;
4936	PVMSVGA3DCONTEXT pContext;
4937	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
4938	AssertReturn(pState, VERR_NO_MEMORY);
4939
4940	Log(("vmsvga3dSetMaterial %x face %d\n", cid, face));
4941
4942	if ( cid >= pState->cContexts
4943	\|\| pState->paContext[cid].id != cid)
4944	{
4945	Log(("vmsvga3dSetMaterial invalid context id!\n"));
4946	return VERR_INVALID_PARAMETER;
4947	}
4948	pContext = &pState->paContext[cid];
4949
4950	AssertReturn(face < SVGA3D_FACE_MAX, VERR_INVALID_PARAMETER);
4951
4952	/* Save for vm state save/restore. */
4953	pContext->state.aMaterial[face].fValid = true;
4954	pContext->state.aMaterial[face].material = *pMaterial;
4955	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_MATERIAL;
4956
4957	/* @note face not used for D3D9 */
4958	/* @todo ignore everything except SVGA3D_FACE_NONE? */
4959	//Assert(face == SVGA3D_FACE_NONE);
4960	if (face != SVGA3D_FACE_NONE)
4961	Log(("Unsupported face %d!!\n", face));
4962
4963	material.Diffuse.r = pMaterial->diffuse[0];
4964	material.Diffuse.g = pMaterial->diffuse[1];
4965	material.Diffuse.b = pMaterial->diffuse[2];
4966	material.Diffuse.a = pMaterial->diffuse[3];
4967	material.Ambient.r = pMaterial->ambient[0];
4968	material.Ambient.g = pMaterial->ambient[1];
4969	material.Ambient.b = pMaterial->ambient[2];
4970	material.Ambient.a = pMaterial->ambient[3];
4971	material.Specular.r = pMaterial->specular[0];
4972	material.Specular.g = pMaterial->specular[1];
4973	material.Specular.b = pMaterial->specular[2];
4974	material.Specular.a = pMaterial->specular[3];
4975	material.Emissive.r = pMaterial->emissive[0];
4976	material.Emissive.g = pMaterial->emissive[1];
4977	material.Emissive.b = pMaterial->emissive[2];
4978	material.Emissive.a = pMaterial->emissive[3];
4979	material.Power = pMaterial->shininess;
4980
4981	hr = pContext->pDevice->SetMaterial(&material);
4982	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetMaterial: SetMaterial failed with %x\n", hr), VERR_INTERNAL_ERROR);
4983
4984	return VINF_SUCCESS;
4985	}
4986
4987	int vmsvga3dSetLightData(PVGASTATE pThis, uint32_t cid, uint32_t index, SVGA3dLightData *pData)
4988	{
4989	HRESULT hr;
4990	D3DLIGHT9 light;
4991	PVMSVGA3DCONTEXT pContext;
4992	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
4993	AssertReturn(pState, VERR_NO_MEMORY);
4994
4995	Log(("vmsvga3dSetLightData %x index=%d\n", cid, index));
4996
4997	if ( cid >= pState->cContexts
4998	\|\| pState->paContext[cid].id != cid)
4999	{
5000	Log(("vmsvga3dSetLightData invalid context id!\n"));
5001	return VERR_INVALID_PARAMETER;
5002	}
5003	pContext = &pState->paContext[cid];
5004
5005	switch (pData->type)
5006	{
5007	case SVGA3D_LIGHTTYPE_POINT:
5008	light.Type = D3DLIGHT_POINT;
5009	break;
5010
5011	case SVGA3D_LIGHTTYPE_SPOT1: /* 1-cone, in degrees */
5012	light.Type = D3DLIGHT_SPOT;
5013	break;
5014
5015	case SVGA3D_LIGHTTYPE_DIRECTIONAL:
5016	light.Type = D3DLIGHT_DIRECTIONAL;
5017	break;
5018
5019	case SVGA3D_LIGHTTYPE_SPOT2: /* 2-cone, in radians */
5020	default:
5021	Log(("Unsupported light type!!\n"));
5022	return VERR_INVALID_PARAMETER;
5023	}
5024
5025	/* Store for vm state save/restore */
5026	if (index < SVGA3D_MAX_LIGHTS)
5027	{
5028	pContext->state.aLightData[index].fValidData = true;
5029	pContext->state.aLightData[index].data = *pData;
5030	}
5031	else
5032	AssertFailed();
5033
5034	light.Diffuse.r = pData->diffuse[0];
5035	light.Diffuse.g = pData->diffuse[1];
5036	light.Diffuse.b = pData->diffuse[2];
5037	light.Diffuse.a = pData->diffuse[3];
5038	light.Specular.r = pData->specular[0];
5039	light.Specular.g = pData->specular[1];
5040	light.Specular.b = pData->specular[2];
5041	light.Specular.a = pData->specular[3];
5042	light.Ambient.r = pData->ambient[0];
5043	light.Ambient.g = pData->ambient[1];
5044	light.Ambient.b = pData->ambient[2];
5045	light.Ambient.a = pData->ambient[3];
5046	light.Position.x = pData->position[0];
5047	light.Position.y = pData->position[1];
5048	light.Position.z = pData->position[2]; /* @note 4th position not available in D3D9 */
5049	light.Direction.x = pData->direction[0];
5050	light.Direction.y = pData->direction[1];
5051	light.Direction.z = pData->direction[2]; /* @note 4th position not available in D3D9 */
5052	light.Range = pData->range;
5053	light.Falloff = pData->falloff;
5054	light.Attenuation0 = pData->attenuation0;
5055	light.Attenuation1 = pData->attenuation1;
5056	light.Attenuation2 = pData->attenuation2;
5057	light.Theta = pData->theta;
5058	light.Phi = pData->phi;
5059
5060	hr = pContext->pDevice->SetLight(index, &light);
5061	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetLightData: SetLight failed with %x\n", hr), VERR_INTERNAL_ERROR);
5062
5063	return VINF_SUCCESS;
5064	}
5065
5066	int vmsvga3dSetLightEnabled(PVGASTATE pThis, uint32_t cid, uint32_t index, uint32_t enabled)
5067	{
5068	HRESULT hr;
5069	PVMSVGA3DCONTEXT pContext;
5070	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5071	AssertReturn(pState, VERR_NO_MEMORY);
5072
5073	Log(("vmsvga3dSetLightEnabled %x %d -> %d\n", cid, index, enabled));
5074
5075	if ( cid >= pState->cContexts
5076	\|\| pState->paContext[cid].id != cid)
5077	{
5078	Log(("vmsvga3dSetLightEnabled invalid context id!\n"));
5079	return VERR_INVALID_PARAMETER;
5080	}
5081	pContext = &pState->paContext[cid];
5082
5083	/* Store for vm state save/restore */
5084	if (index < SVGA3D_MAX_LIGHTS)
5085	pContext->state.aLightData[index].fEnabled = !!enabled;
5086	else
5087	AssertFailed();
5088
5089	hr = pContext->pDevice->LightEnable(index, (BOOL)enabled);
5090	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetLightEnabled: LightEnable failed with %x\n", hr), VERR_INTERNAL_ERROR);
5091
5092	return VINF_SUCCESS;
5093	}
5094
5095	int vmsvga3dSetViewPort(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
5096	{
5097	HRESULT hr;
5098	D3DVIEWPORT9 viewPort;
5099	PVMSVGA3DCONTEXT pContext;
5100	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5101	AssertReturn(pState, VERR_NO_MEMORY);
5102
5103	Log(("vmsvga3dSetViewPort %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
5104
5105	if ( cid >= pState->cContexts
5106	\|\| pState->paContext[cid].id != cid)
5107	{
5108	Log(("vmsvga3dSetViewPort invalid context id!\n"));
5109	return VERR_INVALID_PARAMETER;
5110	}
5111	/* Save for vm state save/restore. */
5112	pContext = &pState->paContext[cid];
5113	pContext->state.RectViewPort = *pRect;
5114	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_VIEWPORT;
5115
5116	hr = pContext->pDevice->GetViewport(&viewPort);
5117	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetViewPort: GetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
5118
5119	viewPort.X = pRect->x;
5120	viewPort.Y = pRect->y;
5121	viewPort.Width = pRect->w;
5122	viewPort.Height = pRect->h;
5123	/* viewPort.MinZ & MaxZ are not changed from the current setting. */
5124
5125	hr = pContext->pDevice->SetViewport(&viewPort);
5126	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetViewPort: SetViewport failed with %x\n", hr), VERR_INTERNAL_ERROR);
5127
5128	return VINF_SUCCESS;
5129	}
5130
5131	int vmsvga3dSetClipPlane(PVGASTATE pThis, uint32_t cid, uint32_t index, float plane[4])
5132	{
5133	HRESULT hr;
5134	PVMSVGA3DCONTEXT pContext;
5135	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5136	AssertReturn(pState, VERR_NO_MEMORY);
5137
5138	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)));
5139	AssertReturn(index < SVGA3D_CLIPPLANE_MAX, VERR_INVALID_PARAMETER);
5140
5141	if ( cid >= pState->cContexts
5142	\|\| pState->paContext[cid].id != cid)
5143	{
5144	Log(("vmsvga3dSetClipPlane invalid context id!\n"));
5145	return VERR_INVALID_PARAMETER;
5146	}
5147	pContext = &pState->paContext[cid];
5148
5149	/* Store for vm state save/restore. */
5150	pContext->state.aClipPlane[index].fValid = true;
5151	memcpy(pContext->state.aClipPlane[index].plane, plane, sizeof(plane));
5152
5153	hr = pContext->pDevice->SetClipPlane(index, plane);
5154	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetClipPlane: SetClipPlane failed with %x\n", hr), VERR_INTERNAL_ERROR);
5155	return VINF_SUCCESS;
5156	}
5157
5158	int vmsvga3dCommandClear(PVGASTATE pThis, uint32_t cid, SVGA3dClearFlag clearFlag, uint32_t color, float depth, uint32_t stencil, uint32_t cRects, SVGA3dRect *pRect)
5159	{
5160	DWORD clearFlagD3D = 0;
5161	D3DRECT *pRectD3D = NULL;
5162	HRESULT hr;
5163	PVMSVGA3DCONTEXT pContext;
5164	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5165	AssertReturn(pState, VERR_NO_MEMORY);
5166
5167	Log(("vmsvga3dCommandClear %x clearFlag=%x color=%x depth=%d stencil=%x cRects=%d\n", cid, clearFlag, color, (uint32_t)(depth * 100.0), stencil, cRects));
5168
5169	if ( cid >= pState->cContexts
5170	\|\| pState->paContext[cid].id != cid)
5171	{
5172	Log(("vmsvga3dCommandClear invalid context id!\n"));
5173	return VERR_INVALID_PARAMETER;
5174	}
5175	pContext = &pState->paContext[cid];
5176
5177	if (clearFlag & SVGA3D_CLEAR_COLOR)
5178	clearFlagD3D \|= D3DCLEAR_TARGET;
5179	if (clearFlag & SVGA3D_CLEAR_STENCIL)
5180	clearFlagD3D \|= D3DCLEAR_STENCIL;
5181	if (clearFlag & SVGA3D_CLEAR_DEPTH)
5182	clearFlagD3D \|= D3DCLEAR_ZBUFFER;
5183
5184	if (cRects)
5185	{
5186	pRectD3D = (D3DRECT )RTMemAlloc(sizeof(D3DRECT) cRects);
5187	AssertReturn(pRectD3D, VERR_NO_MEMORY);
5188
5189	for (unsigned i=0; i < cRects; i++)
5190	{
5191	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));
5192	pRectD3D[i].x1 = pRect[i].x;
5193	pRectD3D[i].y1 = pRect[i].y;
5194	pRectD3D[i].x2 = pRect[i].x + pRect[i].w; /* exclusive */
5195	pRectD3D[i].y2 = pRect[i].y + pRect[i].h; /* exclusive */
5196	}
5197	}
5198
5199	hr = pContext->pDevice->Clear(cRects, pRectD3D, clearFlagD3D, (D3DCOLOR)color, depth, stencil);
5200	if (pRectD3D)
5201	RTMemFree(pRectD3D);
5202
5203	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dCommandClear: Clear failed with %x\n", hr), VERR_INTERNAL_ERROR);
5204
5205	/* Make sure we can track drawing usage of active render targets. */
5206	if (pContext->sidRenderTarget != SVGA3D_INVALID_ID)
5207	vmsvga3dSurfaceTrackUsage(pThis, pContext, pContext->sidRenderTarget);
5208
5209	return VINF_SUCCESS;
5210	}
5211
5212	/* Convert VMWare vertex declaration to its D3D equivalent. */
5213	int vmsvga3dVertexDecl2D3D(SVGA3dVertexArrayIdentity &identity, D3DVERTEXELEMENT9 *pVertexElement)
5214	{
5215	/* usage, method and type are identical; make sure. */
5216	AssertCompile(SVGA3D_DECLTYPE_FLOAT1 == D3DDECLTYPE_FLOAT1);
5217	AssertCompile(SVGA3D_DECLTYPE_FLOAT16_4 == D3DDECLTYPE_FLOAT16_4);
5218	AssertCompile(SVGA3D_DECLMETHOD_DEFAULT == D3DDECLMETHOD_DEFAULT);
5219	AssertCompile(SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED == D3DDECLMETHOD_LOOKUPPRESAMPLED);
5220	AssertCompile(D3DDECLUSAGE_POSITION == SVGA3D_DECLUSAGE_POSITION);
5221	AssertCompile(D3DDECLUSAGE_SAMPLE == SVGA3D_DECLUSAGE_SAMPLE);
5222
5223	pVertexElement->Stream = 0;
5224	pVertexElement->Offset = 0;
5225	pVertexElement->Type = identity.type;
5226	pVertexElement->Method = identity.method;
5227	pVertexElement->Usage = identity.usage;
5228	pVertexElement->UsageIndex = identity.usageIndex;
5229	return VINF_SUCCESS;
5230	}
5231
5232	/* Convert VMWare primitive type to its D3D equivalent. */
5233	int vmsvga3dPrimitiveType2D3D(SVGA3dPrimitiveType PrimitiveType, D3DPRIMITIVETYPE *pPrimitiveTypeD3D)
5234	{
5235	switch (PrimitiveType)
5236	{
5237	case SVGA3D_PRIMITIVE_TRIANGLELIST:
5238	*pPrimitiveTypeD3D = D3DPT_TRIANGLELIST;
5239	break;
5240	case SVGA3D_PRIMITIVE_POINTLIST:
5241	*pPrimitiveTypeD3D = D3DPT_POINTLIST;
5242	break;
5243	case SVGA3D_PRIMITIVE_LINELIST:
5244	*pPrimitiveTypeD3D = D3DPT_LINELIST;
5245	break;
5246	case SVGA3D_PRIMITIVE_LINESTRIP:
5247	*pPrimitiveTypeD3D = D3DPT_LINESTRIP;
5248	break;
5249	case SVGA3D_PRIMITIVE_TRIANGLESTRIP:
5250	*pPrimitiveTypeD3D = D3DPT_TRIANGLESTRIP;
5251	break;
5252	case SVGA3D_PRIMITIVE_TRIANGLEFAN:
5253	*pPrimitiveTypeD3D = D3DPT_TRIANGLEFAN;
5254	break;
5255	default:
5256	return VERR_INVALID_PARAMETER;
5257	}
5258	return VINF_SUCCESS;
5259	}
5260
5261	int vmsvga3dDrawPrimitivesProcessVertexDecls(PVMSVGA3DSTATE pState, PVMSVGA3DCONTEXT pContext, uint32_t numVertexDecls, SVGA3dVertexDecl pVertexDecl, uint32_t idStream, D3DVERTEXELEMENT9 pVertexElement)
5262	{
5263	HRESULT hr;
5264	int rc;
5265	uint32_t uVertexMinOffset = 0xffffffff;
5266	uint32_t uVertexMaxOffset = 0;
5267
5268	/* Create a vertex declaration array */
5269	for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
5270	{
5271	unsigned sidVertex = pVertexDecl[iVertex].array.surfaceId;
5272	PVMSVGA3DSURFACE pVertexSurface;
5273
5274	AssertReturn(sidVertex < SVGA3D_MAX_SURFACE_IDS, VERR_INVALID_PARAMETER);
5275	AssertReturn(sidVertex < pState->cSurfaces && pState->paSurface[sidVertex].id == sidVertex, VERR_INVALID_PARAMETER);
5276
5277	pVertexSurface = &pState->paSurface[sidVertex];
5278	Log(("vmsvga3dDrawPrimitives: vertex surface %x stream %d\n", sidVertex, idStream));
5279	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));
5280
5281	rc = vmsvga3dVertexDecl2D3D(pVertexDecl[iVertex].identity, &pVertexElement[iVertex]);
5282	AssertRCReturn(rc, rc);
5283	pVertexElement[iVertex].Stream = idStream;
5284
5285	#ifdef LOG_ENABLED
5286	if (pVertexDecl[iVertex].array.stride == 0)
5287	Log(("vmsvga3dDrawPrimitives: stride == 0! Can be valid\n"));
5288	#endif
5289
5290	/* Find the min and max vertex offset to determine the right base offset to use in the vertex declaration. */
5291	if (pVertexDecl[iVertex].array.offset > uVertexMaxOffset)
5292	uVertexMaxOffset = pVertexDecl[iVertex].array.offset;
5293	if (pVertexDecl[iVertex].array.offset < uVertexMinOffset)
5294	uVertexMinOffset = pVertexDecl[iVertex].array.offset;
5295
5296	if (!pVertexSurface->u.pVertexBuffer)
5297	{
5298	Assert(iVertex == 0);
5299
5300	Log(("vmsvga3dDrawPrimitives: create vertex buffer fDirty=%d\n", pVertexSurface->fDirty));
5301	hr = pContext->pDevice->CreateVertexBuffer(pVertexSurface->pMipmapLevels[0].cbSurface,
5302	D3DUSAGE_DYNAMIC \| D3DUSAGE_WRITEONLY /* possible severe performance penalty otherwise (according to d3d debug output) */,
5303	0, /* non-FVF */
5304	D3DPOOL_DEFAULT,
5305	&pVertexSurface->u.pVertexBuffer,
5306	NULL);
5307	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateVertexBuffer failed with %x\n", hr), VERR_INTERNAL_ERROR);
5308
5309	if (pVertexSurface->fDirty)
5310	{
5311	void *pData;
5312
5313	hr = pVertexSurface->u.pVertexBuffer->Lock(0, 0, &pData, 0);
5314	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Lock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
5315
5316	memcpy(pData, pVertexSurface->pMipmapLevels[0].pSurfaceData, pVertexSurface->pMipmapLevels[0].cbSurface);
5317
5318	hr = pVertexSurface->u.pVertexBuffer->Unlock();
5319	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Unlock vertex failed with %x\n", hr), VERR_INTERNAL_ERROR);
5320	pVertexSurface->pMipmapLevels[0].fDirty = false;
5321	pVertexSurface->fDirty = false;
5322	}
5323	pVertexSurface->flags \|= SVGA3D_SURFACE_HINT_VERTEXBUFFER;
5324	}
5325	else
5326	Assert(pVertexSurface->fDirty == false);
5327	}
5328
5329	/* Set the right vertex offset values for each declaration. */
5330	for (unsigned iVertex = 0; iVertex < numVertexDecls; iVertex++)
5331	{
5332	pVertexElement[iVertex].Offset = pVertexDecl[iVertex].array.offset - uVertexMinOffset;
5333	#ifdef LOG_ENABLED
5334	if (pVertexElement[iVertex].Offset >= pVertexDecl[0].array.stride)
5335	Log(("vmsvga3dDrawPrimitives: WARNING: offset > stride!!\n"));
5336	#endif
5337
5338	Log(("vmsvga3dDrawPrimitives: vertex %d offset = %d (stride %d) (min=%d max=%d)\n", iVertex, pVertexDecl[iVertex].array.offset, pVertexDecl[iVertex].array.stride, uVertexMinOffset, uVertexMaxOffset));
5339	}
5340
5341	PVMSVGA3DSURFACE pVertexSurface;
5342	unsigned sidVertex = pVertexDecl[0].array.surfaceId;
5343	unsigned strideVertex = pVertexDecl[0].array.stride;
5344
5345	pVertexSurface = &pState->paSurface[sidVertex];
5346
5347	Log(("vmsvga3dDrawPrimitives: SetStreamSource %d min offset=%d stride=%d\n", idStream, uVertexMinOffset, strideVertex));
5348	hr = pContext->pDevice->SetStreamSource(idStream,
5349	pVertexSurface->u.pVertexBuffer,
5350	uVertexMinOffset,
5351	strideVertex);
5352
5353	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetStreamSource failed with %x\n", hr), VERR_INTERNAL_ERROR);
5354	return VINF_SUCCESS;
5355	}
5356
5357	int vmsvga3dDrawPrimitives(PVGASTATE pThis, uint32_t cid, uint32_t numVertexDecls, SVGA3dVertexDecl pVertexDecl, uint32_t numRanges, SVGA3dPrimitiveRange pRange, uint32_t cVertexDivisor, SVGA3dVertexDivisor *pVertexDivisor)
5358	{
5359	PVMSVGA3DCONTEXT pContext;
5360	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5361	AssertReturn(pState, VERR_INTERNAL_ERROR);
5362	int rc;
5363	HRESULT hr;
5364	uint32_t iCurrentVertex, iCurrentStreamId;
5365	IDirect3DVertexDeclaration9 *pVertexDeclD3D = NULL;
5366	D3DVERTEXELEMENT9 *pVertexElement = NULL;
5367	D3DVERTEXELEMENT9 VertexEnd = D3DDECL_END();
5368
5369	Log(("vmsvga3dDrawPrimitives %x numVertexDecls=%d numRanges=%d, cVertexDivisor=%d\n", cid, numVertexDecls, numRanges, cVertexDivisor));
5370
5371	AssertReturn(numVertexDecls && numVertexDecls <= SVGA3D_MAX_VERTEX_ARRAYS, VERR_INVALID_PARAMETER);
5372	AssertReturn(numRanges && numRanges <= SVGA3D_MAX_DRAW_PRIMITIVE_RANGES, VERR_INVALID_PARAMETER);
5373	AssertReturn(!cVertexDivisor \|\| cVertexDivisor == numVertexDecls, VERR_INVALID_PARAMETER);
5374	/* @todo */
5375	Assert(!cVertexDivisor);
5376
5377	if ( cid >= pState->cContexts
5378	\|\| pState->paContext[cid].id != cid)
5379	{
5380	Log(("vmsvga3dDrawPrimitives invalid context id!\n"));
5381	return VERR_INVALID_PARAMETER;
5382	}
5383
5384	pContext = &pState->paContext[cid];
5385
5386	/* Begin a scene before rendering anything. */
5387	hr = pContext->pDevice->BeginScene();
5388	AssertMsgReturn(hr == D3D_OK, ("BeginScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
5389
5390	pVertexElement = (D3DVERTEXELEMENT9 )RTMemAllocZ(sizeof(D3DVERTEXELEMENT9) (numVertexDecls + 1));
5391	if (!pVertexElement)
5392	{
5393	Assert(pVertexElement);
5394	rc = VERR_INTERNAL_ERROR;
5395	goto internal_error;
5396	}
5397
5398	/* Process all vertex declarations. Each vertex buffer is represented by one stream source id. */
5399	iCurrentVertex = 0;
5400	iCurrentStreamId = 0;
5401	while (iCurrentVertex < numVertexDecls)
5402	{
5403	uint32_t sidVertex = SVGA_ID_INVALID;
5404	uint32_t iVertex;
5405	uint32_t uVertexMinOffset = 0xffffffff;
5406
5407	for (iVertex = iCurrentVertex; iVertex < numVertexDecls; iVertex++)
5408	{
5409	if ( ( sidVertex != SVGA_ID_INVALID
5410	&& pVertexDecl[iVertex].array.surfaceId != sidVertex
5411	)
5412	/* We must put vertex declarations that start at a different element in another stream as d3d only handles offsets < stride. */
5413	\|\| ( uVertexMinOffset != 0xffffffff
5414	&& pVertexDecl[iVertex].array.offset >= uVertexMinOffset + pVertexDecl[iCurrentVertex].array.stride
5415	)
5416	)
5417	break;
5418	sidVertex = pVertexDecl[iVertex].array.surfaceId;
5419
5420	if (uVertexMinOffset > pVertexDecl[iVertex].array.offset)
5421	uVertexMinOffset = pVertexDecl[iVertex].array.offset;
5422	}
5423
5424	rc = vmsvga3dDrawPrimitivesProcessVertexDecls(pState, pContext, iVertex - iCurrentVertex, &pVertexDecl[iCurrentVertex], iCurrentStreamId, &pVertexElement[iCurrentVertex]);
5425	if (RT_FAILURE(rc))
5426	goto internal_error;
5427
5428	iCurrentVertex = iVertex;
5429	iCurrentStreamId++;
5430	}
5431
5432	/* Mark the end. */
5433	memcpy(&pVertexElement[numVertexDecls], &VertexEnd, sizeof(VertexEnd));
5434
5435	hr = pContext->pDevice->CreateVertexDeclaration(&pVertexElement[0],
5436	&pVertexDeclD3D);
5437	if (hr != D3D_OK)
5438	{
5439	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateVertexDeclaration failed with %x\n", hr));
5440	rc = VERR_INTERNAL_ERROR;
5441	goto internal_error;
5442	}
5443
5444	hr = pContext->pDevice->SetVertexDeclaration(pVertexDeclD3D);
5445	if (hr != D3D_OK)
5446	{
5447	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetVertexDeclaration failed with %x\n", hr));
5448	rc = VERR_INTERNAL_ERROR;
5449	goto internal_error;
5450	}
5451
5452	/* Now draw the primitives. */
5453	for (unsigned iPrimitive = 0; iPrimitive < numRanges; iPrimitive++)
5454	{
5455	D3DPRIMITIVETYPE PrimitiveTypeD3D;
5456	unsigned sidIndex = pRange[iPrimitive].indexArray.surfaceId;
5457	PVMSVGA3DSURFACE pIndexSurface = NULL;
5458
5459	Log(("Primitive %d: type %s\n", iPrimitive, vmsvga3dPrimitiveType2String(pRange[iPrimitive].primType)));
5460	rc = vmsvga3dPrimitiveType2D3D(pRange[iPrimitive].primType, &PrimitiveTypeD3D);
5461	if (RT_FAILURE(rc))
5462	{
5463	AssertRC(rc);
5464	goto internal_error;
5465	}
5466
5467	/* Triangle strips or fans with just one primitive don't make much sense and are identical to triangle lists.
5468	* Workaround for NVidia driver crash when encountering some of these.
5469	*/
5470	if ( pRange[iPrimitive].primitiveCount == 1
5471	&& ( PrimitiveTypeD3D == D3DPT_TRIANGLESTRIP
5472	\|\| PrimitiveTypeD3D == D3DPT_TRIANGLEFAN))
5473	PrimitiveTypeD3D = D3DPT_TRIANGLELIST;
5474
5475	if (sidIndex != SVGA3D_INVALID_ID)
5476	{
5477	AssertMsg(pRange[iPrimitive].indexWidth == sizeof(uint32_t) \|\| pRange[iPrimitive].indexWidth == sizeof(uint16_t), ("Unsupported primitive width %d\n", pRange[iPrimitive].indexWidth));
5478
5479	if ( sidIndex >= SVGA3D_MAX_SURFACE_IDS
5480	\|\| sidIndex >= pState->cSurfaces
5481	\|\| pState->paSurface[sidIndex].id != sidIndex)
5482	{
5483	Assert(sidIndex < SVGA3D_MAX_SURFACE_IDS);
5484	Assert(sidIndex < pState->cSurfaces && pState->paSurface[sidIndex].id == sidIndex);
5485	rc = VERR_INVALID_PARAMETER;
5486	goto internal_error;
5487	}
5488	pIndexSurface = &pState->paSurface[sidIndex];
5489	Log(("vmsvga3dDrawPrimitives: index surface %x\n", sidIndex));
5490
5491	if (!pIndexSurface->u.pIndexBuffer)
5492	{
5493	Log(("vmsvga3dDrawPrimitives: create index buffer fDirty=%d\n", pIndexSurface->fDirty));
5494
5495	hr = pContext->pDevice->CreateIndexBuffer(pIndexSurface->pMipmapLevels[0].cbSurface,
5496	D3DUSAGE_DYNAMIC \| D3DUSAGE_WRITEONLY /* possible severe performance penalty otherwise (according to d3d debug output */,
5497	(pRange[iPrimitive].indexWidth == sizeof(uint16_t)) ? D3DFMT_INDEX16 : D3DFMT_INDEX32,
5498	D3DPOOL_DEFAULT,
5499	&pIndexSurface->u.pIndexBuffer,
5500	NULL);
5501	if (hr != D3D_OK)
5502	{
5503	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: CreateIndexBuffer failed with %x\n", hr));
5504	rc = VERR_INTERNAL_ERROR;
5505	goto internal_error;
5506	}
5507
5508	if (pIndexSurface->fDirty)
5509	{
5510	void *pData;
5511
5512	Log(("vmsvga3dDrawPrimitives: sync index buffer\n"));
5513
5514	hr = pIndexSurface->u.pIndexBuffer->Lock(0, 0, &pData, 0);
5515	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Lock vertex failed with %x\n", hr));
5516
5517	memcpy(pData, pIndexSurface->pMipmapLevels[0].pSurfaceData, pIndexSurface->pMipmapLevels[0].cbSurface);
5518
5519	hr = pIndexSurface->u.pIndexBuffer->Unlock();
5520	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: Unlock vertex failed with %x\n", hr));
5521
5522	pIndexSurface->pMipmapLevels[0].fDirty = false;
5523	pIndexSurface->fDirty = false;
5524	}
5525	pIndexSurface->flags \|= SVGA3D_SURFACE_HINT_INDEXBUFFER;
5526	}
5527	else
5528	Assert(pIndexSurface->fDirty == false);
5529
5530	hr = pContext->pDevice->SetIndices(pIndexSurface->u.pIndexBuffer);
5531	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetIndices vertex failed with %x\n", hr));
5532	}
5533	else
5534	{
5535	hr = pContext->pDevice->SetIndices(NULL);
5536	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetIndices vertex (NULL) failed with %x\n", hr));
5537	}
5538
5539	PVMSVGA3DSURFACE pVertexSurface;
5540	unsigned sidVertex = pVertexDecl[0].array.surfaceId;
5541	unsigned strideVertex = pVertexDecl[0].array.stride;
5542
5543	pVertexSurface = &pState->paSurface[sidVertex];
5544
5545	if (!pIndexSurface)
5546	{
5547	/* Render without an index buffer */
5548	Log(("DrawPrimitive %x primitivecount=%d index index bias=%d stride=%d\n", PrimitiveTypeD3D, pRange[iPrimitive].primitiveCount, pRange[iPrimitive].indexBias, strideVertex));
5549
5550	hr = pContext->pDevice->DrawPrimitive(PrimitiveTypeD3D,
5551	pRange[iPrimitive].indexBias,
5552	pRange[iPrimitive].primitiveCount);
5553	if (hr != D3D_OK)
5554	{
5555	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: DrawPrimitive failed with %x\n", hr));
5556	rc = VERR_INTERNAL_ERROR;
5557	goto internal_error;
5558	}
5559	}
5560	else
5561	{
5562	Assert(pRange[iPrimitive].indexBias >= 0); /* @todo */
5563
5564	UINT numVertices;
5565
5566	if (pVertexDecl[0].rangeHint.last)
5567	numVertices = pVertexDecl[0].rangeHint.last - pVertexDecl[0].rangeHint.first + 1;
5568	else
5569	numVertices = pVertexSurface->pMipmapLevels[0].cbSurface / strideVertex - pVertexDecl[0].array.offset / strideVertex - pVertexDecl[0].rangeHint.first - pRange[iPrimitive].indexBias;
5570
5571	/* Render with an index buffer */
5572	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));
5573
5574	hr = pContext->pDevice->DrawIndexedPrimitive(PrimitiveTypeD3D,
5575	pRange[iPrimitive].indexBias, /* BaseVertexIndex */
5576	0, /* MinVertexIndex */
5577	numVertices,
5578	pRange[iPrimitive].indexArray.offset / pRange[iPrimitive].indexWidth, /* StartIndex */
5579	pRange[iPrimitive].primitiveCount);
5580	if (hr != D3D_OK)
5581	{
5582	AssertMsg(hr == D3D_OK, ("vmsvga3dDrawPrimitives: DrawIndexedPrimitive failed with %x\n", hr));
5583	rc = VERR_INTERNAL_ERROR;
5584	goto internal_error;
5585	}
5586	}
5587	}
5588	pVertexDeclD3D->Release();
5589	RTMemFree(pVertexElement);
5590
5591	hr = pContext->pDevice->EndScene();
5592	AssertMsgReturn(hr == D3D_OK, ("EndScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
5593
5594	/* Clear streams above 1 as they might accidentally be reused in the future. */
5595	if (iCurrentStreamId > 1)
5596	{
5597	for (uint32_t i = 1; i < iCurrentStreamId; i++)
5598	{
5599	Log(("vmsvga3dDrawPrimitives: clear stream %d\n", i));
5600	hr = pContext->pDevice->SetStreamSource(i, NULL, 0, 0);
5601	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dDrawPrimitives: SetStreamSource failed with %x\n", hr), VERR_INTERNAL_ERROR);
5602	}
5603	}
5604
5605	#if 0 /* Flush queue */
5606	{
5607	IDirect3DQuery9 *pQuery;
5608	hr = pContext->pDevice->CreateQuery(D3DQUERYTYPE_EVENT, &pQuery);
5609	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: CreateQuery failed with %x\n", hr), VERR_INTERNAL_ERROR);
5610
5611	hr = pQuery->Issue(D3DISSUE_END);
5612	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSurfaceTrackUsage: Issue failed with %x\n", hr), VERR_INTERNAL_ERROR);
5613	while (true)
5614	{
5615	hr = pQuery->GetData(NULL, 0, D3DGETDATA_FLUSH);
5616	if (hr != S_FALSE) break;
5617
5618	RTThreadSleep(1);
5619	}
5620	AssertMsgReturn(hr == S_OK, ("vmsvga3dSurfaceFinishDrawing: GetData failed with %x\n", hr), VERR_INTERNAL_ERROR);
5621
5622	pQuery->Release();
5623	}
5624	#endif
5625
5626	/* Make sure we can track drawing usage of active render targets and textures. */
5627	vmsvga3dContextTrackUsage(pThis, pContext);
5628
5629	#ifdef DEBUG_GFX_WINDOW
5630	if (pContext->aSidActiveTexture[0] == 0x62)
5631	//// if (pContext->sidActiveTexture == 0x3d)
5632	{
5633	SVGA3dCopyRect rect;
5634
5635	rect.srcx = rect.srcy = rect.x = rect.y = 0;
5636	rect.w = 800;
5637	rect.h = 600;
5638	vmsvga3dCommandPresent(pThis, pContext->sidRenderTarget /pContext->aSidActiveTexture[0] /, 0, &rect);
5639	}
5640	#endif
5641	return rc;
5642
5643	internal_error:
5644	if (pVertexDeclD3D)
5645	pVertexDeclD3D->Release();
5646	if (pVertexElement)
5647	RTMemFree(pVertexElement);
5648
5649	hr = pContext->pDevice->EndScene();
5650	AssertMsgReturn(hr == D3D_OK, ("EndScene failed with %x\n", hr), VERR_INTERNAL_ERROR);
5651
5652	return rc;
5653	}
5654
5655	int vmsvga3dSetScissorRect(PVGASTATE pThis, uint32_t cid, SVGA3dRect *pRect)
5656	{
5657	HRESULT hr;
5658	RECT rect;
5659	PVMSVGA3DCONTEXT pContext;
5660	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5661	AssertReturn(pState, VERR_NO_MEMORY);
5662
5663	Log(("vmsvga3dSetScissorRect %x (%d,%d)(%d,%d)\n", cid, pRect->x, pRect->y, pRect->w, pRect->h));
5664
5665	if ( cid >= pState->cContexts
5666	\|\| pState->paContext[cid].id != cid)
5667	{
5668	Log(("vmsvga3dSetScissorRect invalid context id!\n"));
5669	return VERR_INVALID_PARAMETER;
5670	}
5671	pContext = &pState->paContext[cid];
5672
5673	/* Store for vm state save/restore. */
5674	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_SCISSORRECT;
5675	pContext->state.RectScissor = *pRect;
5676
5677	rect.left = pRect->x;
5678	rect.top = pRect->y;
5679	rect.right = rect.left + pRect->w; /* exclusive */
5680	rect.bottom = rect.top + pRect->h; /* exclusive */
5681
5682	hr = pContext->pDevice->SetScissorRect(&rect);
5683	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dSetScissorRect: SetScissorRect failed with %x\n", hr), VERR_INTERNAL_ERROR);
5684
5685	return VINF_SUCCESS;
5686	}
5687
5688
5689	int vmsvga3dShaderDefine(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type, uint32_t cbData, uint32_t *pShaderData)
5690	{
5691	HRESULT hr;
5692	PVMSVGA3DCONTEXT pContext;
5693	PVMSVGA3DSHADER pShader;
5694	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5695	AssertReturn(pState, VERR_NO_MEMORY);
5696
5697	Log(("vmsvga3dShaderDefine %x shid=%x type=%s cbData=%x\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", cbData));
5698	Log3(("shader code:\n%.*Rhxd\n", cbData, pShaderData));
5699
5700	if ( cid >= pState->cContexts
5701	\|\| pState->paContext[cid].id != cid)
5702	{
5703	Log(("vmsvga3dShaderDefine invalid context id!\n"));
5704	return VERR_INVALID_PARAMETER;
5705	}
5706	pContext = &pState->paContext[cid];
5707
5708	AssertReturn(shid < SVGA3D_MAX_SHADER_IDS, VERR_INVALID_PARAMETER);
5709	if (type == SVGA3D_SHADERTYPE_VS)
5710	{
5711	if (shid >= pContext->cVertexShaders)
5712	{
5713	pContext->paVertexShader = (PVMSVGA3DSHADER)RTMemRealloc(pContext->paVertexShader, sizeof(VMSVGA3DSHADER) * (shid + 1));
5714	AssertReturn(pContext->paVertexShader, VERR_NO_MEMORY);
5715	memset(&pContext->paVertexShader[pContext->cVertexShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cVertexShaders));
5716	for (uint32_t i = pContext->cVertexShaders; i < shid + 1; i++)
5717	pContext->paVertexShader[i].id = SVGA3D_INVALID_ID;
5718	pContext->cVertexShaders = shid + 1;
5719	}
5720	/* If one already exists with this id, then destroy it now. */
5721	if (pContext->paVertexShader[shid].id != SVGA3D_INVALID_ID)
5722	vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paVertexShader[shid].type);
5723
5724	pShader = &pContext->paVertexShader[shid];
5725	}
5726	else
5727	{
5728	Assert(type == SVGA3D_SHADERTYPE_PS);
5729	if (shid >= pContext->cPixelShaders)
5730	{
5731	pContext->paPixelShader = (PVMSVGA3DSHADER)RTMemRealloc(pContext->paPixelShader, sizeof(VMSVGA3DSHADER) * (shid + 1));
5732	AssertReturn(pContext->paPixelShader, VERR_NO_MEMORY);
5733	memset(&pContext->paPixelShader[pContext->cPixelShaders], 0, sizeof(VMSVGA3DSHADER) * (shid + 1 - pContext->cPixelShaders));
5734	for (uint32_t i = pContext->cPixelShaders; i < shid + 1; i++)
5735	pContext->paPixelShader[i].id = SVGA3D_INVALID_ID;
5736	pContext->cPixelShaders = shid + 1;
5737	}
5738	/* If one already exists with this id, then destroy it now. */
5739	if (pContext->paPixelShader[shid].id != SVGA3D_INVALID_ID)
5740	vmsvga3dShaderDestroy(pThis, cid, shid, pContext->paPixelShader[shid].type);
5741
5742	pShader = &pContext->paPixelShader[shid];
5743	}
5744
5745	memset(pShader, 0, sizeof(*pShader));
5746	pShader->id = shid;
5747	pShader->cid = cid;
5748	pShader->type = type;
5749	pShader->cbData = cbData;
5750	pShader->pShaderProgram = RTMemAllocZ(cbData);
5751	AssertReturn(pShader->pShaderProgram, VERR_NO_MEMORY);
5752	memcpy(pShader->pShaderProgram, pShaderData, cbData);
5753
5754	switch (type)
5755	{
5756	case SVGA3D_SHADERTYPE_VS:
5757	hr = pContext->pDevice->CreateVertexShader((const DWORD *)pShaderData, &pShader->u.pVertexShader);
5758	break;
5759
5760	case SVGA3D_SHADERTYPE_PS:
5761	hr = pContext->pDevice->CreatePixelShader((const DWORD *)pShaderData, &pShader->u.pPixelShader);
5762	break;
5763
5764	default:
5765	AssertFailedReturn(VERR_INVALID_PARAMETER);
5766	}
5767	#ifdef DUMP_SHADER_DISASSEMBLY
5768	LPD3DXBUFFER pDisassembly;
5769
5770	hr = D3DXDisassembleShader((const DWORD *)pShaderData, FALSE, NULL, &pDisassembly);
5771	if (hr == D3D_OK)
5772	{
5773	Log(("Shader disassembly:\n%s\n", pDisassembly->GetBufferPointer()));
5774	pDisassembly->Release();
5775	}
5776	#endif
5777	if (hr != D3D_OK)
5778	{
5779	RTMemFree(pShader->pShaderProgram);
5780	memset(pShader, 0, sizeof(*pShader));
5781	pShader->id = SVGA3D_INVALID_ID;
5782	}
5783
5784	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderDefine: CreateVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5785	return VINF_SUCCESS;
5786	}
5787
5788	int vmsvga3dShaderDestroy(PVGASTATE pThis, uint32_t cid, uint32_t shid, SVGA3dShaderType type)
5789	{
5790	PVMSVGA3DCONTEXT pContext;
5791	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5792	AssertReturn(pState, VERR_NO_MEMORY);
5793	PVMSVGA3DSHADER pShader = NULL;
5794
5795	Log(("vmsvga3dShaderDestroy %x shid=%x type=%s\n", cid, shid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL"));
5796
5797	if ( cid >= pState->cContexts
5798	\|\| pState->paContext[cid].id != cid)
5799	{
5800	Log(("vmsvga3dShaderDestroy invalid context id!\n"));
5801	return VERR_INVALID_PARAMETER;
5802	}
5803	pContext = &pState->paContext[cid];
5804
5805	if (type == SVGA3D_SHADERTYPE_VS)
5806	{
5807	if ( shid < pContext->cVertexShaders
5808	&& pContext->paVertexShader[shid].id == shid)
5809	{
5810	pShader = &pContext->paVertexShader[shid];
5811	pShader->u.pVertexShader->Release();
5812	}
5813	}
5814	else
5815	{
5816	Assert(type == SVGA3D_SHADERTYPE_PS);
5817	if ( shid < pContext->cPixelShaders
5818	&& pContext->paPixelShader[shid].id == shid)
5819	{
5820	pShader = &pContext->paPixelShader[shid];
5821	pShader->u.pPixelShader->Release();
5822	}
5823	}
5824
5825	if (pShader)
5826	{
5827	if (pShader->pShaderProgram)
5828	RTMemFree(pShader->pShaderProgram);
5829
5830	memset(pShader, 0, sizeof(*pShader));
5831	pShader->id = SVGA3D_INVALID_ID;
5832	}
5833	else
5834	AssertFailedReturn(VERR_INVALID_PARAMETER);
5835
5836	return VINF_SUCCESS;
5837	}
5838
5839	int vmsvga3dShaderSet(PVGASTATE pThis, uint32_t cid, SVGA3dShaderType type, uint32_t shid)
5840	{
5841	PVMSVGA3DCONTEXT pContext;
5842	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5843	AssertReturn(pState, VERR_NO_MEMORY);
5844	HRESULT hr;
5845
5846	Log(("vmsvga3dShaderSet %x type=%s shid=%d\n", cid, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", shid));
5847
5848	if ( cid >= pState->cContexts
5849	\|\| pState->paContext[cid].id != cid)
5850	{
5851	Log(("vmsvga3dShaderSet invalid context id!\n"));
5852	return VERR_INVALID_PARAMETER;
5853	}
5854	pContext = &pState->paContext[cid];
5855
5856	if (type == SVGA3D_SHADERTYPE_VS)
5857	{
5858	/* Save for vm state save/restore. */
5859	pContext->state.shidVertex = shid;
5860	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_VERTEXSHADER;
5861
5862	if ( shid < pContext->cVertexShaders
5863	&& pContext->paVertexShader[shid].id == shid)
5864	{
5865	PVMSVGA3DSHADER pShader = &pContext->paVertexShader[shid];
5866	Assert(type == pShader->type);
5867
5868	hr = pContext->pDevice->SetVertexShader(pShader->u.pVertexShader);
5869	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5870	}
5871	else
5872	if (shid == SVGA_ID_INVALID)
5873	{
5874	/* Unselect shader. */
5875	hr = pContext->pDevice->SetVertexShader(NULL);
5876	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5877	}
5878	else
5879	AssertFailedReturn(VERR_INVALID_PARAMETER);
5880	}
5881	else
5882	{
5883	/* Save for vm state save/restore. */
5884	pContext->state.shidPixel = shid;
5885	pContext->state.u32UpdateFlags \|= VMSVGA3D_UPDATE_PIXELSHADER;
5886
5887	Assert(type == SVGA3D_SHADERTYPE_PS);
5888	if ( shid < pContext->cPixelShaders
5889	&& pContext->paPixelShader[shid].id == shid)
5890	{
5891	PVMSVGA3DSHADER pShader = &pContext->paPixelShader[shid];
5892	Assert(type == pShader->type);
5893
5894	hr = pContext->pDevice->SetPixelShader(pShader->u.pPixelShader);
5895	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5896	}
5897	else
5898	if (shid == SVGA_ID_INVALID)
5899	{
5900	/* Unselect shader. */
5901	hr = pContext->pDevice->SetPixelShader(NULL);
5902	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSet: SetVertex/PixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5903	}
5904	else
5905	AssertFailedReturn(VERR_INVALID_PARAMETER);
5906	}
5907
5908	return VINF_SUCCESS;
5909	}
5910
5911	int vmsvga3dShaderSetConst(PVGASTATE pThis, uint32_t cid, uint32_t reg, SVGA3dShaderType type, SVGA3dShaderConstType ctype, uint32_t cRegisters, uint32_t *pValues)
5912	{
5913	HRESULT hr;
5914	PVMSVGA3DCONTEXT pContext;
5915	PVMSVGA3DSTATE pState = (PVMSVGA3DSTATE)pThis->svga.p3dState;
5916	AssertReturn(pState, VERR_NO_MEMORY);
5917
5918	Log(("vmsvga3dShaderSetConst %x reg=%x type=%s ctype=%x\n", cid, reg, (type == SVGA3D_SHADERTYPE_VS) ? "VERTEX" : "PIXEL", ctype));
5919
5920	if ( cid >= pState->cContexts
5921	\|\| pState->paContext[cid].id != cid)
5922	{
5923	Log(("vmsvga3dShaderSetConst invalid context id!\n"));
5924	return VERR_INVALID_PARAMETER;
5925	}
5926	pContext = &pState->paContext[cid];
5927
5928	for (uint32_t i = 0; i < cRegisters; i++)
5929	{
5930	Log(("Constant %d: value=%x-%x-%x-%x\n", reg + i, pValues[i4 + 0], pValues[i4 + 1], pValues[i4 + 2], pValues[i4 + 3]));
5931	vmsvga3dSaveShaderConst(pContext, reg + i, type, ctype, pValues[i4 + 0], pValues[i4 + 1], pValues[i4 + 2], pValues[i4 + 3]);
5932	}
5933
5934	switch (type)
5935	{
5936	case SVGA3D_SHADERTYPE_VS:
5937	switch (ctype)
5938	{
5939	case SVGA3D_CONST_TYPE_FLOAT:
5940	hr = pContext->pDevice->SetVertexShaderConstantF(reg, (const float *)pValues, cRegisters);
5941	break;
5942
5943	case SVGA3D_CONST_TYPE_INT:
5944	hr = pContext->pDevice->SetVertexShaderConstantI(reg, (const int *)pValues, cRegisters);
5945	break;
5946
5947	case SVGA3D_CONST_TYPE_BOOL:
5948	hr = pContext->pDevice->SetVertexShaderConstantB(reg, (const BOOL *)pValues, cRegisters);
5949	break;
5950
5951	default:
5952	AssertFailedReturn(VERR_INVALID_PARAMETER);
5953	}
5954	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSetConst: SetVertexShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5955	break;
5956
5957	case SVGA3D_SHADERTYPE_PS:
5958	switch (ctype)
5959	{
5960	case SVGA3D_CONST_TYPE_FLOAT:
5961	{
5962	hr = pContext->pDevice->SetPixelShaderConstantF(reg, (const float *)pValues, cRegisters);
5963	break;
5964	}
5965
5966	case SVGA3D_CONST_TYPE_INT:
5967	hr = pContext->pDevice->SetPixelShaderConstantI(reg, (const int *)pValues, cRegisters);
5968	break;
5969
5970	case SVGA3D_CONST_TYPE_BOOL:
5971	hr = pContext->pDevice->SetPixelShaderConstantB(reg, (const BOOL *)pValues, cRegisters);
5972	break;
5973
5974	default:
5975	AssertFailedReturn(VERR_INVALID_PARAMETER);
5976	}
5977	AssertMsgReturn(hr == D3D_OK, ("vmsvga3dShaderSetConst: SetPixelShader failed with %x\n", hr), VERR_INTERNAL_ERROR);
5978	break;
5979
5980	default:
5981	AssertFailedReturn(VERR_INVALID_PARAMETER);
5982	}
5983	return VINF_SUCCESS;
5984	}
5985
5986
5987	int vmsvga3dQueryBegin(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type)
5988	{
5989	AssertFailed();
5990	return VERR_NOT_IMPLEMENTED;
5991	}
5992
5993	int vmsvga3dQueryEnd(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
5994	{
5995	AssertFailed();
5996	return VERR_NOT_IMPLEMENTED;
5997	}
5998
5999	int vmsvga3dQueryWait(PVGASTATE pThis, uint32_t cid, SVGA3dQueryType type, SVGAGuestPtr guestResult)
6000	{
6001	AssertFailed();
6002	return VERR_NOT_IMPLEMENTED;
6003	}
6004
6005	static void vmsvgaDumpD3DCaps(D3DCAPS9 *pCaps)
6006	{
6007	LogRel(("\nD3D device caps: DevCaps2:\n"));
6008	if (pCaps->DevCaps2 & D3DDEVCAPS2_ADAPTIVETESSRTPATCH)
6009	LogRel((" - D3DDEVCAPS2_ADAPTIVETESSRTPATCH\n"));
6010	if (pCaps->DevCaps2 & D3DDEVCAPS2_ADAPTIVETESSNPATCH)
6011	LogRel((" - D3DDEVCAPS2_ADAPTIVETESSNPATCH\n"));
6012	if (pCaps->DevCaps2 & D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES)
6013	LogRel((" - D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES\n"));
6014	if (pCaps->DevCaps2 & D3DDEVCAPS2_DMAPNPATCH)
6015	LogRel((" - D3DDEVCAPS2_DMAPNPATCH\n"));
6016	if (pCaps->DevCaps2 & D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH)
6017	LogRel((" - D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH\n"));
6018	if (pCaps->DevCaps2 & D3DDEVCAPS2_STREAMOFFSET)
6019	LogRel((" - D3DDEVCAPS2_STREAMOFFSET\n"));
6020	if (pCaps->DevCaps2 & D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET)
6021	LogRel((" - D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET\n"));
6022
6023	LogRel(("\nCaps2:\n"));
6024	if (pCaps->Caps2 & D3DCAPS2_CANAUTOGENMIPMAP)
6025	LogRel((" - D3DCAPS2_CANAUTOGENMIPMAP\n"));
6026	if (pCaps->Caps2 & D3DCAPS2_CANCALIBRATEGAMMA)
6027	LogRel((" - D3DCAPS2_CANCALIBRATEGAMMA\n"));
6028	if (pCaps->Caps2 & D3DCAPS2_CANSHARERESOURCE)
6029	LogRel((" - D3DCAPS2_CANSHARERESOURCE\n"));
6030	if (pCaps->Caps2 & D3DCAPS2_CANMANAGERESOURCE)
6031	LogRel((" - D3DCAPS2_CANMANAGERESOURCE\n"));
6032	if (pCaps->Caps2 & D3DCAPS2_DYNAMICTEXTURES)
6033	LogRel((" - D3DCAPS2_DYNAMICTEXTURES\n"));
6034	if (pCaps->Caps2 & D3DCAPS2_FULLSCREENGAMMA)
6035	LogRel((" - D3DCAPS2_FULLSCREENGAMMA\n"));
6036
6037	LogRel(("\nCaps3:\n"));
6038	if (pCaps->Caps3 & D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD)
6039	LogRel((" - D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD\n"));
6040	if (pCaps->Caps3 & D3DCAPS3_COPY_TO_VIDMEM)
6041	LogRel((" - D3DCAPS3_COPY_TO_VIDMEM\n"));
6042	if (pCaps->Caps3 & D3DCAPS3_COPY_TO_SYSTEMMEM)
6043	LogRel((" - D3DCAPS3_COPY_TO_SYSTEMMEM\n"));
6044	if (pCaps->Caps3 & D3DCAPS3_DXVAHD)
6045	LogRel((" - D3DCAPS3_DXVAHD\n"));
6046	if (pCaps->Caps3 & D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION)
6047	LogRel((" - D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION\n"));
6048
6049	LogRel(("\nPresentationIntervals:\n"));
6050	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_IMMEDIATE)
6051	LogRel((" - D3DPRESENT_INTERVAL_IMMEDIATE\n"));
6052	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_ONE)
6053	LogRel((" - D3DPRESENT_INTERVAL_ONE\n"));
6054	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_TWO)
6055	LogRel((" - D3DPRESENT_INTERVAL_TWO\n"));
6056	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_THREE)
6057	LogRel((" - D3DPRESENT_INTERVAL_THREE\n"));
6058	if (pCaps->PresentationIntervals & D3DPRESENT_INTERVAL_FOUR)
6059	LogRel((" - D3DPRESENT_INTERVAL_FOUR\n"));
6060
6061	LogRel(("\nDevcaps:\n"));
6062	if (pCaps->DevCaps & D3DDEVCAPS_CANBLTSYSTONONLOCAL)
6063	LogRel((" - D3DDEVCAPS_CANBLTSYSTONONLOCAL\n"));
6064	if (pCaps->DevCaps & D3DDEVCAPS_CANRENDERAFTERFLIP)
6065	LogRel((" - D3DDEVCAPS_CANRENDERAFTERFLIP\n"));
6066	if (pCaps->DevCaps & D3DDEVCAPS_DRAWPRIMITIVES2)
6067	LogRel((" - D3DDEVCAPS_DRAWPRIMITIVES2\n"));
6068	if (pCaps->DevCaps & D3DDEVCAPS_DRAWPRIMITIVES2EX)
6069	LogRel((" - D3DDEVCAPS_DRAWPRIMITIVES2EX\n"));
6070	if (pCaps->DevCaps & D3DDEVCAPS_DRAWPRIMTLVERTEX)
6071	LogRel((" - D3DDEVCAPS_DRAWPRIMTLVERTEX\n"));
6072	if (pCaps->DevCaps & D3DDEVCAPS_EXECUTESYSTEMMEMORY)
6073	LogRel((" - D3DDEVCAPS_EXECUTESYSTEMMEMORY\n"));
6074	if (pCaps->DevCaps & D3DDEVCAPS_EXECUTEVIDEOMEMORY)
6075	LogRel((" - D3DDEVCAPS_EXECUTEVIDEOMEMORY\n"));
6076	if (pCaps->DevCaps & D3DDEVCAPS_HWRASTERIZATION)
6077	LogRel((" - D3DDEVCAPS_HWRASTERIZATION\n"));
6078	if (pCaps->DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT)
6079	LogRel((" - D3DDEVCAPS_HWTRANSFORMANDLIGHT\n"));
6080	if (pCaps->DevCaps & D3DDEVCAPS_NPATCHES)
6081	LogRel((" - D3DDEVCAPS_NPATCHES\n"));
6082	if (pCaps->DevCaps & D3DDEVCAPS_PUREDEVICE)
6083	LogRel((" - D3DDEVCAPS_PUREDEVICE\n"));
6084	if (pCaps->DevCaps & D3DDEVCAPS_QUINTICRTPATCHES)
6085	LogRel((" - D3DDEVCAPS_QUINTICRTPATCHES\n"));
6086	if (pCaps->DevCaps & D3DDEVCAPS_RTPATCHES)
6087	LogRel((" - D3DDEVCAPS_RTPATCHES\n"));
6088	if (pCaps->DevCaps & D3DDEVCAPS_RTPATCHHANDLEZERO)
6089	LogRel((" - D3DDEVCAPS_RTPATCHHANDLEZERO\n"));
6090	if (pCaps->DevCaps & D3DDEVCAPS_SEPARATETEXTUREMEMORIES)
6091	LogRel((" - D3DDEVCAPS_SEPARATETEXTUREMEMORIES\n"));
6092	if (pCaps->DevCaps & D3DDEVCAPS_TEXTURENONLOCALVIDMEM)
6093	LogRel((" - D3DDEVCAPS_TEXTURENONLOCALVIDMEM\n"));
6094	if (pCaps->DevCaps & D3DDEVCAPS_TEXTURESYSTEMMEMORY)
6095	LogRel((" - D3DDEVCAPS_TEXTURESYSTEMMEMORY\n"));
6096	if (pCaps->DevCaps & D3DDEVCAPS_TEXTUREVIDEOMEMORY)
6097	LogRel((" - D3DDEVCAPS_TEXTUREVIDEOMEMORY\n"));
6098	if (pCaps->DevCaps & D3DDEVCAPS_TLVERTEXSYSTEMMEMORY)
6099	LogRel((" - D3DDEVCAPS_TLVERTEXSYSTEMMEMORY\n"));
6100	if (pCaps->DevCaps & D3DDEVCAPS_TLVERTEXVIDEOMEMORY)
6101	LogRel((" - D3DDEVCAPS_TLVERTEXVIDEOMEMORY\n"));
6102
6103	LogRel(("\nTextureCaps:\n"));
6104	if (pCaps->TextureCaps & D3DPTEXTURECAPS_ALPHA)
6105	LogRel((" - D3DPTEXTURECAPS_ALPHA\n"));
6106	if (pCaps->TextureCaps & D3DPTEXTURECAPS_ALPHAPALETTE)
6107	LogRel((" - D3DPTEXTURECAPS_ALPHAPALETTE\n"));
6108	if (pCaps->TextureCaps & D3DPTEXTURECAPS_CUBEMAP)
6109	LogRel((" - D3DPTEXTURECAPS_CUBEMAP\n"));
6110	if (pCaps->TextureCaps & D3DPTEXTURECAPS_CUBEMAP_POW2)
6111	LogRel((" - D3DPTEXTURECAPS_CUBEMAP_POW2\n"));
6112	if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPCUBEMAP)
6113	LogRel((" - D3DPTEXTURECAPS_MIPCUBEMAP\n"));
6114	if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPMAP)
6115	LogRel((" - D3DPTEXTURECAPS_MIPMAP\n"));
6116	if (pCaps->TextureCaps & D3DPTEXTURECAPS_MIPVOLUMEMAP)
6117	LogRel((" - D3DPTEXTURECAPS_MIPVOLUMEMAP\n"));
6118	if (pCaps->TextureCaps & D3DPTEXTURECAPS_NONPOW2CONDITIONAL)
6119	LogRel((" - D3DPTEXTURECAPS_NONPOW2CONDITIONAL\n"));
6120	if (pCaps->TextureCaps & D3DPTEXTURECAPS_POW2)
6121	LogRel((" - D3DPTEXTURECAPS_POW2\n"));
6122	if (pCaps->TextureCaps & D3DPTEXTURECAPS_NOPROJECTEDBUMPENV)
6123	LogRel((" - D3DPTEXTURECAPS_NOPROJECTEDBUMPENV\n"));
6124	if (pCaps->TextureCaps & D3DPTEXTURECAPS_PERSPECTIVE)
6125	LogRel((" - D3DPTEXTURECAPS_PERSPECTIVE\n"));
6126	if (pCaps->TextureCaps & D3DPTEXTURECAPS_POW2)
6127	LogRel((" - D3DPTEXTURECAPS_POW2\n"));
6128	if (pCaps->TextureCaps & D3DPTEXTURECAPS_PROJECTED)
6129	LogRel((" - D3DPTEXTURECAPS_PROJECTED\n"));
6130	if (pCaps->TextureCaps & D3DPTEXTURECAPS_SQUAREONLY)
6131	LogRel((" - D3DPTEXTURECAPS_SQUAREONLY\n"));
6132	if (pCaps->TextureCaps & D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE)
6133	LogRel((" - D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE\n"));
6134	if (pCaps->TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP)
6135	LogRel((" - D3DPTEXTURECAPS_VOLUMEMAP\n"));
6136	if (pCaps->TextureCaps & D3DPTEXTURECAPS_VOLUMEMAP_POW2)
6137	LogRel((" - D3DPTEXTURECAPS_VOLUMEMAP_POW2\n"));
6138
6139	LogRel(("\nTextureFilterCaps\n"));
6140	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
6141	LogRel((" - D3DPTFILTERCAPS_CONVOLUTIONMONO\n"));
6142	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
6143	LogRel((" - D3DPTFILTERCAPS_MAGFPOINT\n"));
6144	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
6145	LogRel((" - D3DPTFILTERCAPS_MAGFLINEAR\n"));
6146	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
6147	LogRel((" - D3DPTFILTERCAPS_MAGFANISOTROPIC\n"));
6148	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
6149	LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
6150	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
6151	LogRel((" - D3DPTFILTERCAPS_MAGFGAUSSIANQUAD\n"));
6152	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
6153	LogRel((" - D3DPTFILTERCAPS_MINFPOINT\n"));
6154	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
6155	LogRel((" - D3DPTFILTERCAPS_MINFLINEAR\n"));
6156	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
6157	LogRel((" - D3DPTFILTERCAPS_MINFANISOTROPIC\n"));
6158	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
6159	LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
6160	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
6161	LogRel((" - D3DPTFILTERCAPS_MINFGAUSSIANQUAD\n"));
6162	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
6163	LogRel((" - D3DPTFILTERCAPS_MIPFPOINT\n"));
6164	if (pCaps->TextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
6165	LogRel((" - D3DPTFILTERCAPS_MIPFLINEAR\n"));
6166
6167	LogRel(("\nCubeTextureFilterCaps\n"));
6168	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
6169	LogRel((" - D3DPTFILTERCAPS_CONVOLUTIONMONO\n"));
6170	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
6171	LogRel((" - D3DPTFILTERCAPS_MAGFPOINT\n"));
6172	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
6173	LogRel((" - D3DPTFILTERCAPS_MAGFLINEAR\n"));
6174	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
6175	LogRel((" - D3DPTFILTERCAPS_MAGFANISOTROPIC\n"));
6176	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
6177	LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
6178	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
6179	LogRel((" - D3DPTFILTERCAPS_MAGFGAUSSIANQUAD\n"));
6180	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
6181	LogRel((" - D3DPTFILTERCAPS_MINFPOINT\n"));
6182	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
6183	LogRel((" - D3DPTFILTERCAPS_MINFLINEAR\n"));
6184	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
6185	LogRel((" - D3DPTFILTERCAPS_MINFANISOTROPIC\n"));
6186	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
6187	LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
6188	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
6189	LogRel((" - D3DPTFILTERCAPS_MINFGAUSSIANQUAD\n"));
6190	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
6191	LogRel((" - D3DPTFILTERCAPS_MIPFPOINT\n"));
6192	if (pCaps->CubeTextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
6193	LogRel((" - D3DPTFILTERCAPS_MIPFLINEAR\n"));
6194
6195	LogRel(("\nVolumeTextureFilterCaps\n"));
6196	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_CONVOLUTIONMONO)
6197	LogRel((" - D3DPTFILTERCAPS_CONVOLUTIONMONO\n"));
6198	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPOINT)
6199	LogRel((" - D3DPTFILTERCAPS_MAGFPOINT\n"));
6200	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFLINEAR)
6201	LogRel((" - D3DPTFILTERCAPS_MAGFLINEAR\n"));
6202	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFANISOTROPIC)
6203	LogRel((" - D3DPTFILTERCAPS_MAGFANISOTROPIC\n"));
6204	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD)
6205	LogRel((" - D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD\n"));
6206	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MAGFGAUSSIANQUAD)
6207	LogRel((" - D3DPTFILTERCAPS_MAGFGAUSSIANQUAD\n"));
6208	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFPOINT)
6209	LogRel((" - D3DPTFILTERCAPS_MINFPOINT\n"));
6210	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFLINEAR)
6211	LogRel((" - D3DPTFILTERCAPS_MINFLINEAR\n"));
6212	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFANISOTROPIC)
6213	LogRel((" - D3DPTFILTERCAPS_MINFANISOTROPIC\n"));
6214	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFPYRAMIDALQUAD)
6215	LogRel((" - D3DPTFILTERCAPS_MINFPYRAMIDALQUAD\n"));
6216	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MINFGAUSSIANQUAD)
6217	LogRel((" - D3DPTFILTERCAPS_MINFGAUSSIANQUAD\n"));
6218	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MIPFPOINT)
6219	LogRel((" - D3DPTFILTERCAPS_MIPFPOINT\n"));
6220	if (pCaps->VolumeTextureFilterCaps & D3DPTFILTERCAPS_MIPFLINEAR)
6221	LogRel((" - D3DPTFILTERCAPS_MIPFLINEAR\n"));
6222
6223	LogRel(("\nTextureAddressCaps:\n"));
6224	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_BORDER)
6225	LogRel((" - D3DPTADDRESSCAPS_BORDER\n"));
6226	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_CLAMP)
6227	LogRel((" - D3DPTADDRESSCAPS_CLAMP\n"));
6228	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_INDEPENDENTUV)
6229	LogRel((" - D3DPTADDRESSCAPS_INDEPENDENTUV\n"));
6230	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_MIRROR)
6231	LogRel((" - D3DPTADDRESSCAPS_MIRROR\n"));
6232	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_MIRRORONCE)
6233	LogRel((" - D3DPTADDRESSCAPS_MIRRORONCE\n"));
6234	if (pCaps->TextureAddressCaps & D3DPTADDRESSCAPS_WRAP)
6235	LogRel((" - D3DPTADDRESSCAPS_WRAP\n"));
6236
6237	LogRel(("\nTextureOpCaps:\n"));
6238	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_DISABLE)
6239	LogRel((" - D3DTEXOPCAPS_DISABLE\n"));
6240	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SELECTARG1)
6241	LogRel((" - D3DTEXOPCAPS_SELECTARG1\n"));
6242	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SELECTARG2)
6243	LogRel((" - D3DTEXOPCAPS_SELECTARG2\n"));
6244	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE)
6245	LogRel((" - D3DTEXOPCAPS_MODULATE\n"));
6246	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE2X)
6247	LogRel((" - D3DTEXOPCAPS_MODULATE2X\n"));
6248	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATE4X)
6249	LogRel((" - D3DTEXOPCAPS_MODULATE4X\n"));
6250	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADD)
6251	LogRel((" - D3DTEXOPCAPS_ADD\n"));
6252	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADDSIGNED)
6253	LogRel((" - D3DTEXOPCAPS_ADDSIGNED\n"));
6254	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADDSIGNED2X)
6255	LogRel((" - D3DTEXOPCAPS_ADDSIGNED2X\n"));
6256	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_SUBTRACT)
6257	LogRel((" - D3DTEXOPCAPS_SUBTRACT\n"));
6258	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_ADDSMOOTH)
6259	LogRel((" - D3DTEXOPCAPS_ADDSMOOTH\n"));
6260	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDDIFFUSEALPHA)
6261	LogRel((" - D3DTEXOPCAPS_BLENDDIFFUSEALPHA\n"));
6262	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDTEXTUREALPHA)
6263	LogRel((" - D3DTEXOPCAPS_BLENDTEXTUREALPHA\n"));
6264	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDFACTORALPHA)
6265	LogRel((" - D3DTEXOPCAPS_BLENDFACTORALPHA\n"));
6266	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDTEXTUREALPHAPM)
6267	LogRel((" - D3DTEXOPCAPS_BLENDTEXTUREALPHAPM\n"));
6268	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BLENDCURRENTALPHA)
6269	LogRel((" - D3DTEXOPCAPS_BLENDCURRENTALPHA\n"));
6270	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_PREMODULATE)
6271	LogRel((" - D3DTEXOPCAPS_PREMODULATE\n"));
6272	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR)
6273	LogRel((" - D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR\n"));
6274	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA)
6275	LogRel((" - D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA\n"));
6276	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR)
6277	LogRel((" - D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR\n"));
6278	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA)
6279	LogRel((" - D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA\n"));
6280	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAP)
6281	LogRel((" - D3DTEXOPCAPS_BUMPENVMAP\n"));
6282	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_BUMPENVMAPLUMINANCE)
6283	LogRel((" - D3DTEXOPCAPS_BUMPENVMAPLUMINANCE\n"));
6284	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_DOTPRODUCT3)
6285	LogRel((" - D3DTEXOPCAPS_DOTPRODUCT3\n"));
6286	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_MULTIPLYADD)
6287	LogRel((" - D3DTEXOPCAPS_MULTIPLYADD\n"));
6288	if (pCaps->TextureOpCaps & D3DTEXOPCAPS_LERP)
6289	LogRel((" - D3DTEXOPCAPS_LERP\n"));
6290
6291	}
6292

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

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

Download in other formats: