svga_dump.c@ 88838

最後變更在這個檔案從88838是 88838,由 vboxsync 提交於 4 年前
Devices/Graphics: attempt to fix mac builds. bugref:9830
屬性 svn:eol-style 設為 `LF`
檔案大小: 100.7 KB

行
1	/**********************************************************
2	* Copyright 2009 VMware, Inc. All rights reserved.
3	*
4	* Permission is hereby granted, free of charge, to any person
5	* obtaining a copy of this software and associated documentation
6	* files (the "Software"), to deal in the Software without
7	* restriction, including without limitation the rights to use, copy,
8	* modify, merge, publish, distribute, sublicense, and/or sell copies
9	* of the Software, and to permit persons to whom the Software is
10	* furnished to do so, subject to the following conditions:
11	*
12	* The above copyright notice and this permission notice shall be
13	* included in all copies or substantial portions of the Software.
14	*
15	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
19	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
20	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22	* SOFTWARE.
23	*
24	**********************************************************/
25
26	/**
27	* @file
28	* Dump SVGA commands.
29	*
30	* Generated automatically from svga3d_reg.h by svga_dump.py.
31	*
32	* Modified for VirtualBox.
33	*/
34
35	#include "svga_types.h"
36	#include "vmsvga_headers_begin.h"
37	#pragma pack(1) /* VMSVGA structures are '__packed'. */
38	#include "svga3d_reg.h"
39	#pragma pack()
40	#include "vmsvga_headers_end.h"
41
42	#include "svga_dump.h"
43
44	#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
45	#include <VBox/log.h>
46
47	#define _debug_printf(...) Log7((__VA_ARGS__));
48
49	#ifdef LOG_ENABLED
50	struct SVGAFormatName
51	{
52	SVGA3dSurfaceFormat f;
53	const char *pszName;
54	};
55
56	static struct SVGAFormatName g_formats[] =
57	{
58	{ SVGA3D_FORMAT_INVALID , "INVALID" },
59	{ SVGA3D_X8R8G8B8 , "X8R8G8B8" },
60	{ SVGA3D_A8R8G8B8 , "A8R8G8B8" },
61	{ SVGA3D_R5G6B5 , "R5G6B5" },
62	{ SVGA3D_X1R5G5B5 , "X1R5G5B5" },
63	{ SVGA3D_A1R5G5B5 , "A1R5G5B5" },
64	{ SVGA3D_A4R4G4B4 , "A4R4G4B4" },
65	{ SVGA3D_Z_D32 , "Z_D32" },
66	{ SVGA3D_Z_D16 , "Z_D16" },
67	{ SVGA3D_Z_D24S8 , "Z_D24S8" },
68	{ SVGA3D_Z_D15S1 , "Z_D15S1" },
69	{ SVGA3D_LUMINANCE8 , "LUMINANCE8" },
70	{ SVGA3D_LUMINANCE4_ALPHA4 , "LUMINANCE4_ALPHA4" },
71	{ SVGA3D_LUMINANCE16 , "LUMINANCE16" },
72	{ SVGA3D_LUMINANCE8_ALPHA8 , "LUMINANCE8_ALPHA8" },
73	{ SVGA3D_DXT1 , "DXT1" },
74	{ SVGA3D_DXT2 , "DXT2" },
75	{ SVGA3D_DXT3 , "DXT3" },
76	{ SVGA3D_DXT4 , "DXT4" },
77	{ SVGA3D_DXT5 , "DXT5" },
78	{ SVGA3D_BUMPU8V8 , "BUMPU8V8" },
79	{ SVGA3D_BUMPL6V5U5 , "BUMPL6V5U5" },
80	{ SVGA3D_BUMPX8L8V8U8 , "BUMPX8L8V8U8" },
81	{ SVGA3D_FORMAT_DEAD1 , "FORMAT_DEAD1" },
82	{ SVGA3D_ARGB_S10E5 , "ARGB_S10E5" },
83	{ SVGA3D_ARGB_S23E8 , "ARGB_S23E8" },
84	{ SVGA3D_A2R10G10B10 , "A2R10G10B10" },
85	{ SVGA3D_V8U8 , "V8U8" },
86	{ SVGA3D_Q8W8V8U8 , "Q8W8V8U8" },
87	{ SVGA3D_CxV8U8 , "CxV8U8" },
88	{ SVGA3D_X8L8V8U8 , "X8L8V8U8" },
89	{ SVGA3D_A2W10V10U10 , "A2W10V10U10" },
90	{ SVGA3D_ALPHA8 , "ALPHA8" },
91	{ SVGA3D_R_S10E5 , "R_S10E5" },
92	{ SVGA3D_R_S23E8 , "R_S23E8" },
93	{ SVGA3D_RG_S10E5 , "RG_S10E5" },
94	{ SVGA3D_RG_S23E8 , "RG_S23E8" },
95	{ SVGA3D_BUFFER , "BUFFER" },
96	{ SVGA3D_Z_D24X8 , "Z_D24X8" },
97	{ SVGA3D_V16U16 , "V16U16" },
98	{ SVGA3D_G16R16 , "G16R16" },
99	{ SVGA3D_A16B16G16R16 , "A16B16G16R16" },
100	{ SVGA3D_UYVY , "UYVY" },
101	{ SVGA3D_YUY2 , "YUY2" },
102	{ SVGA3D_NV12 , "NV12" },
103	{ SVGA3D_FORMAT_DEAD2 , "FORMAT_DEAD2" },
104	{ SVGA3D_R32G32B32A32_TYPELESS , "R32G32B32A32_TYPELESS" },
105	{ SVGA3D_R32G32B32A32_UINT , "R32G32B32A32_UINT" },
106	{ SVGA3D_R32G32B32A32_SINT , "R32G32B32A32_SINT" },
107	{ SVGA3D_R32G32B32_TYPELESS , "R32G32B32_TYPELESS" },
108	{ SVGA3D_R32G32B32_FLOAT , "R32G32B32_FLOAT" },
109	{ SVGA3D_R32G32B32_UINT , "R32G32B32_UINT" },
110	{ SVGA3D_R32G32B32_SINT , "R32G32B32_SINT" },
111	{ SVGA3D_R16G16B16A16_TYPELESS , "R16G16B16A16_TYPELESS" },
112	{ SVGA3D_R16G16B16A16_UINT , "R16G16B16A16_UINT" },
113	{ SVGA3D_R16G16B16A16_SNORM , "R16G16B16A16_SNORM" },
114	{ SVGA3D_R16G16B16A16_SINT , "R16G16B16A16_SINT" },
115	{ SVGA3D_R32G32_TYPELESS , "R32G32_TYPELESS" },
116	{ SVGA3D_R32G32_UINT , "R32G32_UINT" },
117	{ SVGA3D_R32G32_SINT , "R32G32_SINT" },
118	{ SVGA3D_R32G8X24_TYPELESS , "R32G8X24_TYPELESS" },
119	{ SVGA3D_D32_FLOAT_S8X24_UINT , "D32_FLOAT_S8X24_UINT" },
120	{ SVGA3D_R32_FLOAT_X8X24 , "R32_FLOAT_X8X24" },
121	{ SVGA3D_X32_G8X24_UINT , "X32_G8X24_UINT" },
122	{ SVGA3D_R10G10B10A2_TYPELESS , "R10G10B10A2_TYPELESS" },
123	{ SVGA3D_R10G10B10A2_UINT , "R10G10B10A2_UINT" },
124	{ SVGA3D_R11G11B10_FLOAT , "R11G11B10_FLOAT" },
125	{ SVGA3D_R8G8B8A8_TYPELESS , "R8G8B8A8_TYPELESS" },
126	{ SVGA3D_R8G8B8A8_UNORM , "R8G8B8A8_UNORM" },
127	{ SVGA3D_R8G8B8A8_UNORM_SRGB , "R8G8B8A8_UNORM_SRGB" },
128	{ SVGA3D_R8G8B8A8_UINT , "R8G8B8A8_UINT" },
129	{ SVGA3D_R8G8B8A8_SINT , "R8G8B8A8_SINT" },
130	{ SVGA3D_R16G16_TYPELESS , "R16G16_TYPELESS" },
131	{ SVGA3D_R16G16_UINT , "R16G16_UINT" },
132	{ SVGA3D_R16G16_SINT , "R16G16_SINT" },
133	{ SVGA3D_R32_TYPELESS , "R32_TYPELESS" },
134	{ SVGA3D_D32_FLOAT , "D32_FLOAT" },
135	{ SVGA3D_R32_UINT , "R32_UINT" },
136	{ SVGA3D_R32_SINT , "R32_SINT" },
137	{ SVGA3D_R24G8_TYPELESS , "R24G8_TYPELESS" },
138	{ SVGA3D_D24_UNORM_S8_UINT , "D24_UNORM_S8_UINT" },
139	{ SVGA3D_R24_UNORM_X8 , "R24_UNORM_X8" },
140	{ SVGA3D_X24_G8_UINT , "X24_G8_UINT" },
141	{ SVGA3D_R8G8_TYPELESS , "R8G8_TYPELESS" },
142	{ SVGA3D_R8G8_UNORM , "R8G8_UNORM" },
143	{ SVGA3D_R8G8_UINT , "R8G8_UINT" },
144	{ SVGA3D_R8G8_SINT , "R8G8_SINT" },
145	{ SVGA3D_R16_TYPELESS , "R16_TYPELESS" },
146	{ SVGA3D_R16_UNORM , "R16_UNORM" },
147	{ SVGA3D_R16_UINT , "R16_UINT" },
148	{ SVGA3D_R16_SNORM , "R16_SNORM" },
149	{ SVGA3D_R16_SINT , "R16_SINT" },
150	{ SVGA3D_R8_TYPELESS , "R8_TYPELESS" },
151	{ SVGA3D_R8_UNORM , "R8_UNORM" },
152	{ SVGA3D_R8_UINT , "R8_UINT" },
153	{ SVGA3D_R8_SNORM , "R8_SNORM" },
154	{ SVGA3D_R8_SINT , "R8_SINT" },
155	{ SVGA3D_P8 , "P8" },
156	{ SVGA3D_R9G9B9E5_SHAREDEXP , "R9G9B9E5_SHAREDEXP" },
157	{ SVGA3D_R8G8_B8G8_UNORM , "R8G8_B8G8_UNORM" },
158	{ SVGA3D_G8R8_G8B8_UNORM , "G8R8_G8B8_UNORM" },
159	{ SVGA3D_BC1_TYPELESS , "BC1_TYPELESS" },
160	{ SVGA3D_BC1_UNORM_SRGB , "BC1_UNORM_SRGB" },
161	{ SVGA3D_BC2_TYPELESS , "BC2_TYPELESS" },
162	{ SVGA3D_BC2_UNORM_SRGB , "BC2_UNORM_SRGB" },
163	{ SVGA3D_BC3_TYPELESS , "BC3_TYPELESS" },
164	{ SVGA3D_BC3_UNORM_SRGB , "BC3_UNORM_SRGB" },
165	{ SVGA3D_BC4_TYPELESS , "BC4_TYPELESS" },
166	{ SVGA3D_ATI1 , "ATI1" },
167	{ SVGA3D_BC4_SNORM , "BC4_SNORM" },
168	{ SVGA3D_BC5_TYPELESS , "BC5_TYPELESS" },
169	{ SVGA3D_ATI2 , "ATI2" },
170	{ SVGA3D_BC5_SNORM , "BC5_SNORM" },
171	{ SVGA3D_R10G10B10_XR_BIAS_A2_UNORM , "R10G10B10_XR_BIAS_A2_UNORM" },
172	{ SVGA3D_B8G8R8A8_TYPELESS , "B8G8R8A8_TYPELESS" },
173	{ SVGA3D_B8G8R8A8_UNORM_SRGB , "B8G8R8A8_UNORM_SRGB" },
174	{ SVGA3D_B8G8R8X8_TYPELESS , "B8G8R8X8_TYPELESS" },
175	{ SVGA3D_B8G8R8X8_UNORM_SRGB , "B8G8R8X8_UNORM_SRGB" },
176	{ SVGA3D_Z_DF16 , "Z_DF16" },
177	{ SVGA3D_Z_DF24 , "Z_DF24" },
178	{ SVGA3D_Z_D24S8_INT , "Z_D24S8_INT" },
179	{ SVGA3D_YV12 , "YV12" },
180	{ SVGA3D_R32G32B32A32_FLOAT , "R32G32B32A32_FLOAT" },
181	{ SVGA3D_R16G16B16A16_FLOAT , "R16G16B16A16_FLOAT" },
182	{ SVGA3D_R16G16B16A16_UNORM , "R16G16B16A16_UNORM" },
183	{ SVGA3D_R32G32_FLOAT , "R32G32_FLOAT" },
184	{ SVGA3D_R10G10B10A2_UNORM , "R10G10B10A2_UNORM" },
185	{ SVGA3D_R8G8B8A8_SNORM , "R8G8B8A8_SNORM" },
186	{ SVGA3D_R16G16_FLOAT , "R16G16_FLOAT" },
187	{ SVGA3D_R16G16_UNORM , "R16G16_UNORM" },
188	{ SVGA3D_R16G16_SNORM , "R16G16_SNORM" },
189	{ SVGA3D_R32_FLOAT , "R32_FLOAT" },
190	{ SVGA3D_R8G8_SNORM , "R8G8_SNORM" },
191	{ SVGA3D_R16_FLOAT , "R16_FLOAT" },
192	{ SVGA3D_D16_UNORM , "D16_UNORM" },
193	{ SVGA3D_A8_UNORM , "A8_UNORM" },
194	{ SVGA3D_BC1_UNORM , "BC1_UNORM" },
195	{ SVGA3D_BC2_UNORM , "BC2_UNORM" },
196	{ SVGA3D_BC3_UNORM , "BC3_UNORM" },
197	{ SVGA3D_B5G6R5_UNORM , "B5G6R5_UNORM" },
198	{ SVGA3D_B5G5R5A1_UNORM , "B5G5R5A1_UNORM" },
199	{ SVGA3D_B8G8R8A8_UNORM , "B8G8R8A8_UNORM" },
200	{ SVGA3D_B8G8R8X8_UNORM , "B8G8R8X8_UNORM" },
201	{ SVGA3D_BC4_UNORM , "BC4_UNORM" },
202	{ SVGA3D_BC5_UNORM , "BC5_UNORM" },
203	{ SVGA3D_B4G4R4A4_UNORM , "B4G4R4A4_UNORM" },
204	{ SVGA3D_BC6H_TYPELESS , "BC6H_TYPELESS" },
205	{ SVGA3D_BC6H_UF16 , "BC6H_UF16" },
206	{ SVGA3D_BC6H_SF16 , "BC6H_SF16" },
207	{ SVGA3D_BC7_TYPELESS , "BC7_TYPELESS" },
208	{ SVGA3D_BC7_UNORM , "BC7_UNORM" },
209	{ SVGA3D_BC7_UNORM_SRGB , "BC7_UNORM_SRGB" },
210	{ SVGA3D_AYUV , "AYUV" },
211	};
212
213
214	static const char *
215	svga_format_name(SVGA3dSurfaceFormat format)
216	{
217	if (format < RT_ELEMENTS(g_formats))
218	return g_formats[format].pszName;
219	return "???";
220	}
221
222
223	static const char *
224	shader_name(unsigned type)
225	{
226	switch (type) {
227	case SVGA3D_SHADERTYPE_VS:
228	return "SVGA3D_SHADERTYPE_VS";
229	case SVGA3D_SHADERTYPE_PS:
230	return "SVGA3D_SHADERTYPE_PS";
231	case SVGA3D_SHADERTYPE_GS:
232	return "SVGA3D_SHADERTYPE_GS";
233	default:
234	return "unknown shader type!";
235	}
236	}
237
238
239	static void
240	dump_SVGA3dVertexDecl(const SVGA3dVertexDecl *cmd)
241	{
242	switch((*cmd).identity.type) {
243	case SVGA3D_DECLTYPE_FLOAT1:
244	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT1\n");
245	break;
246	case SVGA3D_DECLTYPE_FLOAT2:
247	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT2\n");
248	break;
249	case SVGA3D_DECLTYPE_FLOAT3:
250	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT3\n");
251	break;
252	case SVGA3D_DECLTYPE_FLOAT4:
253	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT4\n");
254	break;
255	case SVGA3D_DECLTYPE_D3DCOLOR:
256	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_D3DCOLOR\n");
257	break;
258	case SVGA3D_DECLTYPE_UBYTE4:
259	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UBYTE4\n");
260	break;
261	case SVGA3D_DECLTYPE_SHORT2:
262	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT2\n");
263	break;
264	case SVGA3D_DECLTYPE_SHORT4:
265	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT4\n");
266	break;
267	case SVGA3D_DECLTYPE_UBYTE4N:
268	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UBYTE4N\n");
269	break;
270	case SVGA3D_DECLTYPE_SHORT2N:
271	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT2N\n");
272	break;
273	case SVGA3D_DECLTYPE_SHORT4N:
274	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT4N\n");
275	break;
276	case SVGA3D_DECLTYPE_USHORT2N:
277	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_USHORT2N\n");
278	break;
279	case SVGA3D_DECLTYPE_USHORT4N:
280	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_USHORT4N\n");
281	break;
282	case SVGA3D_DECLTYPE_UDEC3:
283	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UDEC3\n");
284	break;
285	case SVGA3D_DECLTYPE_DEC3N:
286	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_DEC3N\n");
287	break;
288	case SVGA3D_DECLTYPE_FLOAT16_2:
289	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT16_2\n");
290	break;
291	case SVGA3D_DECLTYPE_FLOAT16_4:
292	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT16_4\n");
293	break;
294	case SVGA3D_DECLTYPE_MAX:
295	_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_MAX\n");
296	break;
297	default:
298	_debug_printf("\t\t.identity.type = %i\n", (*cmd).identity.type);
299	break;
300	}
301	switch((*cmd).identity.method) {
302	case SVGA3D_DECLMETHOD_DEFAULT:
303	_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_DEFAULT\n");
304	break;
305	case SVGA3D_DECLMETHOD_PARTIALU:
306	_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_PARTIALU\n");
307	break;
308	case SVGA3D_DECLMETHOD_PARTIALV:
309	_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_PARTIALV\n");
310	break;
311	case SVGA3D_DECLMETHOD_CROSSUV:
312	_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_CROSSUV\n");
313	break;
314	case SVGA3D_DECLMETHOD_UV:
315	_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_UV\n");
316	break;
317	case SVGA3D_DECLMETHOD_LOOKUP:
318	_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_LOOKUP\n");
319	break;
320	case SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED:
321	_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED\n");
322	break;
323	default:
324	_debug_printf("\t\t.identity.method = %i\n", (*cmd).identity.method);
325	break;
326	}
327	switch((*cmd).identity.usage) {
328	case SVGA3D_DECLUSAGE_POSITION:
329	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_POSITION\n");
330	break;
331	case SVGA3D_DECLUSAGE_BLENDWEIGHT:
332	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BLENDWEIGHT\n");
333	break;
334	case SVGA3D_DECLUSAGE_BLENDINDICES:
335	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BLENDINDICES\n");
336	break;
337	case SVGA3D_DECLUSAGE_NORMAL:
338	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_NORMAL\n");
339	break;
340	case SVGA3D_DECLUSAGE_PSIZE:
341	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_PSIZE\n");
342	break;
343	case SVGA3D_DECLUSAGE_TEXCOORD:
344	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TEXCOORD\n");
345	break;
346	case SVGA3D_DECLUSAGE_TANGENT:
347	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TANGENT\n");
348	break;
349	case SVGA3D_DECLUSAGE_BINORMAL:
350	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BINORMAL\n");
351	break;
352	case SVGA3D_DECLUSAGE_TESSFACTOR:
353	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TESSFACTOR\n");
354	break;
355	case SVGA3D_DECLUSAGE_POSITIONT:
356	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_POSITIONT\n");
357	break;
358	case SVGA3D_DECLUSAGE_COLOR:
359	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_COLOR\n");
360	break;
361	case SVGA3D_DECLUSAGE_FOG:
362	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_FOG\n");
363	break;
364	case SVGA3D_DECLUSAGE_DEPTH:
365	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_DEPTH\n");
366	break;
367	case SVGA3D_DECLUSAGE_SAMPLE:
368	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_SAMPLE\n");
369	break;
370	case SVGA3D_DECLUSAGE_MAX:
371	_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_MAX\n");
372	break;
373	default:
374	_debug_printf("\t\t.identity.usage = %i\n", (*cmd).identity.usage);
375	break;
376	}
377	_debug_printf("\t\t.identity.usageIndex = %u\n", (*cmd).identity.usageIndex);
378	_debug_printf("\t\t.array.surfaceId = %u\n", (*cmd).array.surfaceId);
379	_debug_printf("\t\t.array.offset = %u\n", (*cmd).array.offset);
380	_debug_printf("\t\t.array.stride = %u\n", (*cmd).array.stride);
381	_debug_printf("\t\t.rangeHint.first = %u\n", (*cmd).rangeHint.first);
382	_debug_printf("\t\t.rangeHint.last = %u\n", (*cmd).rangeHint.last);
383	}
384
385	static void
386	dump_SVGA3dTextureState(const SVGA3dTextureState *cmd)
387	{
388	_debug_printf("\t\t.stage = %u\n", (*cmd).stage);
389	switch((*cmd).name) {
390	case SVGA3D_TS_INVALID:
391	_debug_printf("\t\t.name = SVGA3D_TS_INVALID\n");
392	break;
393	case SVGA3D_TS_BIND_TEXTURE:
394	_debug_printf("\t\t.name = SVGA3D_TS_BIND_TEXTURE\n");
395	break;
396	case SVGA3D_TS_COLOROP:
397	_debug_printf("\t\t.name = SVGA3D_TS_COLOROP\n");
398	break;
399	case SVGA3D_TS_COLORARG1:
400	_debug_printf("\t\t.name = SVGA3D_TS_COLORARG1\n");
401	break;
402	case SVGA3D_TS_COLORARG2:
403	_debug_printf("\t\t.name = SVGA3D_TS_COLORARG2\n");
404	break;
405	case SVGA3D_TS_ALPHAOP:
406	_debug_printf("\t\t.name = SVGA3D_TS_ALPHAOP\n");
407	break;
408	case SVGA3D_TS_ALPHAARG1:
409	_debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG1\n");
410	break;
411	case SVGA3D_TS_ALPHAARG2:
412	_debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG2\n");
413	break;
414	case SVGA3D_TS_ADDRESSU:
415	_debug_printf("\t\t.name = SVGA3D_TS_ADDRESSU\n");
416	break;
417	case SVGA3D_TS_ADDRESSV:
418	_debug_printf("\t\t.name = SVGA3D_TS_ADDRESSV\n");
419	break;
420	case SVGA3D_TS_MIPFILTER:
421	_debug_printf("\t\t.name = SVGA3D_TS_MIPFILTER\n");
422	break;
423	case SVGA3D_TS_MAGFILTER:
424	_debug_printf("\t\t.name = SVGA3D_TS_MAGFILTER\n");
425	break;
426	case SVGA3D_TS_MINFILTER:
427	_debug_printf("\t\t.name = SVGA3D_TS_MINFILTER\n");
428	break;
429	case SVGA3D_TS_BORDERCOLOR:
430	_debug_printf("\t\t.name = SVGA3D_TS_BORDERCOLOR\n");
431	break;
432	case SVGA3D_TS_TEXCOORDINDEX:
433	_debug_printf("\t\t.name = SVGA3D_TS_TEXCOORDINDEX\n");
434	break;
435	case SVGA3D_TS_TEXTURETRANSFORMFLAGS:
436	_debug_printf("\t\t.name = SVGA3D_TS_TEXTURETRANSFORMFLAGS\n");
437	break;
438	case SVGA3D_TS_TEXCOORDGEN:
439	_debug_printf("\t\t.name = SVGA3D_TS_TEXCOORDGEN\n");
440	break;
441	case SVGA3D_TS_BUMPENVMAT00:
442	_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT00\n");
443	break;
444	case SVGA3D_TS_BUMPENVMAT01:
445	_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT01\n");
446	break;
447	case SVGA3D_TS_BUMPENVMAT10:
448	_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT10\n");
449	break;
450	case SVGA3D_TS_BUMPENVMAT11:
451	_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT11\n");
452	break;
453	case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL:
454	_debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_MIPMAP_LEVEL\n");
455	break;
456	case SVGA3D_TS_TEXTURE_LOD_BIAS:
457	_debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_LOD_BIAS\n");
458	break;
459	case SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL:
460	_debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL\n");
461	break;
462	case SVGA3D_TS_ADDRESSW:
463	_debug_printf("\t\t.name = SVGA3D_TS_ADDRESSW\n");
464	break;
465	case SVGA3D_TS_GAMMA:
466	_debug_printf("\t\t.name = SVGA3D_TS_GAMMA\n");
467	break;
468	case SVGA3D_TS_BUMPENVLSCALE:
469	_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVLSCALE\n");
470	break;
471	case SVGA3D_TS_BUMPENVLOFFSET:
472	_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVLOFFSET\n");
473	break;
474	case SVGA3D_TS_COLORARG0:
475	_debug_printf("\t\t.name = SVGA3D_TS_COLORARG0\n");
476	break;
477	case SVGA3D_TS_ALPHAARG0:
478	_debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG0\n");
479	break;
480	case SVGA3D_TS_MAX:
481	_debug_printf("\t\t.name = SVGA3D_TS_MAX\n");
482	break;
483	default:
484	_debug_printf("\t\t.name = %i\n", (*cmd).name);
485	break;
486	}
487	_debug_printf("\t\t.value = %u\n", (*cmd).value);
488	_debug_printf("\t\t.floatValue = %R[float]\n", (*cmd).floatValue);
489	}
490
491	static void
492	dump_SVGA3dViewport(const SVGA3dViewport *cmd)
493	{
494	_debug_printf("\t\t.x = %R[float]\n", (*cmd).x);
495	_debug_printf("\t\t.y = %R[float]\n", (*cmd).y);
496	_debug_printf("\t\t.width = %R[float]\n", (*cmd).width);
497	_debug_printf("\t\t.height = %R[float]\n", (*cmd).height);
498	_debug_printf("\t\t.minDepth = %R[float]\n", (*cmd).minDepth);
499	_debug_printf("\t\t.maxDepth = %R[float]\n", (*cmd).maxDepth);
500	}
501
502	static void
503	dump_SVGA3dSamplerId(const SVGA3dSamplerId *cmd)
504	{
505	_debug_printf("\t\t.id = %u\n", *cmd);
506	}
507
508	static void
509	dump_SVGA3dSoTarget(const SVGA3dSoTarget *cmd)
510	{
511	_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
512	_debug_printf("\t\t.offset = %u\n", (*cmd).offset);
513	}
514
515	static void
516	dump_SVGA3dInputElementDesc(const SVGA3dInputElementDesc *cmd)
517	{
518	_debug_printf("\t\t.inputSlot = %u\n", (*cmd).inputSlot);
519	_debug_printf("\t\t.alignedByteOffset = %u\n", (*cmd).alignedByteOffset);
520	_debug_printf("\t\t.format = %s\n", svga_format_name((*cmd).format));
521	_debug_printf("\t\t.inputSlotClass = %u\n", (*cmd).inputSlotClass);
522	_debug_printf("\t\t.instanceDataStepRate = %u\n", (*cmd).instanceDataStepRate);
523	_debug_printf("\t\t.inputRegister = %u\n", (*cmd).inputRegister);
524	}
525
526	static void
527	dump_SVGA3dVertexBuffer(const SVGA3dVertexBuffer *cmd)
528	{
529	_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
530	_debug_printf("\t\t.stride = %u\n", (*cmd).stride);
531	_debug_printf("\t\t.offset = %u\n", (*cmd).offset);
532	}
533
534	static void
535	dump_SVGA3dCopyBox(const SVGA3dCopyBox *cmd)
536	{
537	_debug_printf("\t\t.x = %u\n", (*cmd).x);
538	_debug_printf("\t\t.y = %u\n", (*cmd).y);
539	_debug_printf("\t\t.z = %u\n", (*cmd).z);
540	_debug_printf("\t\t.w = %u\n", (*cmd).w);
541	_debug_printf("\t\t.h = %u\n", (*cmd).h);
542	_debug_printf("\t\t.d = %u\n", (*cmd).d);
543	_debug_printf("\t\t.srcx = %u\n", (*cmd).srcx);
544	_debug_printf("\t\t.srcy = %u\n", (*cmd).srcy);
545	_debug_printf("\t\t.srcz = %u\n", (*cmd).srcz);
546	}
547
548	static void
549	dump_SVGA3dShaderResourceViewId(const SVGA3dShaderResourceViewId *id)
550	{
551	_debug_printf("\t\t.id = %u\n", *id);
552	}
553
554	static void
555	dump_SVGA3dCmdSetClipPlane(const SVGA3dCmdSetClipPlane *cmd)
556	{
557	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
558	_debug_printf("\t\t.index = %u\n", (*cmd).index);
559	_debug_printf("\t\t.plane[0] = %R[float]\n", (*cmd).plane[0]);
560	_debug_printf("\t\t.plane[1] = %R[float]\n", (*cmd).plane[1]);
561	_debug_printf("\t\t.plane[2] = %R[float]\n", (*cmd).plane[2]);
562	_debug_printf("\t\t.plane[3] = %R[float]\n", (*cmd).plane[3]);
563	}
564
565	static void
566	dump_SVGA3dCmdWaitForQuery(const SVGA3dCmdWaitForQuery *cmd)
567	{
568	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
569	switch((*cmd).type) {
570	case SVGA3D_QUERYTYPE_OCCLUSION:
571	_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
572	break;
573	case SVGA3D_QUERYTYPE_MAX:
574	_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
575	break;
576	default:
577	_debug_printf("\t\t.type = %i\n", (*cmd).type);
578	break;
579	}
580	_debug_printf("\t\t.guestResult.gmrId = %u\n", (*cmd).guestResult.gmrId);
581	_debug_printf("\t\t.guestResult.offset = %u\n", (*cmd).guestResult.offset);
582	}
583
584	static void
585	dump_SVGA3dCmdSetRenderTarget(const SVGA3dCmdSetRenderTarget *cmd)
586	{
587	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
588	switch((*cmd).type) {
589	case SVGA3D_RT_DEPTH:
590	_debug_printf("\t\t.type = SVGA3D_RT_DEPTH\n");
591	break;
592	case SVGA3D_RT_STENCIL:
593	_debug_printf("\t\t.type = SVGA3D_RT_STENCIL\n");
594	break;
595	default:
596	_debug_printf("\t\t.type = SVGA3D_RT_COLOR%u\n", (*cmd).type - SVGA3D_RT_COLOR0);
597	break;
598	}
599	_debug_printf("\t\t.target.sid = %u\n", (*cmd).target.sid);
600	_debug_printf("\t\t.target.face = %u\n", (*cmd).target.face);
601	_debug_printf("\t\t.target.mipmap = %u\n", (*cmd).target.mipmap);
602	}
603
604	static void
605	dump_SVGA3dCmdSetTextureState(const SVGA3dCmdSetTextureState *cmd)
606	{
607	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
608	}
609
610	static void
611	dump_SVGA3dCmdSurfaceCopy(const SVGA3dCmdSurfaceCopy *cmd)
612	{
613	_debug_printf("\t\t.src.sid = %u\n", (*cmd).src.sid);
614	_debug_printf("\t\t.src.face = %u\n", (*cmd).src.face);
615	_debug_printf("\t\t.src.mipmap = %u\n", (*cmd).src.mipmap);
616	_debug_printf("\t\t.dest.sid = %u\n", (*cmd).dest.sid);
617	_debug_printf("\t\t.dest.face = %u\n", (*cmd).dest.face);
618	_debug_printf("\t\t.dest.mipmap = %u\n", (*cmd).dest.mipmap);
619	}
620
621	static void
622	dump_SVGA3dCmdSetMaterial(const SVGA3dCmdSetMaterial *cmd)
623	{
624	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
625	switch((*cmd).face) {
626	case SVGA3D_FACE_INVALID:
627	_debug_printf("\t\t.face = SVGA3D_FACE_INVALID\n");
628	break;
629	case SVGA3D_FACE_NONE:
630	_debug_printf("\t\t.face = SVGA3D_FACE_NONE\n");
631	break;
632	case SVGA3D_FACE_FRONT:
633	_debug_printf("\t\t.face = SVGA3D_FACE_FRONT\n");
634	break;
635	case SVGA3D_FACE_BACK:
636	_debug_printf("\t\t.face = SVGA3D_FACE_BACK\n");
637	break;
638	case SVGA3D_FACE_FRONT_BACK:
639	_debug_printf("\t\t.face = SVGA3D_FACE_FRONT_BACK\n");
640	break;
641	case SVGA3D_FACE_MAX:
642	_debug_printf("\t\t.face = SVGA3D_FACE_MAX\n");
643	break;
644	default:
645	_debug_printf("\t\t.face = %i\n", (*cmd).face);
646	break;
647	}
648	_debug_printf("\t\t.material.diffuse[0] = %R[float]\n", (*cmd).material.diffuse[0]);
649	_debug_printf("\t\t.material.diffuse[1] = %R[float]\n", (*cmd).material.diffuse[1]);
650	_debug_printf("\t\t.material.diffuse[2] = %R[float]\n", (*cmd).material.diffuse[2]);
651	_debug_printf("\t\t.material.diffuse[3] = %R[float]\n", (*cmd).material.diffuse[3]);
652	_debug_printf("\t\t.material.ambient[0] = %R[float]\n", (*cmd).material.ambient[0]);
653	_debug_printf("\t\t.material.ambient[1] = %R[float]\n", (*cmd).material.ambient[1]);
654	_debug_printf("\t\t.material.ambient[2] = %R[float]\n", (*cmd).material.ambient[2]);
655	_debug_printf("\t\t.material.ambient[3] = %R[float]\n", (*cmd).material.ambient[3]);
656	_debug_printf("\t\t.material.specular[0] = %R[float]\n", (*cmd).material.specular[0]);
657	_debug_printf("\t\t.material.specular[1] = %R[float]\n", (*cmd).material.specular[1]);
658	_debug_printf("\t\t.material.specular[2] = %R[float]\n", (*cmd).material.specular[2]);
659	_debug_printf("\t\t.material.specular[3] = %R[float]\n", (*cmd).material.specular[3]);
660	_debug_printf("\t\t.material.emissive[0] = %R[float]\n", (*cmd).material.emissive[0]);
661	_debug_printf("\t\t.material.emissive[1] = %R[float]\n", (*cmd).material.emissive[1]);
662	_debug_printf("\t\t.material.emissive[2] = %R[float]\n", (*cmd).material.emissive[2]);
663	_debug_printf("\t\t.material.emissive[3] = %R[float]\n", (*cmd).material.emissive[3]);
664	_debug_printf("\t\t.material.shininess = %R[float]\n", (*cmd).material.shininess);
665	}
666
667	static void
668	dump_SVGA3dCmdSetLightData(const SVGA3dCmdSetLightData *cmd)
669	{
670	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
671	_debug_printf("\t\t.index = %u\n", (*cmd).index);
672	switch((*cmd).data.type) {
673	case SVGA3D_LIGHTTYPE_INVALID:
674	_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_INVALID\n");
675	break;
676	case SVGA3D_LIGHTTYPE_POINT:
677	_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_POINT\n");
678	break;
679	case SVGA3D_LIGHTTYPE_SPOT1:
680	_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_SPOT1\n");
681	break;
682	case SVGA3D_LIGHTTYPE_SPOT2:
683	_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_SPOT2\n");
684	break;
685	case SVGA3D_LIGHTTYPE_DIRECTIONAL:
686	_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_DIRECTIONAL\n");
687	break;
688	case SVGA3D_LIGHTTYPE_MAX:
689	_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_MAX\n");
690	break;
691	default:
692	_debug_printf("\t\t.data.type = %i\n", (*cmd).data.type);
693	break;
694	}
695	_debug_printf("\t\t.data.inWorldSpace = %u\n", (*cmd).data.inWorldSpace);
696	_debug_printf("\t\t.data.diffuse[0] = %R[float]\n", (*cmd).data.diffuse[0]);
697	_debug_printf("\t\t.data.diffuse[1] = %R[float]\n", (*cmd).data.diffuse[1]);
698	_debug_printf("\t\t.data.diffuse[2] = %R[float]\n", (*cmd).data.diffuse[2]);
699	_debug_printf("\t\t.data.diffuse[3] = %R[float]\n", (*cmd).data.diffuse[3]);
700	_debug_printf("\t\t.data.specular[0] = %R[float]\n", (*cmd).data.specular[0]);
701	_debug_printf("\t\t.data.specular[1] = %R[float]\n", (*cmd).data.specular[1]);
702	_debug_printf("\t\t.data.specular[2] = %R[float]\n", (*cmd).data.specular[2]);
703	_debug_printf("\t\t.data.specular[3] = %R[float]\n", (*cmd).data.specular[3]);
704	_debug_printf("\t\t.data.ambient[0] = %R[float]\n", (*cmd).data.ambient[0]);
705	_debug_printf("\t\t.data.ambient[1] = %R[float]\n", (*cmd).data.ambient[1]);
706	_debug_printf("\t\t.data.ambient[2] = %R[float]\n", (*cmd).data.ambient[2]);
707	_debug_printf("\t\t.data.ambient[3] = %R[float]\n", (*cmd).data.ambient[3]);
708	_debug_printf("\t\t.data.position[0] = %R[float]\n", (*cmd).data.position[0]);
709	_debug_printf("\t\t.data.position[1] = %R[float]\n", (*cmd).data.position[1]);
710	_debug_printf("\t\t.data.position[2] = %R[float]\n", (*cmd).data.position[2]);
711	_debug_printf("\t\t.data.position[3] = %R[float]\n", (*cmd).data.position[3]);
712	_debug_printf("\t\t.data.direction[0] = %R[float]\n", (*cmd).data.direction[0]);
713	_debug_printf("\t\t.data.direction[1] = %R[float]\n", (*cmd).data.direction[1]);
714	_debug_printf("\t\t.data.direction[2] = %R[float]\n", (*cmd).data.direction[2]);
715	_debug_printf("\t\t.data.direction[3] = %R[float]\n", (*cmd).data.direction[3]);
716	_debug_printf("\t\t.data.range = %R[float]\n", (*cmd).data.range);
717	_debug_printf("\t\t.data.falloff = %R[float]\n", (*cmd).data.falloff);
718	_debug_printf("\t\t.data.attenuation0 = %R[float]\n", (*cmd).data.attenuation0);
719	_debug_printf("\t\t.data.attenuation1 = %R[float]\n", (*cmd).data.attenuation1);
720	_debug_printf("\t\t.data.attenuation2 = %R[float]\n", (*cmd).data.attenuation2);
721	_debug_printf("\t\t.data.theta = %R[float]\n", (*cmd).data.theta);
722	_debug_printf("\t\t.data.phi = %R[float]\n", (*cmd).data.phi);
723	}
724
725	static void
726	dump_SVGA3dCmdSetViewport(const SVGA3dCmdSetViewport *cmd)
727	{
728	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
729	_debug_printf("\t\t.rect.x = %u\n", (*cmd).rect.x);
730	_debug_printf("\t\t.rect.y = %u\n", (*cmd).rect.y);
731	_debug_printf("\t\t.rect.w = %u\n", (*cmd).rect.w);
732	_debug_printf("\t\t.rect.h = %u\n", (*cmd).rect.h);
733	}
734
735	static void
736	dump_SVGA3dCmdSetScissorRect(const SVGA3dCmdSetScissorRect *cmd)
737	{
738	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
739	_debug_printf("\t\t.rect.x = %u\n", (*cmd).rect.x);
740	_debug_printf("\t\t.rect.y = %u\n", (*cmd).rect.y);
741	_debug_printf("\t\t.rect.w = %u\n", (*cmd).rect.w);
742	_debug_printf("\t\t.rect.h = %u\n", (*cmd).rect.h);
743	}
744
745	static void
746	dump_SVGA3dCopyRect(const SVGA3dCopyRect *cmd)
747	{
748	_debug_printf("\t\t.x = %u\n", (*cmd).x);
749	_debug_printf("\t\t.y = %u\n", (*cmd).y);
750	_debug_printf("\t\t.w = %u\n", (*cmd).w);
751	_debug_printf("\t\t.h = %u\n", (*cmd).h);
752	_debug_printf("\t\t.srcx = %u\n", (*cmd).srcx);
753	_debug_printf("\t\t.srcy = %u\n", (*cmd).srcy);
754	}
755
756	static void
757	dump_SVGA3dCmdSetShader(const SVGA3dCmdSetShader *cmd)
758	{
759	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
760	_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
761	_debug_printf("\t\t.shid = %u\n", (*cmd).shid);
762	}
763
764	static void
765	dump_SVGA3dCmdEndQuery(const SVGA3dCmdEndQuery *cmd)
766	{
767	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
768	switch((*cmd).type) {
769	case SVGA3D_QUERYTYPE_OCCLUSION:
770	_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
771	break;
772	case SVGA3D_QUERYTYPE_MAX:
773	_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
774	break;
775	default:
776	_debug_printf("\t\t.type = %i\n", (*cmd).type);
777	break;
778	}
779	_debug_printf("\t\t.guestResult.gmrId = %u\n", (*cmd).guestResult.gmrId);
780	_debug_printf("\t\t.guestResult.offset = %u\n", (*cmd).guestResult.offset);
781	}
782
783	static void
784	dump_SVGA3dSize(const SVGA3dSize *cmd)
785	{
786	_debug_printf("\t\t.width = %u\n", (*cmd).width);
787	_debug_printf("\t\t.height = %u\n", (*cmd).height);
788	_debug_printf("\t\t.depth = %u\n", (*cmd).depth);
789	}
790
791	static void
792	dump_SVGA3dCmdDestroySurface(const SVGA3dCmdDestroySurface *cmd)
793	{
794	_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
795	}
796
797	static void
798	dump_SVGA3dCmdDefineContext(const SVGA3dCmdDefineContext *cmd)
799	{
800	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
801	}
802
803	static void
804	dump_SVGA3dRect(const SVGA3dRect *cmd)
805	{
806	_debug_printf("\t\t.x = %u\n", (*cmd).x);
807	_debug_printf("\t\t.y = %u\n", (*cmd).y);
808	_debug_printf("\t\t.w = %u\n", (*cmd).w);
809	_debug_printf("\t\t.h = %u\n", (*cmd).h);
810	}
811
812	static void
813	dump_SVGA3dCmdBeginQuery(const SVGA3dCmdBeginQuery *cmd)
814	{
815	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
816	switch((*cmd).type) {
817	case SVGA3D_QUERYTYPE_OCCLUSION:
818	_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
819	break;
820	case SVGA3D_QUERYTYPE_MAX:
821	_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
822	break;
823	default:
824	_debug_printf("\t\t.type = %i\n", (*cmd).type);
825	break;
826	}
827	}
828
829	static void
830	dump_SVGA3dRenderState(const SVGA3dRenderState *cmd)
831	{
832	switch((*cmd).state) {
833	case SVGA3D_RS_INVALID:
834	_debug_printf("\t\t.state = SVGA3D_RS_INVALID\n");
835	break;
836	case SVGA3D_RS_ZENABLE:
837	_debug_printf("\t\t.state = SVGA3D_RS_ZENABLE\n");
838	break;
839	case SVGA3D_RS_ZWRITEENABLE:
840	_debug_printf("\t\t.state = SVGA3D_RS_ZWRITEENABLE\n");
841	break;
842	case SVGA3D_RS_ALPHATESTENABLE:
843	_debug_printf("\t\t.state = SVGA3D_RS_ALPHATESTENABLE\n");
844	break;
845	case SVGA3D_RS_DITHERENABLE:
846	_debug_printf("\t\t.state = SVGA3D_RS_DITHERENABLE\n");
847	break;
848	case SVGA3D_RS_BLENDENABLE:
849	_debug_printf("\t\t.state = SVGA3D_RS_BLENDENABLE\n");
850	break;
851	case SVGA3D_RS_FOGENABLE:
852	_debug_printf("\t\t.state = SVGA3D_RS_FOGENABLE\n");
853	break;
854	case SVGA3D_RS_SPECULARENABLE:
855	_debug_printf("\t\t.state = SVGA3D_RS_SPECULARENABLE\n");
856	break;
857	case SVGA3D_RS_STENCILENABLE:
858	_debug_printf("\t\t.state = SVGA3D_RS_STENCILENABLE\n");
859	break;
860	case SVGA3D_RS_LIGHTINGENABLE:
861	_debug_printf("\t\t.state = SVGA3D_RS_LIGHTINGENABLE\n");
862	break;
863	case SVGA3D_RS_NORMALIZENORMALS:
864	_debug_printf("\t\t.state = SVGA3D_RS_NORMALIZENORMALS\n");
865	break;
866	case SVGA3D_RS_POINTSPRITEENABLE:
867	_debug_printf("\t\t.state = SVGA3D_RS_POINTSPRITEENABLE\n");
868	break;
869	case SVGA3D_RS_POINTSCALEENABLE:
870	_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALEENABLE\n");
871	break;
872	case SVGA3D_RS_STENCILREF:
873	_debug_printf("\t\t.state = SVGA3D_RS_STENCILREF\n");
874	break;
875	case SVGA3D_RS_STENCILMASK:
876	_debug_printf("\t\t.state = SVGA3D_RS_STENCILMASK\n");
877	break;
878	case SVGA3D_RS_STENCILWRITEMASK:
879	_debug_printf("\t\t.state = SVGA3D_RS_STENCILWRITEMASK\n");
880	break;
881	case SVGA3D_RS_FOGSTART:
882	_debug_printf("\t\t.state = SVGA3D_RS_FOGSTART\n");
883	break;
884	case SVGA3D_RS_FOGEND:
885	_debug_printf("\t\t.state = SVGA3D_RS_FOGEND\n");
886	break;
887	case SVGA3D_RS_FOGDENSITY:
888	_debug_printf("\t\t.state = SVGA3D_RS_FOGDENSITY\n");
889	break;
890	case SVGA3D_RS_POINTSIZE:
891	_debug_printf("\t\t.state = SVGA3D_RS_POINTSIZE\n");
892	break;
893	case SVGA3D_RS_POINTSIZEMIN:
894	_debug_printf("\t\t.state = SVGA3D_RS_POINTSIZEMIN\n");
895	break;
896	case SVGA3D_RS_POINTSIZEMAX:
897	_debug_printf("\t\t.state = SVGA3D_RS_POINTSIZEMAX\n");
898	break;
899	case SVGA3D_RS_POINTSCALE_A:
900	_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_A\n");
901	break;
902	case SVGA3D_RS_POINTSCALE_B:
903	_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_B\n");
904	break;
905	case SVGA3D_RS_POINTSCALE_C:
906	_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_C\n");
907	break;
908	case SVGA3D_RS_FOGCOLOR:
909	_debug_printf("\t\t.state = SVGA3D_RS_FOGCOLOR\n");
910	break;
911	case SVGA3D_RS_AMBIENT:
912	_debug_printf("\t\t.state = SVGA3D_RS_AMBIENT\n");
913	break;
914	case SVGA3D_RS_CLIPPLANEENABLE:
915	_debug_printf("\t\t.state = SVGA3D_RS_CLIPPLANEENABLE\n");
916	break;
917	case SVGA3D_RS_FOGMODE:
918	_debug_printf("\t\t.state = SVGA3D_RS_FOGMODE\n");
919	break;
920	case SVGA3D_RS_FILLMODE:
921	_debug_printf("\t\t.state = SVGA3D_RS_FILLMODE\n");
922	break;
923	case SVGA3D_RS_SHADEMODE:
924	_debug_printf("\t\t.state = SVGA3D_RS_SHADEMODE\n");
925	break;
926	case SVGA3D_RS_LINEPATTERN:
927	_debug_printf("\t\t.state = SVGA3D_RS_LINEPATTERN\n");
928	break;
929	case SVGA3D_RS_SRCBLEND:
930	_debug_printf("\t\t.state = SVGA3D_RS_SRCBLEND\n");
931	break;
932	case SVGA3D_RS_DSTBLEND:
933	_debug_printf("\t\t.state = SVGA3D_RS_DSTBLEND\n");
934	break;
935	case SVGA3D_RS_BLENDEQUATION:
936	_debug_printf("\t\t.state = SVGA3D_RS_BLENDEQUATION\n");
937	break;
938	case SVGA3D_RS_CULLMODE:
939	_debug_printf("\t\t.state = SVGA3D_RS_CULLMODE\n");
940	break;
941	case SVGA3D_RS_ZFUNC:
942	_debug_printf("\t\t.state = SVGA3D_RS_ZFUNC\n");
943	break;
944	case SVGA3D_RS_ALPHAFUNC:
945	_debug_printf("\t\t.state = SVGA3D_RS_ALPHAFUNC\n");
946	break;
947	case SVGA3D_RS_STENCILFUNC:
948	_debug_printf("\t\t.state = SVGA3D_RS_STENCILFUNC\n");
949	break;
950	case SVGA3D_RS_STENCILFAIL:
951	_debug_printf("\t\t.state = SVGA3D_RS_STENCILFAIL\n");
952	break;
953	case SVGA3D_RS_STENCILZFAIL:
954	_debug_printf("\t\t.state = SVGA3D_RS_STENCILZFAIL\n");
955	break;
956	case SVGA3D_RS_STENCILPASS:
957	_debug_printf("\t\t.state = SVGA3D_RS_STENCILPASS\n");
958	break;
959	case SVGA3D_RS_ALPHAREF:
960	_debug_printf("\t\t.state = SVGA3D_RS_ALPHAREF\n");
961	break;
962	case SVGA3D_RS_FRONTWINDING:
963	_debug_printf("\t\t.state = SVGA3D_RS_FRONTWINDING\n");
964	break;
965	case SVGA3D_RS_COORDINATETYPE:
966	_debug_printf("\t\t.state = SVGA3D_RS_COORDINATETYPE\n");
967	break;
968	case SVGA3D_RS_ZBIAS:
969	_debug_printf("\t\t.state = SVGA3D_RS_ZBIAS\n");
970	break;
971	case SVGA3D_RS_RANGEFOGENABLE:
972	_debug_printf("\t\t.state = SVGA3D_RS_RANGEFOGENABLE\n");
973	break;
974	case SVGA3D_RS_COLORWRITEENABLE:
975	_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE\n");
976	break;
977	case SVGA3D_RS_VERTEXMATERIALENABLE:
978	_debug_printf("\t\t.state = SVGA3D_RS_VERTEXMATERIALENABLE\n");
979	break;
980	case SVGA3D_RS_DIFFUSEMATERIALSOURCE:
981	_debug_printf("\t\t.state = SVGA3D_RS_DIFFUSEMATERIALSOURCE\n");
982	break;
983	case SVGA3D_RS_SPECULARMATERIALSOURCE:
984	_debug_printf("\t\t.state = SVGA3D_RS_SPECULARMATERIALSOURCE\n");
985	break;
986	case SVGA3D_RS_AMBIENTMATERIALSOURCE:
987	_debug_printf("\t\t.state = SVGA3D_RS_AMBIENTMATERIALSOURCE\n");
988	break;
989	case SVGA3D_RS_EMISSIVEMATERIALSOURCE:
990	_debug_printf("\t\t.state = SVGA3D_RS_EMISSIVEMATERIALSOURCE\n");
991	break;
992	case SVGA3D_RS_TEXTUREFACTOR:
993	_debug_printf("\t\t.state = SVGA3D_RS_TEXTUREFACTOR\n");
994	break;
995	case SVGA3D_RS_LOCALVIEWER:
996	_debug_printf("\t\t.state = SVGA3D_RS_LOCALVIEWER\n");
997	break;
998	case SVGA3D_RS_SCISSORTESTENABLE:
999	_debug_printf("\t\t.state = SVGA3D_RS_SCISSORTESTENABLE\n");
1000	break;
1001	case SVGA3D_RS_BLENDCOLOR:
1002	_debug_printf("\t\t.state = SVGA3D_RS_BLENDCOLOR\n");
1003	break;
1004	case SVGA3D_RS_STENCILENABLE2SIDED:
1005	_debug_printf("\t\t.state = SVGA3D_RS_STENCILENABLE2SIDED\n");
1006	break;
1007	case SVGA3D_RS_CCWSTENCILFUNC:
1008	_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILFUNC\n");
1009	break;
1010	case SVGA3D_RS_CCWSTENCILFAIL:
1011	_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILFAIL\n");
1012	break;
1013	case SVGA3D_RS_CCWSTENCILZFAIL:
1014	_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILZFAIL\n");
1015	break;
1016	case SVGA3D_RS_CCWSTENCILPASS:
1017	_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILPASS\n");
1018	break;
1019	case SVGA3D_RS_VERTEXBLEND:
1020	_debug_printf("\t\t.state = SVGA3D_RS_VERTEXBLEND\n");
1021	break;
1022	case SVGA3D_RS_SLOPESCALEDEPTHBIAS:
1023	_debug_printf("\t\t.state = SVGA3D_RS_SLOPESCALEDEPTHBIAS\n");
1024	break;
1025	case SVGA3D_RS_DEPTHBIAS:
1026	_debug_printf("\t\t.state = SVGA3D_RS_DEPTHBIAS\n");
1027	break;
1028	case SVGA3D_RS_OUTPUTGAMMA:
1029	_debug_printf("\t\t.state = SVGA3D_RS_OUTPUTGAMMA\n");
1030	break;
1031	case SVGA3D_RS_ZVISIBLE:
1032	_debug_printf("\t\t.state = SVGA3D_RS_ZVISIBLE\n");
1033	break;
1034	case SVGA3D_RS_LASTPIXEL:
1035	_debug_printf("\t\t.state = SVGA3D_RS_LASTPIXEL\n");
1036	break;
1037	case SVGA3D_RS_CLIPPING:
1038	_debug_printf("\t\t.state = SVGA3D_RS_CLIPPING\n");
1039	break;
1040	case SVGA3D_RS_WRAP0:
1041	_debug_printf("\t\t.state = SVGA3D_RS_WRAP0\n");
1042	break;
1043	case SVGA3D_RS_WRAP1:
1044	_debug_printf("\t\t.state = SVGA3D_RS_WRAP1\n");
1045	break;
1046	case SVGA3D_RS_WRAP2:
1047	_debug_printf("\t\t.state = SVGA3D_RS_WRAP2\n");
1048	break;
1049	case SVGA3D_RS_WRAP3:
1050	_debug_printf("\t\t.state = SVGA3D_RS_WRAP3\n");
1051	break;
1052	case SVGA3D_RS_WRAP4:
1053	_debug_printf("\t\t.state = SVGA3D_RS_WRAP4\n");
1054	break;
1055	case SVGA3D_RS_WRAP5:
1056	_debug_printf("\t\t.state = SVGA3D_RS_WRAP5\n");
1057	break;
1058	case SVGA3D_RS_WRAP6:
1059	_debug_printf("\t\t.state = SVGA3D_RS_WRAP6\n");
1060	break;
1061	case SVGA3D_RS_WRAP7:
1062	_debug_printf("\t\t.state = SVGA3D_RS_WRAP7\n");
1063	break;
1064	case SVGA3D_RS_WRAP8:
1065	_debug_printf("\t\t.state = SVGA3D_RS_WRAP8\n");
1066	break;
1067	case SVGA3D_RS_WRAP9:
1068	_debug_printf("\t\t.state = SVGA3D_RS_WRAP9\n");
1069	break;
1070	case SVGA3D_RS_WRAP10:
1071	_debug_printf("\t\t.state = SVGA3D_RS_WRAP10\n");
1072	break;
1073	case SVGA3D_RS_WRAP11:
1074	_debug_printf("\t\t.state = SVGA3D_RS_WRAP11\n");
1075	break;
1076	case SVGA3D_RS_WRAP12:
1077	_debug_printf("\t\t.state = SVGA3D_RS_WRAP12\n");
1078	break;
1079	case SVGA3D_RS_WRAP13:
1080	_debug_printf("\t\t.state = SVGA3D_RS_WRAP13\n");
1081	break;
1082	case SVGA3D_RS_WRAP14:
1083	_debug_printf("\t\t.state = SVGA3D_RS_WRAP14\n");
1084	break;
1085	case SVGA3D_RS_WRAP15:
1086	_debug_printf("\t\t.state = SVGA3D_RS_WRAP15\n");
1087	break;
1088	case SVGA3D_RS_MULTISAMPLEANTIALIAS:
1089	_debug_printf("\t\t.state = SVGA3D_RS_MULTISAMPLEANTIALIAS\n");
1090	break;
1091	case SVGA3D_RS_MULTISAMPLEMASK:
1092	_debug_printf("\t\t.state = SVGA3D_RS_MULTISAMPLEMASK\n");
1093	break;
1094	case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE:
1095	_debug_printf("\t\t.state = SVGA3D_RS_INDEXEDVERTEXBLENDENABLE\n");
1096	break;
1097	case SVGA3D_RS_TWEENFACTOR:
1098	_debug_printf("\t\t.state = SVGA3D_RS_TWEENFACTOR\n");
1099	break;
1100	case SVGA3D_RS_ANTIALIASEDLINEENABLE:
1101	_debug_printf("\t\t.state = SVGA3D_RS_ANTIALIASEDLINEENABLE\n");
1102	break;
1103	case SVGA3D_RS_COLORWRITEENABLE1:
1104	_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE1\n");
1105	break;
1106	case SVGA3D_RS_COLORWRITEENABLE2:
1107	_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE2\n");
1108	break;
1109	case SVGA3D_RS_COLORWRITEENABLE3:
1110	_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE3\n");
1111	break;
1112	case SVGA3D_RS_SEPARATEALPHABLENDENABLE:
1113	_debug_printf("\t\t.state = SVGA3D_RS_SEPARATEALPHABLENDENABLE\n");
1114	break;
1115	case SVGA3D_RS_SRCBLENDALPHA:
1116	_debug_printf("\t\t.state = SVGA3D_RS_SRCBLENDALPHA\n");
1117	break;
1118	case SVGA3D_RS_DSTBLENDALPHA:
1119	_debug_printf("\t\t.state = SVGA3D_RS_DSTBLENDALPHA\n");
1120	break;
1121	case SVGA3D_RS_BLENDEQUATIONALPHA:
1122	_debug_printf("\t\t.state = SVGA3D_RS_BLENDEQUATIONALPHA\n");
1123	break;
1124	case SVGA3D_RS_MAX:
1125	_debug_printf("\t\t.state = SVGA3D_RS_MAX\n");
1126	break;
1127	default:
1128	_debug_printf("\t\t.state = %i\n", (*cmd).state);
1129	break;
1130	}
1131	_debug_printf("\t\t.uintValue = %u\n", (*cmd).uintValue);
1132	_debug_printf("\t\t.floatValue = %R[float]\n", (*cmd).floatValue);
1133	}
1134
1135	static void
1136	dump_SVGA3dVertexDivisor(const SVGA3dVertexDivisor *cmd)
1137	{
1138	_debug_printf("\t\t.value = %u\n", (*cmd).value);
1139	_debug_printf("\t\t.count = %u\n", (*cmd).count);
1140	_debug_printf("\t\t.indexedData = %u\n", (*cmd).indexedData);
1141	_debug_printf("\t\t.instanceData = %u\n", (*cmd).instanceData);
1142	}
1143
1144	static void
1145	dump_SVGA3dCmdDefineShader(const SVGA3dCmdDefineShader *cmd)
1146	{
1147	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1148	_debug_printf("\t\t.shid = %u\n", (*cmd).shid);
1149	switch((*cmd).type) {
1150	case SVGA3D_SHADERTYPE_VS:
1151	_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
1152	break;
1153	case SVGA3D_SHADERTYPE_PS:
1154	_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
1155	break;
1156	default:
1157	_debug_printf("\t\t.type = %i\n", (*cmd).type);
1158	break;
1159	}
1160	}
1161
1162	static void
1163	dump_constants(SVGA3dShaderConstType type, unsigned start,
1164	unsigned numConsts, const void *buf)
1165	{
1166	unsigned i;
1167	const float (*fvalues)[4];
1168	const int32 (*ivalues)[4];
1169
1170	switch (type) {
1171	case SVGA3D_CONST_TYPE_FLOAT:
1172	_debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_FLOAT\n");
1173	fvalues = (const float (*)[4]) buf;
1174	for (i = 0; i < numConsts; ++i) {
1175	_debug_printf("\t\t.values[%u] = {%R[float], %R[float], %R[float], %R[float]}\n",
1176	start + i,
1177	fvalues[i][0],
1178	fvalues[i][1],
1179	fvalues[i][2],
1180	fvalues[i][3]);
1181	}
1182	break;
1183	case SVGA3D_CONST_TYPE_INT:
1184	_debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_INT\n");
1185	ivalues = (const int32 (*)[4]) buf;
1186	for (i = 0; i < numConsts; ++i) {
1187	_debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
1188	start + i,
1189	ivalues[i][0],
1190	ivalues[i][1],
1191	ivalues[i][2],
1192	ivalues[i][3]);
1193	}
1194	break;
1195	case SVGA3D_CONST_TYPE_BOOL:
1196	_debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_BOOL\n");
1197	ivalues = (const int32 (*)[4]) buf;
1198	for (i = 0; i < numConsts; ++i) {
1199	_debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
1200	start + i,
1201	ivalues[i][0],
1202	ivalues[i][1],
1203	ivalues[i][2],
1204	ivalues[i][3]);
1205	}
1206	break;
1207	default:
1208	_debug_printf("\t\t.ctype = %i\n", type);
1209	ivalues = (const int32 (*)[4]) buf;
1210	for (i = 0; i < numConsts; ++i) {
1211	_debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
1212	start + i,
1213	ivalues[i][0],
1214	ivalues[i][1],
1215	ivalues[i][2],
1216	ivalues[i][3]);
1217	}
1218	break;
1219	}
1220	}
1221
1222	static void
1223	dump_SVGA3dCmdSetShaderConst(const SVGA3dCmdSetShaderConst *cmd, uint32 numConsts)
1224	{
1225	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1226	_debug_printf("\t\t.reg = %u\n", (*cmd).reg);
1227	_debug_printf("\t\t.type = %s\n", shader_name((*cmd).type));
1228	dump_constants((*cmd).ctype, cmd->reg, numConsts, cmd->values);
1229	}
1230
1231	static void
1232	dump_SVGA3dCmdSetGBShaderConstInline(const SVGA3dCmdSetGBShaderConstInline *cmd, uint32 numConsts)
1233	{
1234	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1235	_debug_printf("\t\t.reg = %u\n", (*cmd).regStart);
1236	_debug_printf("\t\t.type = %s\n", shader_name((*cmd).shaderType));
1237	dump_constants((*cmd).constType, cmd->regStart, numConsts, &cmd[1]);
1238	}
1239
1240
1241	static void
1242	dump_SVGA3dCmdSetZRange(const SVGA3dCmdSetZRange *cmd)
1243	{
1244	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1245	_debug_printf("\t\t.zRange.min = %R[float]\n", (*cmd).zRange.min);
1246	_debug_printf("\t\t.zRange.max = %R[float]\n", (*cmd).zRange.max);
1247	}
1248
1249	static void
1250	dump_SVGA3dCmdDrawPrimitives(const SVGA3dCmdDrawPrimitives *cmd)
1251	{
1252	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1253	_debug_printf("\t\t.numVertexDecls = %u\n", (*cmd).numVertexDecls);
1254	_debug_printf("\t\t.numRanges = %u\n", (*cmd).numRanges);
1255	}
1256
1257	static void
1258	dump_SVGA3dCmdSetLightEnabled(const SVGA3dCmdSetLightEnabled *cmd)
1259	{
1260	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1261	_debug_printf("\t\t.index = %u\n", (*cmd).index);
1262	_debug_printf("\t\t.enabled = %u\n", (*cmd).enabled);
1263	}
1264
1265	static void
1266	dump_SVGA3dPrimitiveRange(const SVGA3dPrimitiveRange *cmd)
1267	{
1268	switch((*cmd).primType) {
1269	case SVGA3D_PRIMITIVE_INVALID:
1270	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_INVALID\n");
1271	break;
1272	case SVGA3D_PRIMITIVE_TRIANGLELIST:
1273	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLELIST\n");
1274	break;
1275	case SVGA3D_PRIMITIVE_POINTLIST:
1276	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_POINTLIST\n");
1277	break;
1278	case SVGA3D_PRIMITIVE_LINELIST:
1279	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_LINELIST\n");
1280	break;
1281	case SVGA3D_PRIMITIVE_LINESTRIP:
1282	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_LINESTRIP\n");
1283	break;
1284	case SVGA3D_PRIMITIVE_TRIANGLESTRIP:
1285	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLESTRIP\n");
1286	break;
1287	case SVGA3D_PRIMITIVE_TRIANGLEFAN:
1288	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLEFAN\n");
1289	break;
1290	case SVGA3D_PRIMITIVE_MAX:
1291	_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_MAX\n");
1292	break;
1293	default:
1294	_debug_printf("\t\t.primType = %i\n", (*cmd).primType);
1295	break;
1296	}
1297	_debug_printf("\t\t.primitiveCount = %u\n", (*cmd).primitiveCount);
1298	_debug_printf("\t\t.indexArray.surfaceId = %u\n", (*cmd).indexArray.surfaceId);
1299	_debug_printf("\t\t.indexArray.offset = %u\n", (*cmd).indexArray.offset);
1300	_debug_printf("\t\t.indexArray.stride = %u\n", (*cmd).indexArray.stride);
1301	_debug_printf("\t\t.indexWidth = %u\n", (*cmd).indexWidth);
1302	_debug_printf("\t\t.indexBias = %i\n", (*cmd).indexBias);
1303	}
1304
1305	static void
1306	dump_SVGA3dCmdPresent(const SVGA3dCmdPresent *cmd)
1307	{
1308	_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
1309	}
1310
1311	static void
1312	dump_SVGA3dCmdSetRenderState(const SVGA3dCmdSetRenderState *cmd)
1313	{
1314	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1315	}
1316
1317	static void
1318	dump_SVGA3dCmdSurfaceStretchBlt(const SVGA3dCmdSurfaceStretchBlt *cmd)
1319	{
1320	_debug_printf("\t\t.src.sid = %u\n", (*cmd).src.sid);
1321	_debug_printf("\t\t.src.face = %u\n", (*cmd).src.face);
1322	_debug_printf("\t\t.src.mipmap = %u\n", (*cmd).src.mipmap);
1323	_debug_printf("\t\t.dest.sid = %u\n", (*cmd).dest.sid);
1324	_debug_printf("\t\t.dest.face = %u\n", (*cmd).dest.face);
1325	_debug_printf("\t\t.dest.mipmap = %u\n", (*cmd).dest.mipmap);
1326	_debug_printf("\t\t.boxSrc.x = %u\n", (*cmd).boxSrc.x);
1327	_debug_printf("\t\t.boxSrc.y = %u\n", (*cmd).boxSrc.y);
1328	_debug_printf("\t\t.boxSrc.z = %u\n", (*cmd).boxSrc.z);
1329	_debug_printf("\t\t.boxSrc.w = %u\n", (*cmd).boxSrc.w);
1330	_debug_printf("\t\t.boxSrc.h = %u\n", (*cmd).boxSrc.h);
1331	_debug_printf("\t\t.boxSrc.d = %u\n", (*cmd).boxSrc.d);
1332	_debug_printf("\t\t.boxDest.x = %u\n", (*cmd).boxDest.x);
1333	_debug_printf("\t\t.boxDest.y = %u\n", (*cmd).boxDest.y);
1334	_debug_printf("\t\t.boxDest.z = %u\n", (*cmd).boxDest.z);
1335	_debug_printf("\t\t.boxDest.w = %u\n", (*cmd).boxDest.w);
1336	_debug_printf("\t\t.boxDest.h = %u\n", (*cmd).boxDest.h);
1337	_debug_printf("\t\t.boxDest.d = %u\n", (*cmd).boxDest.d);
1338	switch((*cmd).mode) {
1339	case SVGA3D_STRETCH_BLT_POINT:
1340	_debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_POINT\n");
1341	break;
1342	case SVGA3D_STRETCH_BLT_LINEAR:
1343	_debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_LINEAR\n");
1344	break;
1345	case SVGA3D_STRETCH_BLT_MAX:
1346	_debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_MAX\n");
1347	break;
1348	default:
1349	_debug_printf("\t\t.mode = %i\n", (*cmd).mode);
1350	break;
1351	}
1352	}
1353
1354	static void
1355	dump_SVGA3dCmdSurfaceDMA(const SVGA3dCmdSurfaceDMA *cmd)
1356	{
1357	_debug_printf("\t\t.guest.ptr.gmrId = %u\n", (*cmd).guest.ptr.gmrId);
1358	_debug_printf("\t\t.guest.ptr.offset = %u\n", (*cmd).guest.ptr.offset);
1359	_debug_printf("\t\t.guest.pitch = %u\n", (*cmd).guest.pitch);
1360	_debug_printf("\t\t.host.sid = %u\n", (*cmd).host.sid);
1361	_debug_printf("\t\t.host.face = %u\n", (*cmd).host.face);
1362	_debug_printf("\t\t.host.mipmap = %u\n", (*cmd).host.mipmap);
1363	switch((*cmd).transfer) {
1364	case SVGA3D_WRITE_HOST_VRAM:
1365	_debug_printf("\t\t.transfer = SVGA3D_WRITE_HOST_VRAM\n");
1366	break;
1367	case SVGA3D_READ_HOST_VRAM:
1368	_debug_printf("\t\t.transfer = SVGA3D_READ_HOST_VRAM\n");
1369	break;
1370	default:
1371	_debug_printf("\t\t.transfer = %i\n", (*cmd).transfer);
1372	break;
1373	}
1374	}
1375
1376	static void
1377	dump_SVGA3dCmdSurfaceDMASuffix(const SVGA3dCmdSurfaceDMASuffix *cmd)
1378	{
1379	_debug_printf("\t\t.suffixSize = %u\n", (*cmd).suffixSize);
1380	_debug_printf("\t\t.maximumOffset = %u\n", (*cmd).maximumOffset);
1381	_debug_printf("\t\t.flags.discard = %u\n", (*cmd).flags.discard);
1382	_debug_printf("\t\t.flags.unsynchronized = %u\n", (*cmd).flags.unsynchronized);
1383	}
1384
1385	static void
1386	dump_SVGA3dCmdSetTransform(const SVGA3dCmdSetTransform *cmd)
1387	{
1388	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1389	switch((*cmd).type) {
1390	case SVGA3D_TRANSFORM_INVALID:
1391	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_INVALID\n");
1392	break;
1393	case SVGA3D_TRANSFORM_WORLD:
1394	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD\n");
1395	break;
1396	case SVGA3D_TRANSFORM_VIEW:
1397	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_VIEW\n");
1398	break;
1399	case SVGA3D_TRANSFORM_PROJECTION:
1400	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_PROJECTION\n");
1401	break;
1402	case SVGA3D_TRANSFORM_TEXTURE0:
1403	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE0\n");
1404	break;
1405	case SVGA3D_TRANSFORM_TEXTURE1:
1406	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE1\n");
1407	break;
1408	case SVGA3D_TRANSFORM_TEXTURE2:
1409	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE2\n");
1410	break;
1411	case SVGA3D_TRANSFORM_TEXTURE3:
1412	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE3\n");
1413	break;
1414	case SVGA3D_TRANSFORM_TEXTURE4:
1415	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE4\n");
1416	break;
1417	case SVGA3D_TRANSFORM_TEXTURE5:
1418	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE5\n");
1419	break;
1420	case SVGA3D_TRANSFORM_TEXTURE6:
1421	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE6\n");
1422	break;
1423	case SVGA3D_TRANSFORM_TEXTURE7:
1424	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE7\n");
1425	break;
1426	case SVGA3D_TRANSFORM_WORLD1:
1427	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD1\n");
1428	break;
1429	case SVGA3D_TRANSFORM_WORLD2:
1430	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD2\n");
1431	break;
1432	case SVGA3D_TRANSFORM_WORLD3:
1433	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD3\n");
1434	break;
1435	case SVGA3D_TRANSFORM_MAX:
1436	_debug_printf("\t\t.type = SVGA3D_TRANSFORM_MAX\n");
1437	break;
1438	default:
1439	_debug_printf("\t\t.type = %i\n", (*cmd).type);
1440	break;
1441	}
1442	_debug_printf("\t\t.matrix[0] = %R[float]\n", (*cmd).matrix[0]);
1443	_debug_printf("\t\t.matrix[1] = %R[float]\n", (*cmd).matrix[1]);
1444	_debug_printf("\t\t.matrix[2] = %R[float]\n", (*cmd).matrix[2]);
1445	_debug_printf("\t\t.matrix[3] = %R[float]\n", (*cmd).matrix[3]);
1446	_debug_printf("\t\t.matrix[4] = %R[float]\n", (*cmd).matrix[4]);
1447	_debug_printf("\t\t.matrix[5] = %R[float]\n", (*cmd).matrix[5]);
1448	_debug_printf("\t\t.matrix[6] = %R[float]\n", (*cmd).matrix[6]);
1449	_debug_printf("\t\t.matrix[7] = %R[float]\n", (*cmd).matrix[7]);
1450	_debug_printf("\t\t.matrix[8] = %R[float]\n", (*cmd).matrix[8]);
1451	_debug_printf("\t\t.matrix[9] = %R[float]\n", (*cmd).matrix[9]);
1452	_debug_printf("\t\t.matrix[10] = %R[float]\n", (*cmd).matrix[10]);
1453	_debug_printf("\t\t.matrix[11] = %R[float]\n", (*cmd).matrix[11]);
1454	_debug_printf("\t\t.matrix[12] = %R[float]\n", (*cmd).matrix[12]);
1455	_debug_printf("\t\t.matrix[13] = %R[float]\n", (*cmd).matrix[13]);
1456	_debug_printf("\t\t.matrix[14] = %R[float]\n", (*cmd).matrix[14]);
1457	_debug_printf("\t\t.matrix[15] = %R[float]\n", (*cmd).matrix[15]);
1458	}
1459
1460	static void
1461	dump_SVGA3dCmdDestroyShader(const SVGA3dCmdDestroyShader *cmd)
1462	{
1463	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1464	_debug_printf("\t\t.shid = %u\n", (*cmd).shid);
1465	switch((*cmd).type) {
1466	case SVGA3D_SHADERTYPE_VS:
1467	_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
1468	break;
1469	case SVGA3D_SHADERTYPE_PS:
1470	_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
1471	break;
1472	default:
1473	_debug_printf("\t\t.type = %i\n", (*cmd).type);
1474	break;
1475	}
1476	}
1477
1478	static void
1479	dump_SVGA3dCmdDestroyContext(const SVGA3dCmdDestroyContext *cmd)
1480	{
1481	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1482	}
1483
1484	static void
1485	dump_SVGA3dCmdClear(const SVGA3dCmdClear *cmd)
1486	{
1487	_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1488	switch((*cmd).clearFlag) {
1489	case SVGA3D_CLEAR_COLOR:
1490	_debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_COLOR\n");
1491	break;
1492	case SVGA3D_CLEAR_DEPTH:
1493	_debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_DEPTH\n");
1494	break;
1495	case SVGA3D_CLEAR_STENCIL:
1496	_debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_STENCIL\n");
1497	break;
1498	default:
1499	_debug_printf("\t\t.clearFlag = %i\n", (*cmd).clearFlag);
1500	break;
1501	}
1502	_debug_printf("\t\t.color = %u\n", (*cmd).color);
1503	_debug_printf("\t\t.depth = %R[float]\n", (*cmd).depth);
1504	_debug_printf("\t\t.stencil = %u\n", (*cmd).stencil);
1505	}
1506
1507	static void
1508	dump_SVGA3dCmdDefineSurface(const SVGA3dCmdDefineSurface *cmd)
1509	{
1510	_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
1511	switch((*cmd).surfaceFlags) {
1512	case SVGA3D_SURFACE_CUBEMAP:
1513	_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_CUBEMAP\n");
1514	break;
1515	case SVGA3D_SURFACE_HINT_STATIC:
1516	_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_STATIC\n");
1517	break;
1518	case SVGA3D_SURFACE_HINT_DYNAMIC:
1519	_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_DYNAMIC\n");
1520	break;
1521	case SVGA3D_SURFACE_HINT_INDEXBUFFER:
1522	_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_INDEXBUFFER\n");
1523	break;
1524	case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
1525	_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_VERTEXBUFFER\n");
1526	break;
1527	default:
1528	_debug_printf("\t\t.surfaceFlags = %i\n", (*cmd).surfaceFlags);
1529	break;
1530	}
1531	_debug_printf("\t\t.format = %s\n", svga_format_name((*cmd).format));
1532	_debug_printf("\t\t.face[0].numMipLevels = %u\n", (*cmd).face[0].numMipLevels);
1533	_debug_printf("\t\t.face[1].numMipLevels = %u\n", (*cmd).face[1].numMipLevels);
1534	_debug_printf("\t\t.face[2].numMipLevels = %u\n", (*cmd).face[2].numMipLevels);
1535	_debug_printf("\t\t.face[3].numMipLevels = %u\n", (*cmd).face[3].numMipLevels);
1536	_debug_printf("\t\t.face[4].numMipLevels = %u\n", (*cmd).face[4].numMipLevels);
1537	_debug_printf("\t\t.face[5].numMipLevels = %u\n", (*cmd).face[5].numMipLevels);
1538	}
1539
1540	static void
1541	dump_SVGASignedRect(const SVGASignedRect *cmd)
1542	{
1543	_debug_printf("\t\t.left = %i\n", (*cmd).left);
1544	_debug_printf("\t\t.top = %i\n", (*cmd).top);
1545	_debug_printf("\t\t.right = %i\n", (*cmd).right);
1546	_debug_printf("\t\t.bottom = %i\n", (*cmd).bottom);
1547	}
1548
1549	static void
1550	dump_SVGA3dBox(const SVGA3dBox *box)
1551	{
1552	_debug_printf("\t\t.box = %u, %u, %u %u x %u x %u\n",
1553	box->x, box->y, box->z,
1554	box->w, box->h, box->d);
1555	}
1556
1557	static void
1558	dump_SVGA3dCmdBlitSurfaceToScreen(const SVGA3dCmdBlitSurfaceToScreen *cmd)
1559	{
1560	_debug_printf("\t\t.srcImage.sid = %u\n", (*cmd).srcImage.sid);
1561	_debug_printf("\t\t.srcImage.face = %u\n", (*cmd).srcImage.face);
1562	_debug_printf("\t\t.srcImage.mipmap = %u\n", (*cmd).srcImage.mipmap);
1563	_debug_printf("\t\t.srcRect.left = %i\n", (*cmd).srcRect.left);
1564	_debug_printf("\t\t.srcRect.top = %i\n", (*cmd).srcRect.top);
1565	_debug_printf("\t\t.srcRect.right = %i\n", (*cmd).srcRect.right);
1566	_debug_printf("\t\t.srcRect.bottom = %i\n", (*cmd).srcRect.bottom);
1567	_debug_printf("\t\t.destScreenId = %u\n", (*cmd).destScreenId);
1568	_debug_printf("\t\t.destRect.left = %i\n", (*cmd).destRect.left);
1569	_debug_printf("\t\t.destRect.top = %i\n", (*cmd).destRect.top);
1570	_debug_printf("\t\t.destRect.right = %i\n", (*cmd).destRect.right);
1571	_debug_printf("\t\t.destRect.bottom = %i\n", (*cmd).destRect.bottom);
1572	}
1573
1574	static void
1575	dump_SVGA3dCmdDefineGBContext(const SVGA3dCmdDefineGBContext *cmd)
1576	{
1577	_debug_printf("\t\t.cid = %u\n", cmd->cid);
1578	}
1579
1580	static void
1581	dump_SVGA3dCmdBindGBContext(const SVGA3dCmdBindGBContext *cmd)
1582	{
1583	_debug_printf("\t\t.cid = %u\n", cmd->cid);
1584	_debug_printf("\t\t.mobid = %u\n", cmd->mobid);
1585	_debug_printf("\t\t.validContents = %u\n", cmd->validContents);
1586	}
1587
1588	static void
1589	dump_SVGA3dCmdDestroyGBContext(const SVGA3dCmdDestroyGBContext *cmd)
1590	{
1591	_debug_printf("\t\t.cid = %u\n", cmd->cid);
1592	}
1593
1594	static void
1595	dump_SVGA3dCmdDefineGBShader(const SVGA3dCmdDefineGBShader *cmd)
1596	{
1597	_debug_printf("\t\t.shid = %u\n", cmd->shid);
1598	_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
1599	_debug_printf("\t\t.sizeInBytes = %u\n", cmd->sizeInBytes);
1600	}
1601
1602	static void
1603	dump_SVGA3dCmdBindGBShader(const SVGA3dCmdBindGBShader *cmd)
1604	{
1605	_debug_printf("\t\t.shid = %u\n", cmd->shid);
1606	_debug_printf("\t\t.mobid = %u\n", cmd->mobid);
1607	_debug_printf("\t\t.offsetInBytes = %u\n", cmd->offsetInBytes);
1608	}
1609
1610	static void
1611	dump_SVGA3dCmdDestroyGBShader(const SVGA3dCmdDestroyGBShader *cmd)
1612	{
1613	_debug_printf("\t\t.shid = %u\n", cmd->shid);
1614	}
1615
1616	static void
1617	dump_SVGA3dCmdBindGBSurface(const SVGA3dCmdBindGBSurface *cmd)
1618	{
1619	_debug_printf("\t\t.sid = %u\n", cmd->sid);
1620	_debug_printf("\t\t.mobid = %u\n", cmd->mobid);
1621	}
1622
1623	static void
1624	dump_SVGA3dCmdUpdateGBSurface(const SVGA3dCmdUpdateGBSurface *cmd)
1625	{
1626	_debug_printf("\t\t.sid = %u\n", cmd->sid);
1627	}
1628
1629	static void
1630	dump_SVGA3dCmdUpdateGBImage(const SVGA3dCmdUpdateGBImage *cmd)
1631	{
1632	_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
1633	_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
1634	_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
1635	dump_SVGA3dBox(&cmd->box);
1636	}
1637
1638	static void
1639	dump_SVGA3dCmdReadbackGBImage(const SVGA3dCmdReadbackGBImage *cmd)
1640	{
1641	_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
1642	_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
1643	_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
1644	}
1645
1646	static void
1647	dump_SVGA3dCmdInvalidateGBImage(const SVGA3dCmdInvalidateGBImage *cmd)
1648	{
1649	_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
1650	_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
1651	_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
1652	}
1653
1654	static void
1655	dump_SVGA3dCmdInvalidateGBImagePartial(const SVGA3dCmdInvalidateGBImagePartial *cmd)
1656	{
1657	_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
1658	_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
1659	_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
1660	dump_SVGA3dBox(&cmd->box);
1661	_debug_printf("\t\t.invertBox = %u\n", cmd->invertBox);
1662	}
1663
1664	/// SVGA_3D_CMD_DX
1665
1666	#define __SVGA3D_DUMP_STRINGIFY(a) #a
1667	#define SVGA3D_DUMP_STRINGIFY(a) __SVGA3D_DUMP_STRINGIFY(a)
1668
1669	#define SVGA3D_DUMP_HEADER(CommandName) \
1670	static void \
1671	dump_SVGA3dCmdDX##CommandName(const SVGA3dCmdDX##CommandName *cmd)
1672
1673	#define SVGA3D_DUMP_PARAMETER(ParameterName, ParameterType) \
1674	_debug_printf(SVGA3D_DUMP_STRINGIFY(\t\t.ParameterName = %ParameterType\n), cmd->ParameterName)
1675
1676	#define SVGA3D_DUMP_TYPE_CASE(TypeVariableName, CaseName) \
1677	case CaseName: \
1678	_debug_printf(SVGA3D_DUMP_STRINGIFY(\t\t.TypeVariableName = CaseName) "\n"); \
1679	break;
1680
1681	#define SVGA3D_DUMP_TYPE_DEFAULT(TypeVariableName) \
1682	default: \
1683	_debug_printf(SVGA3D_DUMP_STRINGIFY(\t\t.TypeVariableName = %i\n), (*cmd).TypeVariableName); \
1684	break;
1685
1686	SVGA3D_DUMP_HEADER(SetShader)
1687	{
1688	SVGA3D_DUMP_PARAMETER(shaderId, u);
1689	_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
1690	}
1691
1692	SVGA3D_DUMP_HEADER(SetSamplers)
1693	{
1694	SVGA3D_DUMP_PARAMETER(startSampler, u);
1695	_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
1696	/* XXX: note we're not printing the sampler IDs at this time */
1697	}
1698
1699	SVGA3D_DUMP_HEADER(Draw)
1700	{
1701	SVGA3D_DUMP_PARAMETER(vertexCount, u);
1702	SVGA3D_DUMP_PARAMETER(startVertexLocation, u);
1703	}
1704
1705	SVGA3D_DUMP_HEADER(DrawIndexed)
1706	{
1707	SVGA3D_DUMP_PARAMETER(indexCount, u);
1708	SVGA3D_DUMP_PARAMETER(startIndexLocation, u);
1709	SVGA3D_DUMP_PARAMETER(baseVertexLocation, i);
1710	}
1711
1712	SVGA3D_DUMP_HEADER(DrawInstanced)
1713	{
1714	SVGA3D_DUMP_PARAMETER(vertexCountPerInstance, u);
1715	SVGA3D_DUMP_PARAMETER(instanceCount, u);
1716	SVGA3D_DUMP_PARAMETER(startVertexLocation, u);
1717	SVGA3D_DUMP_PARAMETER(startInstanceLocation, u);
1718	}
1719
1720	SVGA3D_DUMP_HEADER(DrawIndexedInstanced)
1721	{
1722	SVGA3D_DUMP_PARAMETER(indexCountPerInstance, u);
1723	SVGA3D_DUMP_PARAMETER(instanceCount, u);
1724	SVGA3D_DUMP_PARAMETER(startIndexLocation, u);
1725	SVGA3D_DUMP_PARAMETER(baseVertexLocation, i);
1726	SVGA3D_DUMP_PARAMETER(startInstanceLocation, u);
1727	}
1728
1729	SVGA3D_DUMP_HEADER(DrawAuto)
1730	{
1731	(void)cmd;
1732	}
1733
1734	SVGA3D_DUMP_HEADER(SetBlendState)
1735	{
1736	SVGA3D_DUMP_PARAMETER(blendId, u);
1737	_debug_printf("\t\t.blendFactor[4] = %R[float] %R[float] %R[float] %R[float]\n", cmd->blendFactor[0],
1738	cmd->blendFactor[1],
1739	cmd->blendFactor[2],
1740	cmd->blendFactor[3]);
1741	SVGA3D_DUMP_PARAMETER(sampleMask, u);
1742	}
1743
1744	SVGA3D_DUMP_HEADER(SetDepthStencilState)
1745	{
1746	SVGA3D_DUMP_PARAMETER(depthStencilId, u);
1747	SVGA3D_DUMP_PARAMETER(stencilRef, u);
1748	}
1749
1750	SVGA3D_DUMP_HEADER(SetRasterizerState)
1751	{
1752	SVGA3D_DUMP_PARAMETER(rasterizerId, u);
1753	}
1754
1755	SVGA3D_DUMP_HEADER(DefineQuery)
1756	{
1757	SVGA3D_DUMP_PARAMETER(queryId, u);
1758	switch (cmd->type)
1759	{
1760	SVGA3D_DUMP_TYPE_CASE(type, SVGA3D_QUERYTYPE_OCCLUSION);
1761	SVGA3D_DUMP_TYPE_CASE(type, SVGA3D_QUERYTYPE_MAX);
1762	SVGA3D_DUMP_TYPE_DEFAULT(type);
1763	}
1764	switch (cmd->flags)
1765	{
1766	SVGA3D_DUMP_TYPE_CASE(flags, SVGA3D_DXQUERY_FLAG_PREDICATEHINT);
1767	SVGA3D_DUMP_TYPE_DEFAULT(flags);
1768	}
1769	}
1770
1771	SVGA3D_DUMP_HEADER(DestroyQuery)
1772	{
1773	SVGA3D_DUMP_PARAMETER(queryId, u);
1774	}
1775
1776	SVGA3D_DUMP_HEADER(BindAllQuery)
1777	{
1778	SVGA3D_DUMP_PARAMETER(cid, u);
1779	SVGA3D_DUMP_PARAMETER(mobid, u);
1780	}
1781
1782	SVGA3D_DUMP_HEADER(BindQuery)
1783	{
1784	SVGA3D_DUMP_PARAMETER(queryId, u);
1785	SVGA3D_DUMP_PARAMETER(mobid, u);
1786	}
1787
1788	SVGA3D_DUMP_HEADER(MoveQuery)
1789	{
1790	SVGA3D_DUMP_PARAMETER(queryId, u);
1791	SVGA3D_DUMP_PARAMETER(mobid, u);
1792	SVGA3D_DUMP_PARAMETER(mobOffset, u);
1793	}
1794
1795	SVGA3D_DUMP_HEADER(ReadbackAllQuery)
1796	{
1797	SVGA3D_DUMP_PARAMETER(cid, u);
1798	}
1799
1800	SVGA3D_DUMP_HEADER(SetQueryOffset)
1801	{
1802	SVGA3D_DUMP_PARAMETER(queryId, u);
1803	SVGA3D_DUMP_PARAMETER(mobOffset, u);
1804	}
1805
1806	SVGA3D_DUMP_HEADER(BeginQuery)
1807	{
1808	SVGA3D_DUMP_PARAMETER(queryId, u);
1809	}
1810
1811	SVGA3D_DUMP_HEADER(EndQuery)
1812	{
1813	SVGA3D_DUMP_PARAMETER(queryId, u);
1814	}
1815
1816	SVGA3D_DUMP_HEADER(SetPredication)
1817	{
1818	SVGA3D_DUMP_PARAMETER(queryId, u);
1819	SVGA3D_DUMP_PARAMETER(predicateValue, u);
1820	}
1821
1822	SVGA3D_DUMP_HEADER(SetSOTargets)
1823	{
1824	(void)cmd;
1825	}
1826
1827
1828	SVGA3D_DUMP_HEADER(BindContext)
1829	{
1830	SVGA3D_DUMP_PARAMETER(mobid, u);
1831	SVGA3D_DUMP_PARAMETER(validContents, u);
1832	}
1833
1834	SVGA3D_DUMP_HEADER(SetViewports)
1835	{
1836	(void)cmd;
1837	/* XXX: note we're not printing the SVGA3dViewport list at this time */
1838	}
1839
1840	SVGA3D_DUMP_HEADER(SetScissorRects)
1841	{
1842	(void)cmd;
1843	/* XXX: note we're not printing the SVGASignedRect list at this time */
1844	}
1845
1846	SVGA3D_DUMP_HEADER(ClearRenderTargetView)
1847	{
1848	SVGA3D_DUMP_PARAMETER(renderTargetViewId, u);
1849	SVGA3D_DUMP_PARAMETER(rgba.r, R[float]);
1850	SVGA3D_DUMP_PARAMETER(rgba.g, R[float]);
1851	SVGA3D_DUMP_PARAMETER(rgba.b, R[float]);
1852	SVGA3D_DUMP_PARAMETER(rgba.a, R[float]);
1853	}
1854
1855	SVGA3D_DUMP_HEADER(ClearDepthStencilView)
1856	{
1857	SVGA3D_DUMP_PARAMETER(flags, u);
1858	SVGA3D_DUMP_PARAMETER(stencil, u);
1859	SVGA3D_DUMP_PARAMETER(depthStencilViewId, u);
1860	SVGA3D_DUMP_PARAMETER(depth, R[float]);
1861	}
1862
1863	SVGA3D_DUMP_HEADER(DefineShaderResourceView)
1864	{
1865	SVGA3D_DUMP_PARAMETER(shaderResourceViewId, u);
1866	SVGA3D_DUMP_PARAMETER(sid, u);
1867	_debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
1868	switch (cmd->resourceDimension)
1869	{
1870	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_BUFFER);
1871	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE1D);
1872	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE2D);
1873	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE3D);
1874	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURECUBE);
1875	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TYPE_MAX);
1876	SVGA3D_DUMP_TYPE_DEFAULT(resourceDimension);
1877	}
1878	if (cmd->resourceDimension == SVGA3D_RESOURCE_BUFFER) {
1879	SVGA3D_DUMP_PARAMETER(desc.buffer.firstElement, u);
1880	SVGA3D_DUMP_PARAMETER(desc.buffer.numElements, u);
1881	}
1882	else {
1883	SVGA3D_DUMP_PARAMETER(desc.tex.mostDetailedMip, u);
1884	SVGA3D_DUMP_PARAMETER(desc.tex.firstArraySlice, u);
1885	SVGA3D_DUMP_PARAMETER(desc.tex.mipLevels, u);
1886	SVGA3D_DUMP_PARAMETER(desc.tex.arraySize, u);
1887	}
1888	}
1889
1890	SVGA3D_DUMP_HEADER(SetShaderResources)
1891	{
1892	SVGA3D_DUMP_PARAMETER(startView, u);
1893	_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
1894	}
1895
1896
1897	SVGA3D_DUMP_HEADER(DestroyShaderResourceView)
1898	{
1899	SVGA3D_DUMP_PARAMETER(shaderResourceViewId, u);
1900	}
1901
1902	SVGA3D_DUMP_HEADER(DefineRenderTargetView)
1903	{
1904	SVGA3D_DUMP_PARAMETER(renderTargetViewId, u);
1905	SVGA3D_DUMP_PARAMETER(sid, u);
1906	_debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
1907	switch (cmd->resourceDimension)
1908	{
1909	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_BUFFER);
1910	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE1D);
1911	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE2D);
1912	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE3D);
1913	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURECUBE);
1914	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TYPE_MAX);
1915	SVGA3D_DUMP_TYPE_DEFAULT(resourceDimension);
1916	}
1917	SVGA3D_DUMP_PARAMETER(desc.buffer.firstElement, u);
1918	SVGA3D_DUMP_PARAMETER(desc.buffer.numElements, u);
1919	SVGA3D_DUMP_PARAMETER(desc.tex.mipSlice, u);
1920	SVGA3D_DUMP_PARAMETER(desc.tex.firstArraySlice, u);
1921	SVGA3D_DUMP_PARAMETER(desc.tex.arraySize, u);
1922	SVGA3D_DUMP_PARAMETER(desc.tex3D.mipSlice, u);
1923	SVGA3D_DUMP_PARAMETER(desc.tex3D.firstW, u);
1924	SVGA3D_DUMP_PARAMETER(desc.tex3D.wSize, u);
1925	}
1926
1927	SVGA3D_DUMP_HEADER(DestroyRenderTargetView)
1928	{
1929	SVGA3D_DUMP_PARAMETER(renderTargetViewId, u);
1930	}
1931
1932	SVGA3D_DUMP_HEADER(DefineDepthStencilView)
1933	{
1934	SVGA3D_DUMP_PARAMETER(depthStencilViewId, u);
1935	SVGA3D_DUMP_PARAMETER(sid, u);
1936	_debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
1937	switch (cmd->resourceDimension)
1938	{
1939	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_BUFFER);
1940	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE1D);
1941	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE2D);
1942	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE3D);
1943	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURECUBE);
1944	SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TYPE_MAX);
1945	SVGA3D_DUMP_TYPE_DEFAULT(resourceDimension);
1946	}
1947	SVGA3D_DUMP_PARAMETER(mipSlice, u);
1948	SVGA3D_DUMP_PARAMETER(firstArraySlice, u);
1949	SVGA3D_DUMP_PARAMETER(arraySize, u);
1950	}
1951
1952	SVGA3D_DUMP_HEADER(DestroyDepthStencilView)
1953	{
1954	SVGA3D_DUMP_PARAMETER(depthStencilViewId, u);
1955	}
1956
1957	SVGA3D_DUMP_HEADER(DefineElementLayout)
1958	{
1959	SVGA3D_DUMP_PARAMETER(elementLayoutId, u);
1960	}
1961
1962	SVGA3D_DUMP_HEADER(DestroyElementLayout)
1963	{
1964	SVGA3D_DUMP_PARAMETER(elementLayoutId, u);
1965	}
1966
1967	static void
1968	dump_SVGA3dCmdDXDefineBlendState(const SVGA3dCmdDXDefineBlendState *cmd)
1969	{
1970	unsigned i;
1971
1972	SVGA3D_DUMP_PARAMETER(blendId, u);
1973	SVGA3D_DUMP_PARAMETER(alphaToCoverageEnable, u);
1974	SVGA3D_DUMP_PARAMETER(independentBlendEnable, u);
1975	for (i = 0; i < SVGA3D_DX_MAX_RENDER_TARGETS; i++) {
1976	const SVGA3dDXBlendStatePerRT *rt = cmd->perRT + i;
1977	_debug_printf("\t\t.perRT[%u].blendEnable = %u\n", i, rt->blendEnable);
1978	if (rt->blendEnable) {
1979	_debug_printf("\t\t.perRT[%u].srcBlend = %u\n", i, rt->srcBlend);
1980	_debug_printf("\t\t.perRT[%u].destBlend = %u\n", i, rt->destBlend);
1981	_debug_printf("\t\t.perRT[%u].blendOp = %u\n", i, rt->blendOp);
1982	_debug_printf("\t\t.perRT[%u].srcBlendAlpha = %u\n", i, rt->srcBlendAlpha);
1983	_debug_printf("\t\t.perRT[%u].destBlendAlpha = %u\n", i, rt->destBlendAlpha);
1984	_debug_printf("\t\t.perRT[%u].blendOpAlpha = %u\n", i, rt->blendOpAlpha);
1985	}
1986	_debug_printf("\t\t.perRT[%u].renderTargetWriteMask = %u\n", i, rt->renderTargetWriteMask);
1987	_debug_printf("\t\t.perRT[%u].logicOpEnable = %u\n", i, rt->logicOpEnable);
1988	if (rt->logicOpEnable) {
1989	_debug_printf("\t\t.perRT[%u].logicOp = %u\n", i, rt->logicOp);
1990	}
1991	}
1992	}
1993
1994	SVGA3D_DUMP_HEADER(DestroyBlendState)
1995	{
1996	SVGA3D_DUMP_PARAMETER(blendId, u);
1997	}
1998
1999	SVGA3D_DUMP_HEADER(DefineDepthStencilState)
2000	{
2001	SVGA3D_DUMP_PARAMETER(depthStencilId, u);
2002	SVGA3D_DUMP_PARAMETER(depthEnable, u);
2003	SVGA3D_DUMP_PARAMETER(depthWriteMask, u);
2004	SVGA3D_DUMP_PARAMETER(depthFunc, u);
2005	SVGA3D_DUMP_PARAMETER(stencilEnable, u);
2006	SVGA3D_DUMP_PARAMETER(frontEnable, u);
2007	SVGA3D_DUMP_PARAMETER(backEnable, u);
2008	SVGA3D_DUMP_PARAMETER(stencilReadMask, u);
2009	SVGA3D_DUMP_PARAMETER(stencilWriteMask, u);
2010	SVGA3D_DUMP_PARAMETER(frontStencilFailOp, u);
2011	SVGA3D_DUMP_PARAMETER(frontStencilDepthFailOp, u);
2012	SVGA3D_DUMP_PARAMETER(frontStencilPassOp, u);
2013	SVGA3D_DUMP_PARAMETER(frontStencilFunc, u);
2014	SVGA3D_DUMP_PARAMETER(backStencilFailOp, u);
2015	SVGA3D_DUMP_PARAMETER(backStencilDepthFailOp, u);
2016	SVGA3D_DUMP_PARAMETER(backStencilPassOp, u);
2017	SVGA3D_DUMP_PARAMETER(backStencilFunc, u);
2018	}
2019
2020	SVGA3D_DUMP_HEADER(DestroyDepthStencilState)
2021	{
2022	SVGA3D_DUMP_PARAMETER(depthStencilId, u);
2023	}
2024
2025	SVGA3D_DUMP_HEADER(DefineRasterizerState)
2026	{
2027	SVGA3D_DUMP_PARAMETER(rasterizerId, u);
2028	SVGA3D_DUMP_PARAMETER(fillMode, u);
2029	SVGA3D_DUMP_PARAMETER(cullMode, u);
2030	SVGA3D_DUMP_PARAMETER(frontCounterClockwise, u);
2031	SVGA3D_DUMP_PARAMETER(depthBias, u);
2032	SVGA3D_DUMP_PARAMETER(depthBiasClamp, R[float]);
2033	SVGA3D_DUMP_PARAMETER(slopeScaledDepthBias, R[float]);
2034	SVGA3D_DUMP_PARAMETER(depthClipEnable, u);
2035	SVGA3D_DUMP_PARAMETER(scissorEnable, u);
2036	SVGA3D_DUMP_PARAMETER(multisampleEnable, u);
2037	SVGA3D_DUMP_PARAMETER(antialiasedLineEnable, u);
2038	SVGA3D_DUMP_PARAMETER(lineWidth, R[float]);
2039	SVGA3D_DUMP_PARAMETER(lineStippleEnable, u);
2040	SVGA3D_DUMP_PARAMETER(lineStippleFactor, u);
2041	SVGA3D_DUMP_PARAMETER(lineStipplePattern, u);
2042	SVGA3D_DUMP_PARAMETER(provokingVertexLast, u);
2043	}
2044
2045	SVGA3D_DUMP_HEADER(DestroyRasterizerState)
2046	{
2047	SVGA3D_DUMP_PARAMETER(rasterizerId, u);
2048	}
2049
2050	SVGA3D_DUMP_HEADER(DefineSamplerState)
2051	{
2052	SVGA3D_DUMP_PARAMETER(samplerId, u);
2053	SVGA3D_DUMP_PARAMETER(filter, u);
2054	SVGA3D_DUMP_PARAMETER(addressU, u);
2055	SVGA3D_DUMP_PARAMETER(addressV, u);
2056	SVGA3D_DUMP_PARAMETER(addressW, u);
2057	SVGA3D_DUMP_PARAMETER(mipLODBias, R[float]);
2058	SVGA3D_DUMP_PARAMETER(maxAnisotropy, u);
2059	SVGA3D_DUMP_PARAMETER(comparisonFunc, u);
2060	SVGA3D_DUMP_PARAMETER(borderColor.r, R[float]);
2061	SVGA3D_DUMP_PARAMETER(borderColor.g, R[float]);
2062	SVGA3D_DUMP_PARAMETER(borderColor.b, R[float]);
2063	SVGA3D_DUMP_PARAMETER(borderColor.a, R[float]);
2064	SVGA3D_DUMP_PARAMETER(minLOD, R[float]);
2065	SVGA3D_DUMP_PARAMETER(maxLOD, R[float]);
2066	}
2067
2068	SVGA3D_DUMP_HEADER(DestroySamplerState)
2069	{
2070	SVGA3D_DUMP_PARAMETER(samplerId, u);
2071	}
2072
2073	SVGA3D_DUMP_HEADER(DefineShader)
2074	{
2075	SVGA3D_DUMP_PARAMETER(shaderId, u);
2076	_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
2077	SVGA3D_DUMP_PARAMETER(sizeInBytes, u);
2078	}
2079
2080	SVGA3D_DUMP_HEADER(DestroyShader)
2081	{
2082	SVGA3D_DUMP_PARAMETER(shaderId, u);
2083	}
2084
2085	SVGA3D_DUMP_HEADER(BindShader)
2086	{
2087	SVGA3D_DUMP_PARAMETER(cid, u);
2088	SVGA3D_DUMP_PARAMETER(shid, u);
2089	SVGA3D_DUMP_PARAMETER(mobid, u);
2090	SVGA3D_DUMP_PARAMETER(offsetInBytes, u);
2091	}
2092
2093	SVGA3D_DUMP_HEADER(DefineStreamOutput)
2094	{
2095	int i;
2096	SVGA3D_DUMP_PARAMETER(soid, u);
2097	SVGA3D_DUMP_PARAMETER(numOutputStreamEntries, u);
2098	for (i = 0; i < SVGA3D_DX_MAX_SOTARGETS; i++) {
2099	_debug_printf("\t\t.streamOutputStrideInBytes[%d] = %u\n",
2100	i, cmd->streamOutputStrideInBytes[i]);
2101	}
2102	for (i = 0; i < 16; i++)
2103	{
2104	_debug_printf("\t\t.decl[%d].outputSlot = %u\n", i, cmd->decl[i].outputSlot);
2105	_debug_printf("\t\t.decl[%d].registerIndex = %u\n", i, cmd->decl[i].registerIndex);
2106	_debug_printf("\t\t.decl[%d].registerMask = %u\n", i, cmd->decl[i].registerMask);
2107	}
2108	}
2109
2110	SVGA3D_DUMP_HEADER(DestroyStreamOutput)
2111	{
2112	SVGA3D_DUMP_PARAMETER(soid, u);
2113	}
2114
2115	SVGA3D_DUMP_HEADER(SetStreamOutput)
2116	{
2117	SVGA3D_DUMP_PARAMETER(soid, u);
2118	}
2119
2120	SVGA3D_DUMP_HEADER(SetSingleConstantBuffer)
2121	{
2122	SVGA3D_DUMP_PARAMETER(slot, u);
2123	SVGA3D_DUMP_PARAMETER(sid, u);
2124	_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
2125	SVGA3D_DUMP_PARAMETER(offsetInBytes, u);
2126	SVGA3D_DUMP_PARAMETER(sizeInBytes, u);
2127	}
2128
2129	SVGA3D_DUMP_HEADER(SetInputLayout)
2130	{
2131	SVGA3D_DUMP_PARAMETER(elementLayoutId, u);
2132	}
2133
2134	SVGA3D_DUMP_HEADER(SetVertexBuffers)
2135	{
2136	SVGA3D_DUMP_PARAMETER(startBuffer, u);
2137
2138	/* XXX: note we're not printing the SVGA3dVertexBuffer list at this time */
2139	}
2140
2141	SVGA3D_DUMP_HEADER(SetTopology)
2142	{
2143	switch (cmd->topology)
2144	{
2145	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_INVALID);
2146	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_TRIANGLELIST);
2147	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_POINTLIST);
2148	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_LINELIST);
2149	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_LINESTRIP);
2150	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_TRIANGLESTRIP);
2151	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_TRIANGLEFAN);
2152	SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_MAX);
2153	SVGA3D_DUMP_TYPE_DEFAULT(topology);
2154	}
2155	}
2156
2157	SVGA3D_DUMP_HEADER(SetIndexBuffer)
2158	{
2159	SVGA3D_DUMP_PARAMETER(sid, u);
2160	_debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
2161	SVGA3D_DUMP_PARAMETER(offset, u);
2162	}
2163
2164	SVGA3D_DUMP_HEADER(PredCopyRegion)
2165	{
2166	SVGA3D_DUMP_PARAMETER(dstSid, u);
2167	SVGA3D_DUMP_PARAMETER(dstSubResource, u);
2168	SVGA3D_DUMP_PARAMETER(srcSid, u);
2169	SVGA3D_DUMP_PARAMETER(srcSubResource, u);
2170	dump_SVGA3dCopyBox(&cmd->box);
2171	}
2172
2173	SVGA3D_DUMP_HEADER(PredCopy)
2174	{
2175	SVGA3D_DUMP_PARAMETER(dstSid, u);
2176	SVGA3D_DUMP_PARAMETER(srcSid, u);
2177	}
2178
2179	static void
2180	dump_SVGA3dCmdDXUpdateSubResource(const SVGA3dCmdDXUpdateSubResource *cmd)
2181	{
2182	SVGA3D_DUMP_PARAMETER(sid, u);
2183	SVGA3D_DUMP_PARAMETER(subResource, u);
2184	dump_SVGA3dBox(&cmd->box);
2185	}
2186
2187	static void
2188	dump_SVGA3dCmdDXReadbackSubResource(const SVGA3dCmdDXReadbackSubResource *cmd)
2189	{
2190	SVGA3D_DUMP_PARAMETER(sid, u);
2191	SVGA3D_DUMP_PARAMETER(subResource, u);
2192	}
2193
2194	SVGA3D_DUMP_HEADER(BufferCopy)
2195	{
2196	SVGA3D_DUMP_PARAMETER(dest, u);
2197	SVGA3D_DUMP_PARAMETER(src, u);
2198	SVGA3D_DUMP_PARAMETER(destX, u);
2199	SVGA3D_DUMP_PARAMETER(srcX, u);
2200	SVGA3D_DUMP_PARAMETER(width, u);
2201
2202	}
2203
2204	SVGA3D_DUMP_HEADER(BufferUpdate)
2205	{
2206	SVGA3D_DUMP_PARAMETER(sid, u);
2207	SVGA3D_DUMP_PARAMETER(x, u);
2208	SVGA3D_DUMP_PARAMETER(width, u);
2209
2210	}
2211
2212	SVGA3D_DUMP_HEADER(GenMips)
2213	{
2214	SVGA3D_DUMP_PARAMETER(shaderResourceViewId, u);
2215	}
2216
2217	SVGA3D_DUMP_HEADER(TransferFromBuffer)
2218	{
2219	SVGA3D_DUMP_PARAMETER(srcSid, u);
2220	SVGA3D_DUMP_PARAMETER(srcOffset, u);
2221	SVGA3D_DUMP_PARAMETER(srcPitch, u);
2222	SVGA3D_DUMP_PARAMETER(srcSlicePitch, u);
2223	SVGA3D_DUMP_PARAMETER(destSid, u);
2224	SVGA3D_DUMP_PARAMETER(destSubResource, u);
2225	dump_SVGA3dBox(&cmd->destBox);
2226	}
2227
2228	static void
2229	dump_SVGA3dCmdIntraSurfaceCopy(const SVGA3dCmdIntraSurfaceCopy *cmd)
2230	{
2231	SVGA3D_DUMP_PARAMETER(surface.sid, u);
2232	SVGA3D_DUMP_PARAMETER(surface.face, u);
2233	SVGA3D_DUMP_PARAMETER(surface.mipmap, u);
2234	dump_SVGA3dCopyBox(&cmd->box);
2235	}
2236
2237	static void
2238	dump_SVGA3dCmdInvalidateGBSurface(const SVGA3dCmdInvalidateGBSurface *cmd)
2239	{
2240	SVGA3D_DUMP_PARAMETER(sid, u);
2241	}
2242
2243	#define SVGA3D_DUMP_CASE_BASIC(CommandName, CommandCode) \
2244	case SVGA_3D_CMD_DX_##CommandCode: \
2245	_debug_printf(SVGA3D_DUMP_STRINGIFY(\tSVGA_3D_CMD_DX_##CommandCode) "\n"); \
2246	{ \
2247	const SVGA3dCmdDX##CommandName cmd = (const SVGA3dCmdDX##CommandName )body; \
2248	dump_SVGA3dCmdDX##CommandName(cmd); \
2249	body = (const uint8_t *)&cmd[1]; \
2250	} \
2251	break
2252
2253	#define SVGA3D_DUMP_CASE_LIST(CommandName, CommandCode, ElementType) \
2254	case SVGA_3D_CMD_DX_##CommandCode: \
2255	_debug_printf(SVGA3D_DUMP_STRINGIFY(\tSVGA_3D_CMD_DX_##CommandCode) "\n"); \
2256	{ \
2257	const SVGA3dCmdDX##CommandName cmd = (const SVGA3dCmdDX##CommandName )body; \
2258	dump_SVGA3dCmdDX##CommandName(cmd); \
2259	body = (const uint8_t *)&cmd[1]; \
2260	while (body + sizeof(ElementType) <= next) \
2261	{ \
2262	dump_##ElementType((const ElementType *)body); \
2263	body += sizeof(ElementType); \
2264	} \
2265	} \
2266	break
2267
2268	void
2269	svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size)
2270	{
2271	const uint8_t body = (const uint8_t )data;
2272	const uint8_t *next = body + size;
2273
2274	switch(cmd_id) {
2275	SVGA3D_DUMP_CASE_BASIC(BindContext, BIND_CONTEXT);
2276	SVGA3D_DUMP_CASE_LIST(SetViewports, SET_VIEWPORTS, SVGA3dViewport);
2277	SVGA3D_DUMP_CASE_BASIC(SetShader, SET_SHADER);
2278	SVGA3D_DUMP_CASE_LIST(SetSamplers, SET_SAMPLERS, SVGA3dSamplerId);
2279	SVGA3D_DUMP_CASE_BASIC(SetBlendState, SET_BLEND_STATE);
2280	SVGA3D_DUMP_CASE_BASIC(SetDepthStencilState, SET_DEPTHSTENCIL_STATE);
2281	SVGA3D_DUMP_CASE_BASIC(SetRasterizerState, SET_RASTERIZER_STATE);
2282	SVGA3D_DUMP_CASE_BASIC(SetPredication, SET_PREDICATION);
2283	SVGA3D_DUMP_CASE_LIST(SetSOTargets, SET_SOTARGETS, SVGA3dSoTarget);
2284	SVGA3D_DUMP_CASE_LIST(SetScissorRects, SET_SCISSORRECTS, SVGASignedRect);
2285	SVGA3D_DUMP_CASE_BASIC(SetStreamOutput, SET_STREAMOUTPUT);
2286	SVGA3D_DUMP_CASE_BASIC(SetSingleConstantBuffer, SET_SINGLE_CONSTANT_BUFFER);
2287	SVGA3D_DUMP_CASE_BASIC(Draw, DRAW);
2288	SVGA3D_DUMP_CASE_BASIC(DrawIndexed, DRAW_INDEXED);
2289	SVGA3D_DUMP_CASE_BASIC(DrawInstanced, DRAW_INSTANCED);
2290	SVGA3D_DUMP_CASE_BASIC(DrawIndexedInstanced, DRAW_INDEXED_INSTANCED);
2291	SVGA3D_DUMP_CASE_BASIC(DrawAuto, DRAW_AUTO);
2292	SVGA3D_DUMP_CASE_BASIC(DefineQuery, DEFINE_QUERY);
2293	SVGA3D_DUMP_CASE_BASIC(DestroyQuery, DESTROY_QUERY);
2294	SVGA3D_DUMP_CASE_BASIC(BindAllQuery, BIND_ALL_QUERY);
2295	SVGA3D_DUMP_CASE_BASIC(BindQuery, BIND_QUERY);
2296	SVGA3D_DUMP_CASE_BASIC(MoveQuery, MOVE_QUERY);
2297	SVGA3D_DUMP_CASE_BASIC(ReadbackAllQuery, READBACK_ALL_QUERY);
2298	SVGA3D_DUMP_CASE_BASIC(SetQueryOffset, SET_QUERY_OFFSET);
2299	SVGA3D_DUMP_CASE_BASIC(BeginQuery, BEGIN_QUERY);
2300	SVGA3D_DUMP_CASE_BASIC(EndQuery, END_QUERY);
2301	SVGA3D_DUMP_CASE_BASIC(ClearRenderTargetView, CLEAR_RENDERTARGET_VIEW);
2302	SVGA3D_DUMP_CASE_BASIC(ClearDepthStencilView, CLEAR_DEPTHSTENCIL_VIEW);
2303	SVGA3D_DUMP_CASE_BASIC(DefineShaderResourceView, DEFINE_SHADERRESOURCE_VIEW);
2304	SVGA3D_DUMP_CASE_LIST(SetShaderResources, SET_SHADER_RESOURCES, SVGA3dShaderResourceViewId);
2305	SVGA3D_DUMP_CASE_BASIC(DestroyShaderResourceView, DESTROY_SHADERRESOURCE_VIEW);
2306	SVGA3D_DUMP_CASE_BASIC(DefineRenderTargetView, DEFINE_RENDERTARGET_VIEW);
2307	SVGA3D_DUMP_CASE_BASIC(DestroyRenderTargetView, DESTROY_RENDERTARGET_VIEW);
2308	SVGA3D_DUMP_CASE_BASIC(DefineDepthStencilView, DEFINE_DEPTHSTENCIL_VIEW);
2309	SVGA3D_DUMP_CASE_BASIC(DestroyDepthStencilView, DESTROY_DEPTHSTENCIL_VIEW);
2310	SVGA3D_DUMP_CASE_LIST(DefineElementLayout, DEFINE_ELEMENTLAYOUT, SVGA3dInputElementDesc);
2311	SVGA3D_DUMP_CASE_BASIC(DestroyElementLayout, DESTROY_ELEMENTLAYOUT);
2312	SVGA3D_DUMP_CASE_BASIC(DefineBlendState, DEFINE_BLEND_STATE);
2313	SVGA3D_DUMP_CASE_BASIC(DestroyBlendState, DESTROY_BLEND_STATE);
2314	SVGA3D_DUMP_CASE_BASIC(DefineDepthStencilState, DEFINE_DEPTHSTENCIL_STATE);
2315	SVGA3D_DUMP_CASE_BASIC(DestroyDepthStencilState, DESTROY_DEPTHSTENCIL_STATE);
2316	SVGA3D_DUMP_CASE_BASIC(DefineRasterizerState, DEFINE_RASTERIZER_STATE);
2317	SVGA3D_DUMP_CASE_BASIC(DestroyRasterizerState, DESTROY_RASTERIZER_STATE);
2318	SVGA3D_DUMP_CASE_BASIC(DefineSamplerState, DEFINE_SAMPLER_STATE);
2319	SVGA3D_DUMP_CASE_BASIC(DestroySamplerState, DESTROY_SAMPLER_STATE);
2320	SVGA3D_DUMP_CASE_BASIC(DefineShader, DEFINE_SHADER);
2321	SVGA3D_DUMP_CASE_BASIC(DestroyShader, DESTROY_SHADER);
2322	SVGA3D_DUMP_CASE_BASIC(BindShader, BIND_SHADER);
2323	SVGA3D_DUMP_CASE_BASIC(DefineStreamOutput, DEFINE_STREAMOUTPUT);
2324	SVGA3D_DUMP_CASE_BASIC(DestroyStreamOutput, DESTROY_STREAMOUTPUT);
2325	SVGA3D_DUMP_CASE_BASIC(SetInputLayout, SET_INPUT_LAYOUT);
2326	SVGA3D_DUMP_CASE_LIST(SetVertexBuffers, SET_VERTEX_BUFFERS, SVGA3dVertexBuffer);
2327	SVGA3D_DUMP_CASE_BASIC(SetTopology, SET_TOPOLOGY);
2328	SVGA3D_DUMP_CASE_BASIC(SetIndexBuffer, SET_INDEX_BUFFER);
2329
2330	SVGA3D_DUMP_CASE_BASIC(PredCopy, PRED_COPY);
2331	SVGA3D_DUMP_CASE_BASIC(UpdateSubResource, UPDATE_SUBRESOURCE);
2332	SVGA3D_DUMP_CASE_BASIC(ReadbackSubResource, READBACK_SUBRESOURCE);
2333	SVGA3D_DUMP_CASE_BASIC(PredCopyRegion, PRED_COPY_REGION);
2334	SVGA3D_DUMP_CASE_BASIC(BufferCopy, BUFFER_COPY);
2335	SVGA3D_DUMP_CASE_BASIC(BufferUpdate, BUFFER_UPDATE);
2336	SVGA3D_DUMP_CASE_BASIC(GenMips, GENMIPS);
2337	SVGA3D_DUMP_CASE_BASIC(TransferFromBuffer, TRANSFER_FROM_BUFFER);
2338
2339	case SVGA_3D_CMD_DX_SET_RENDERTARGETS:
2340	_debug_printf("\tSVGA_3D_CMD_DX_SET_RENDERTARGETS\n");
2341	{
2342	const SVGA3dCmdDXSetRenderTargets *cmd =
2343	(const SVGA3dCmdDXSetRenderTargets *) body;
2344	_debug_printf("\t\t.depthStencilViewId = %u\n",
2345	cmd->depthStencilViewId);
2346	body = (const uint8_t *) &cmd[1];
2347	while (body + sizeof(SVGA3dRenderTargetViewId) <= next) {
2348	_debug_printf("\t\t.renderTargetViewId = %u\n",
2349	((SVGA3dRenderTargetViewId ) body));
2350	body += sizeof(SVGA3dRenderTargetViewId);
2351	}
2352	}
2353	break;
2354
2355	case SVGA_3D_CMD_SURFACE_DEFINE:
2356	_debug_printf("\tSVGA_3D_CMD_SURFACE_DEFINE\n");
2357	{
2358	const SVGA3dCmdDefineSurface cmd = (const SVGA3dCmdDefineSurface )body;
2359	dump_SVGA3dCmdDefineSurface(cmd);
2360	body = (const uint8_t *)&cmd[1];
2361	while(body + sizeof(SVGA3dSize) <= next) {
2362	dump_SVGA3dSize((const SVGA3dSize *)body);
2363	body += sizeof(SVGA3dSize);
2364	}
2365	}
2366	break;
2367	case SVGA_3D_CMD_SURFACE_DESTROY:
2368	_debug_printf("\tSVGA_3D_CMD_SURFACE_DESTROY\n");
2369	{
2370	const SVGA3dCmdDestroySurface cmd = (const SVGA3dCmdDestroySurface )body;
2371	dump_SVGA3dCmdDestroySurface(cmd);
2372	body = (const uint8_t *)&cmd[1];
2373	}
2374	break;
2375	case SVGA_3D_CMD_SURFACE_COPY:
2376	_debug_printf("\tSVGA_3D_CMD_SURFACE_COPY\n");
2377	{
2378	const SVGA3dCmdSurfaceCopy cmd = (const SVGA3dCmdSurfaceCopy )body;
2379	dump_SVGA3dCmdSurfaceCopy(cmd);
2380	body = (const uint8_t *)&cmd[1];
2381	while(body + sizeof(SVGA3dCopyBox) <= next) {
2382	dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
2383	body += sizeof(SVGA3dCopyBox);
2384	}
2385	}
2386	break;
2387	case SVGA_3D_CMD_SURFACE_STRETCHBLT:
2388	_debug_printf("\tSVGA_3D_CMD_SURFACE_STRETCHBLT\n");
2389	{
2390	const SVGA3dCmdSurfaceStretchBlt cmd = (const SVGA3dCmdSurfaceStretchBlt )body;
2391	dump_SVGA3dCmdSurfaceStretchBlt(cmd);
2392	body = (const uint8_t *)&cmd[1];
2393	}
2394	break;
2395	case SVGA_3D_CMD_SURFACE_DMA:
2396	_debug_printf("\tSVGA_3D_CMD_SURFACE_DMA\n");
2397	{
2398	const SVGA3dCmdSurfaceDMA cmd = (const SVGA3dCmdSurfaceDMA )body;
2399	dump_SVGA3dCmdSurfaceDMA(cmd);
2400	body = (const uint8_t *)&cmd[1];
2401	while(body + sizeof(SVGA3dCopyBox) <= next) {
2402	dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
2403	body += sizeof(SVGA3dCopyBox);
2404	}
2405	while(body + sizeof(SVGA3dCmdSurfaceDMASuffix) <= next) {
2406	dump_SVGA3dCmdSurfaceDMASuffix((const SVGA3dCmdSurfaceDMASuffix *)body);
2407	body += sizeof(SVGA3dCmdSurfaceDMASuffix);
2408	}
2409	}
2410	break;
2411	case SVGA_3D_CMD_CONTEXT_DEFINE:
2412	_debug_printf("\tSVGA_3D_CMD_CONTEXT_DEFINE\n");
2413	{
2414	const SVGA3dCmdDefineContext cmd = (const SVGA3dCmdDefineContext )body;
2415	dump_SVGA3dCmdDefineContext(cmd);
2416	body = (const uint8_t *)&cmd[1];
2417	}
2418	break;
2419	case SVGA_3D_CMD_CONTEXT_DESTROY:
2420	_debug_printf("\tSVGA_3D_CMD_CONTEXT_DESTROY\n");
2421	{
2422	const SVGA3dCmdDestroyContext cmd = (const SVGA3dCmdDestroyContext )body;
2423	dump_SVGA3dCmdDestroyContext(cmd);
2424	body = (const uint8_t *)&cmd[1];
2425	}
2426	break;
2427	case SVGA_3D_CMD_SETTRANSFORM:
2428	_debug_printf("\tSVGA_3D_CMD_SETTRANSFORM\n");
2429	{
2430	const SVGA3dCmdSetTransform cmd = (const SVGA3dCmdSetTransform )body;
2431	dump_SVGA3dCmdSetTransform(cmd);
2432	body = (const uint8_t *)&cmd[1];
2433	}
2434	break;
2435	case SVGA_3D_CMD_SETZRANGE:
2436	_debug_printf("\tSVGA_3D_CMD_SETZRANGE\n");
2437	{
2438	const SVGA3dCmdSetZRange cmd = (const SVGA3dCmdSetZRange )body;
2439	dump_SVGA3dCmdSetZRange(cmd);
2440	body = (const uint8_t *)&cmd[1];
2441	}
2442	break;
2443	case SVGA_3D_CMD_SETRENDERSTATE:
2444	_debug_printf("\tSVGA_3D_CMD_SETRENDERSTATE\n");
2445	{
2446	const SVGA3dCmdSetRenderState cmd = (const SVGA3dCmdSetRenderState )body;
2447	dump_SVGA3dCmdSetRenderState(cmd);
2448	body = (const uint8_t *)&cmd[1];
2449	while(body + sizeof(SVGA3dRenderState) <= next) {
2450	dump_SVGA3dRenderState((const SVGA3dRenderState *)body);
2451	body += sizeof(SVGA3dRenderState);
2452	}
2453	}
2454	break;
2455	case SVGA_3D_CMD_SETRENDERTARGET:
2456	_debug_printf("\tSVGA_3D_CMD_SETRENDERTARGET\n");
2457	{
2458	const SVGA3dCmdSetRenderTarget cmd = (const SVGA3dCmdSetRenderTarget )body;
2459	dump_SVGA3dCmdSetRenderTarget(cmd);
2460	body = (const uint8_t *)&cmd[1];
2461	}
2462	break;
2463	case SVGA_3D_CMD_SETTEXTURESTATE:
2464	_debug_printf("\tSVGA_3D_CMD_SETTEXTURESTATE\n");
2465	{
2466	const SVGA3dCmdSetTextureState cmd = (const SVGA3dCmdSetTextureState )body;
2467	dump_SVGA3dCmdSetTextureState(cmd);
2468	body = (const uint8_t *)&cmd[1];
2469	while(body + sizeof(SVGA3dTextureState) <= next) {
2470	dump_SVGA3dTextureState((const SVGA3dTextureState *)body);
2471	body += sizeof(SVGA3dTextureState);
2472	}
2473	}
2474	break;
2475	case SVGA_3D_CMD_SETMATERIAL:
2476	_debug_printf("\tSVGA_3D_CMD_SETMATERIAL\n");
2477	{
2478	const SVGA3dCmdSetMaterial cmd = (const SVGA3dCmdSetMaterial )body;
2479	dump_SVGA3dCmdSetMaterial(cmd);
2480	body = (const uint8_t *)&cmd[1];
2481	}
2482	break;
2483	case SVGA_3D_CMD_SETLIGHTDATA:
2484	_debug_printf("\tSVGA_3D_CMD_SETLIGHTDATA\n");
2485	{
2486	const SVGA3dCmdSetLightData cmd = (const SVGA3dCmdSetLightData )body;
2487	dump_SVGA3dCmdSetLightData(cmd);
2488	body = (const uint8_t *)&cmd[1];
2489	}
2490	break;
2491	case SVGA_3D_CMD_SETLIGHTENABLED:
2492	_debug_printf("\tSVGA_3D_CMD_SETLIGHTENABLED\n");
2493	{
2494	const SVGA3dCmdSetLightEnabled cmd = (const SVGA3dCmdSetLightEnabled )body;
2495	dump_SVGA3dCmdSetLightEnabled(cmd);
2496	body = (const uint8_t *)&cmd[1];
2497	}
2498	break;
2499	case SVGA_3D_CMD_SETVIEWPORT:
2500	_debug_printf("\tSVGA_3D_CMD_SETVIEWPORT\n");
2501	{
2502	const SVGA3dCmdSetViewport cmd = (const SVGA3dCmdSetViewport )body;
2503	dump_SVGA3dCmdSetViewport(cmd);
2504	body = (const uint8_t *)&cmd[1];
2505	}
2506	break;
2507	case SVGA_3D_CMD_SETCLIPPLANE:
2508	_debug_printf("\tSVGA_3D_CMD_SETCLIPPLANE\n");
2509	{
2510	const SVGA3dCmdSetClipPlane cmd = (const SVGA3dCmdSetClipPlane )body;
2511	dump_SVGA3dCmdSetClipPlane(cmd);
2512	body = (const uint8_t *)&cmd[1];
2513	}
2514	break;
2515	case SVGA_3D_CMD_CLEAR:
2516	_debug_printf("\tSVGA_3D_CMD_CLEAR\n");
2517	{
2518	const SVGA3dCmdClear cmd = (const SVGA3dCmdClear )body;
2519	dump_SVGA3dCmdClear(cmd);
2520	body = (const uint8_t *)&cmd[1];
2521	while(body + sizeof(SVGA3dRect) <= next) {
2522	dump_SVGA3dRect((const SVGA3dRect *)body);
2523	body += sizeof(SVGA3dRect);
2524	}
2525	}
2526	break;
2527	case SVGA_3D_CMD_PRESENT:
2528	_debug_printf("\tSVGA_3D_CMD_PRESENT\n");
2529	{
2530	const SVGA3dCmdPresent cmd = (const SVGA3dCmdPresent )body;
2531	dump_SVGA3dCmdPresent(cmd);
2532	body = (const uint8_t *)&cmd[1];
2533	while(body + sizeof(SVGA3dCopyRect) <= next) {
2534	dump_SVGA3dCopyRect((const SVGA3dCopyRect *)body);
2535	body += sizeof(SVGA3dCopyRect);
2536	}
2537	}
2538	break;
2539	case SVGA_3D_CMD_SHADER_DEFINE:
2540	_debug_printf("\tSVGA_3D_CMD_SHADER_DEFINE\n");
2541	{
2542	const SVGA3dCmdDefineShader cmd = (const SVGA3dCmdDefineShader )body;
2543	dump_SVGA3dCmdDefineShader(cmd);
2544	body = (const uint8_t *)&cmd[1];
2545	//svga_shader_dump((const uint32_t *)body,
2546	// (unsigned)(next - body)/sizeof(uint32_t),
2547	// FALSE );
2548	body = next;
2549	}
2550	break;
2551	case SVGA_3D_CMD_SHADER_DESTROY:
2552	_debug_printf("\tSVGA_3D_CMD_SHADER_DESTROY\n");
2553	{
2554	const SVGA3dCmdDestroyShader cmd = (const SVGA3dCmdDestroyShader )body;
2555	dump_SVGA3dCmdDestroyShader(cmd);
2556	body = (const uint8_t *)&cmd[1];
2557	}
2558	break;
2559	case SVGA_3D_CMD_SET_SHADER:
2560	_debug_printf("\tSVGA_3D_CMD_SET_SHADER\n");
2561	{
2562	const SVGA3dCmdSetShader cmd = (const SVGA3dCmdSetShader )body;
2563	dump_SVGA3dCmdSetShader(cmd);
2564	body = (const uint8_t *)&cmd[1];
2565	}
2566	break;
2567	case SVGA_3D_CMD_SET_SHADER_CONST:
2568	_debug_printf("\tSVGA_3D_CMD_SET_SHADER_CONST\n");
2569	{
2570	const SVGA3dCmdSetShaderConst cmd = (const SVGA3dCmdSetShaderConst )body;
2571	uint32 numConsts = 1 + (size - sizeof cmd) / (4 sizeof(uint32));
2572	dump_SVGA3dCmdSetShaderConst(cmd, numConsts);
2573	body = next;
2574	}
2575	break;
2576	case SVGA_3D_CMD_DRAW_PRIMITIVES:
2577	_debug_printf("\tSVGA_3D_CMD_DRAW_PRIMITIVES\n");
2578	{
2579	const SVGA3dCmdDrawPrimitives cmd = (const SVGA3dCmdDrawPrimitives )body;
2580	unsigned i, j;
2581	dump_SVGA3dCmdDrawPrimitives(cmd);
2582	body = (const uint8_t *)&cmd[1];
2583	for(i = 0; i < cmd->numVertexDecls; ++i) {
2584	dump_SVGA3dVertexDecl((const SVGA3dVertexDecl *)body);
2585	body += sizeof(SVGA3dVertexDecl);
2586	}
2587	for(j = 0; j < cmd->numRanges; ++j) {
2588	dump_SVGA3dPrimitiveRange((const SVGA3dPrimitiveRange *)body);
2589	body += sizeof(SVGA3dPrimitiveRange);
2590	}
2591	while(body + sizeof(SVGA3dVertexDivisor) <= next) {
2592	dump_SVGA3dVertexDivisor((const SVGA3dVertexDivisor *)body);
2593	body += sizeof(SVGA3dVertexDivisor);
2594	}
2595	}
2596	break;
2597	case SVGA_3D_CMD_SETSCISSORRECT:
2598	_debug_printf("\tSVGA_3D_CMD_SETSCISSORRECT\n");
2599	{
2600	const SVGA3dCmdSetScissorRect cmd = (const SVGA3dCmdSetScissorRect )body;
2601	dump_SVGA3dCmdSetScissorRect(cmd);
2602	body = (const uint8_t *)&cmd[1];
2603	}
2604	break;
2605	case SVGA_3D_CMD_BEGIN_QUERY:
2606	_debug_printf("\tSVGA_3D_CMD_BEGIN_QUERY\n");
2607	{
2608	const SVGA3dCmdBeginQuery cmd = (const SVGA3dCmdBeginQuery )body;
2609	dump_SVGA3dCmdBeginQuery(cmd);
2610	body = (const uint8_t *)&cmd[1];
2611	}
2612	break;
2613	case SVGA_3D_CMD_END_QUERY:
2614	_debug_printf("\tSVGA_3D_CMD_END_QUERY\n");
2615	{
2616	const SVGA3dCmdEndQuery cmd = (const SVGA3dCmdEndQuery )body;
2617	dump_SVGA3dCmdEndQuery(cmd);
2618	body = (const uint8_t *)&cmd[1];
2619	}
2620	break;
2621	case SVGA_3D_CMD_WAIT_FOR_QUERY:
2622	_debug_printf("\tSVGA_3D_CMD_WAIT_FOR_QUERY\n");
2623	{
2624	const SVGA3dCmdWaitForQuery cmd = (const SVGA3dCmdWaitForQuery )body;
2625	dump_SVGA3dCmdWaitForQuery(cmd);
2626	body = (const uint8_t *)&cmd[1];
2627	}
2628	break;
2629	case SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN:
2630	_debug_printf("\tSVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN\n");
2631	{
2632	const SVGA3dCmdBlitSurfaceToScreen cmd = (const SVGA3dCmdBlitSurfaceToScreen )body;
2633	dump_SVGA3dCmdBlitSurfaceToScreen(cmd);
2634	body = (const uint8_t *)&cmd[1];
2635	while(body + sizeof(SVGASignedRect) <= next) {
2636	dump_SVGASignedRect((const SVGASignedRect *)body);
2637	body += sizeof(SVGASignedRect);
2638	}
2639	}
2640	break;
2641	case SVGA_3D_CMD_DEFINE_GB_CONTEXT:
2642	_debug_printf("\tSVGA_3D_CMD_DEFINE_GB_CONTEXT\n");
2643	{
2644	const SVGA3dCmdDefineGBContext cmd = (const SVGA3dCmdDefineGBContext ) body;
2645	dump_SVGA3dCmdDefineGBContext(cmd);
2646	body = (const uint8_t *)&cmd[1];
2647	}
2648	break;
2649	case SVGA_3D_CMD_BIND_GB_CONTEXT:
2650	_debug_printf("\tSVGA_3D_CMD_BIND_GB_CONTEXT\n");
2651	{
2652	const SVGA3dCmdBindGBContext cmd = (const SVGA3dCmdBindGBContext ) body;
2653	dump_SVGA3dCmdBindGBContext(cmd);
2654	body = (const uint8_t *)&cmd[1];
2655	}
2656	break;
2657	case SVGA_3D_CMD_DESTROY_GB_CONTEXT:
2658	_debug_printf("\tSVGA_3D_CMD_DESTROY_GB_CONTEXT\n");
2659	{
2660	const SVGA3dCmdDestroyGBContext cmd = (const SVGA3dCmdDestroyGBContext ) body;
2661	dump_SVGA3dCmdDestroyGBContext(cmd);
2662	body = (const uint8_t *)&cmd[1];
2663	}
2664	break;
2665	case SVGA_3D_CMD_DEFINE_GB_SHADER:
2666	_debug_printf("\tSVGA_3D_CMD_DEFINE_GB_SHADER\n");
2667	{
2668	const SVGA3dCmdDefineGBShader cmd = (const SVGA3dCmdDefineGBShader ) body;
2669	dump_SVGA3dCmdDefineGBShader(cmd);
2670	body = (const uint8_t *)&cmd[1];
2671	}
2672	break;
2673	case SVGA_3D_CMD_BIND_GB_SHADER:
2674	_debug_printf("\tSVGA_3D_CMD_BIND_GB_SHADER\n");
2675	{
2676	const SVGA3dCmdBindGBShader cmd = (const SVGA3dCmdBindGBShader ) body;
2677	dump_SVGA3dCmdBindGBShader(cmd);
2678	body = (const uint8_t *)&cmd[1];
2679	}
2680	break;
2681	case SVGA_3D_CMD_DESTROY_GB_SHADER:
2682	_debug_printf("\tSVGA_3D_CMD_DESTROY_GB_SHADER\n");
2683	{
2684	const SVGA3dCmdDestroyGBShader cmd = (const SVGA3dCmdDestroyGBShader ) body;
2685	dump_SVGA3dCmdDestroyGBShader(cmd);
2686	body = (const uint8_t *)&cmd[1];
2687	}
2688	break;
2689	case SVGA_3D_CMD_BIND_GB_SURFACE:
2690	_debug_printf("\tSVGA_3D_CMD_BIND_GB_SURFACE\n");
2691	{
2692	const SVGA3dCmdBindGBSurface cmd = (const SVGA3dCmdBindGBSurface ) body;
2693	dump_SVGA3dCmdBindGBSurface(cmd);
2694	body = (const uint8_t *)&cmd[1];
2695	}
2696	break;
2697	case SVGA_3D_CMD_UPDATE_GB_SURFACE:
2698	_debug_printf("\tSVGA_3D_CMD_UPDATE_GB_SURFACE\n");
2699	{
2700	const SVGA3dCmdUpdateGBSurface cmd = (const SVGA3dCmdUpdateGBSurface ) body;
2701	dump_SVGA3dCmdUpdateGBSurface(cmd);
2702	body = (const uint8_t *)&cmd[1];
2703	}
2704	break;
2705	case SVGA_3D_CMD_READBACK_GB_IMAGE:
2706	_debug_printf("\tSVGA_3D_CMD_READBACK_GB_IMAGE:\n");
2707	{
2708	const SVGA3dCmdReadbackGBImage cmd = (SVGA3dCmdReadbackGBImage ) body;
2709	dump_SVGA3dCmdReadbackGBImage(cmd);
2710	body = (const uint8_t *)&cmd[1];
2711	}
2712	break;
2713	case SVGA_3D_CMD_UPDATE_GB_IMAGE:
2714	_debug_printf("\tSVGA_3D_CMD_UPDATE_GB_IMAGE\n");
2715	{
2716	const SVGA3dCmdUpdateGBImage cmd = (const SVGA3dCmdUpdateGBImage ) body;
2717	dump_SVGA3dCmdUpdateGBImage(cmd);
2718	body = (const uint8_t *)&cmd[1];
2719	}
2720	break;
2721	case SVGA_3D_CMD_INVALIDATE_GB_IMAGE:
2722	_debug_printf("\tSVGA_3D_CMD_INVALIDATE_GB_IMAGE\n");
2723	{
2724	const SVGA3dCmdInvalidateGBImage cmd = (const SVGA3dCmdInvalidateGBImage ) body;
2725	dump_SVGA3dCmdInvalidateGBImage(cmd);
2726	body = (const uint8_t *)&cmd[1];
2727	}
2728	break;
2729	case SVGA_3D_CMD_INVALIDATE_GB_IMAGE_PARTIAL:
2730	_debug_printf("\tSVGA_3D_CMD_INVALIDATE_GB_IMAGE_PARTIAL\n");
2731	{
2732	const SVGA3dCmdInvalidateGBImagePartial cmd = (const SVGA3dCmdInvalidateGBImagePartial ) body;
2733	dump_SVGA3dCmdInvalidateGBImagePartial(cmd);
2734	body = (const uint8_t *)&cmd[1];
2735	}
2736	break;
2737	case SVGA_3D_CMD_SET_GB_SHADERCONSTS_INLINE:
2738	_debug_printf("\tSVGA_3D_CMD_SET_GB_SHADERCONSTS_INLINE\n");
2739	{
2740	/* XXX Note: re-using the SVGA3dCmdSetShaderConst code here */
2741	const SVGA3dCmdSetGBShaderConstInline cmd = (const SVGA3dCmdSetGBShaderConstInline )body;
2742	uint32 numConsts = (size - sizeof cmd) / (4 sizeof(uint32));
2743	dump_SVGA3dCmdSetGBShaderConstInline(cmd, numConsts);
2744	body = next;
2745	}
2746	break;
2747	case SVGA_3D_CMD_INVALIDATE_GB_SURFACE:
2748	_debug_printf("\tSVGA_3D_CMD_INVALIDATE_GB_SURFACE\n");
2749	{
2750	const SVGA3dCmdInvalidateGBSurface cmd = (const SVGA3dCmdInvalidateGBSurface )body;
2751	dump_SVGA3dCmdInvalidateGBSurface(cmd);
2752	body = (const uint8_t *)&cmd[1];
2753	}
2754	break;
2755	case SVGA_3D_CMD_INTRA_SURFACE_COPY:
2756	_debug_printf("\tSVGA_3D_CMD_INTRA_SURFACE_COPY\n");
2757	{
2758	const SVGA3dCmdIntraSurfaceCopy cmd = (const SVGA3dCmdIntraSurfaceCopy )body;
2759	dump_SVGA3dCmdIntraSurfaceCopy(cmd);
2760	body = (const uint8_t *)&cmd[1];
2761	}
2762	break;
2763	default:
2764	_debug_printf("\t0x%08x\n", cmd_id);
2765	break;
2766	}
2767
2768	while(body + sizeof(uint32_t) <= next) {
2769	_debug_printf("\t\t0x%08x\n", (const uint32_t )body);
2770	body += sizeof(uint32_t);
2771	}
2772	while(body + sizeof(uint32_t) <= next)
2773	_debug_printf("\t\t0x%02x\n", *body++);
2774	}
2775
2776
2777	void
2778	svga_dump_commands(const void *commands, uint32_t size)
2779	{
2780	const uint8_t *next = commands;
2781	const uint8_t *last = next + size;
2782
2783	//assert(size % sizeof(uint32_t) == 0);
2784
2785	while(next < last) {
2786	const uint32_t cmd_id = (const uint32_t )next;
2787
2788	if(SVGA_3D_CMD_BASE <= cmd_id && cmd_id < SVGA_3D_CMD_MAX) {
2789	const SVGA3dCmdHeader header = (const SVGA3dCmdHeader )next;
2790	const uint8_t body = (const uint8_t )&header[1];
2791
2792	next = body + header->size;
2793	if(next > last)
2794	break;
2795
2796	svga_dump_command(cmd_id, body, header->size);
2797	}
2798	else if(cmd_id == SVGA_CMD_FENCE) {
2799	_debug_printf("\tSVGA_CMD_FENCE\n");
2800	_debug_printf("\t\t0x%08x\n", ((const uint32_t *)next)[1]);
2801	next += 2*sizeof(uint32_t);
2802	}
2803	else {
2804	_debug_printf("\t0x%08x\n", cmd_id);
2805	next += sizeof(uint32_t);
2806	}
2807	}
2808	}
2809	#endif /* LOG_ENABLED */

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/Graphics/svgadump/svga_dump.c@ 88838

以其他格式下載: