DevVGA-SVGA3d-win.cpp@ 54659

Last change on this file since 54659 was 54659, checked in by vboxsync, 10 years ago
DevVGA-SVGA3d-ogl.cpp: Attempt to deal with annoying assertions in for example vmsvga3dSurfaceStretchBlt after surfaces have been ophaned by vmsvga3dContextDestroy.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 254.3 KB

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

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

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

Download in other formats: