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
33#include "svga_types.h"
34#include "svga_shader_dump.h"
35#include "svga3d_reg.h"
36
37#include "util/u_debug.h"
38#include "svga_dump.h"
39
40static void
41dump_SVGA3dVertexDecl(const SVGA3dVertexDecl *cmd)
42{
43   switch((*cmd).identity.type) {
44   case SVGA3D_DECLTYPE_FLOAT1:
45      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT1\n");
46      break;
47   case SVGA3D_DECLTYPE_FLOAT2:
48      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT2\n");
49      break;
50   case SVGA3D_DECLTYPE_FLOAT3:
51      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT3\n");
52      break;
53   case SVGA3D_DECLTYPE_FLOAT4:
54      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT4\n");
55      break;
56   case SVGA3D_DECLTYPE_D3DCOLOR:
57      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_D3DCOLOR\n");
58      break;
59   case SVGA3D_DECLTYPE_UBYTE4:
60      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UBYTE4\n");
61      break;
62   case SVGA3D_DECLTYPE_SHORT2:
63      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT2\n");
64      break;
65   case SVGA3D_DECLTYPE_SHORT4:
66      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT4\n");
67      break;
68   case SVGA3D_DECLTYPE_UBYTE4N:
69      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UBYTE4N\n");
70      break;
71   case SVGA3D_DECLTYPE_SHORT2N:
72      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT2N\n");
73      break;
74   case SVGA3D_DECLTYPE_SHORT4N:
75      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT4N\n");
76      break;
77   case SVGA3D_DECLTYPE_USHORT2N:
78      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_USHORT2N\n");
79      break;
80   case SVGA3D_DECLTYPE_USHORT4N:
81      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_USHORT4N\n");
82      break;
83   case SVGA3D_DECLTYPE_UDEC3:
84      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UDEC3\n");
85      break;
86   case SVGA3D_DECLTYPE_DEC3N:
87      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_DEC3N\n");
88      break;
89   case SVGA3D_DECLTYPE_FLOAT16_2:
90      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT16_2\n");
91      break;
92   case SVGA3D_DECLTYPE_FLOAT16_4:
93      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT16_4\n");
94      break;
95   case SVGA3D_DECLTYPE_MAX:
96      _debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_MAX\n");
97      break;
98   default:
99      _debug_printf("\t\t.identity.type = %i\n", (*cmd).identity.type);
100      break;
101   }
102   switch((*cmd).identity.method) {
103   case SVGA3D_DECLMETHOD_DEFAULT:
104      _debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_DEFAULT\n");
105      break;
106   case SVGA3D_DECLMETHOD_PARTIALU:
107      _debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_PARTIALU\n");
108      break;
109   case SVGA3D_DECLMETHOD_PARTIALV:
110      _debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_PARTIALV\n");
111      break;
112   case SVGA3D_DECLMETHOD_CROSSUV:
113      _debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_CROSSUV\n");
114      break;
115   case SVGA3D_DECLMETHOD_UV:
116      _debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_UV\n");
117      break;
118   case SVGA3D_DECLMETHOD_LOOKUP:
119      _debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_LOOKUP\n");
120      break;
121   case SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED:
122      _debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED\n");
123      break;
124   default:
125      _debug_printf("\t\t.identity.method = %i\n", (*cmd).identity.method);
126      break;
127   }
128   switch((*cmd).identity.usage) {
129   case SVGA3D_DECLUSAGE_POSITION:
130      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_POSITION\n");
131      break;
132   case SVGA3D_DECLUSAGE_BLENDWEIGHT:
133      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BLENDWEIGHT\n");
134      break;
135   case SVGA3D_DECLUSAGE_BLENDINDICES:
136      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BLENDINDICES\n");
137      break;
138   case SVGA3D_DECLUSAGE_NORMAL:
139      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_NORMAL\n");
140      break;
141   case SVGA3D_DECLUSAGE_PSIZE:
142      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_PSIZE\n");
143      break;
144   case SVGA3D_DECLUSAGE_TEXCOORD:
145      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TEXCOORD\n");
146      break;
147   case SVGA3D_DECLUSAGE_TANGENT:
148      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TANGENT\n");
149      break;
150   case SVGA3D_DECLUSAGE_BINORMAL:
151      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BINORMAL\n");
152      break;
153   case SVGA3D_DECLUSAGE_TESSFACTOR:
154      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TESSFACTOR\n");
155      break;
156   case SVGA3D_DECLUSAGE_POSITIONT:
157      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_POSITIONT\n");
158      break;
159   case SVGA3D_DECLUSAGE_COLOR:
160      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_COLOR\n");
161      break;
162   case SVGA3D_DECLUSAGE_FOG:
163      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_FOG\n");
164      break;
165   case SVGA3D_DECLUSAGE_DEPTH:
166      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_DEPTH\n");
167      break;
168   case SVGA3D_DECLUSAGE_SAMPLE:
169      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_SAMPLE\n");
170      break;
171   case SVGA3D_DECLUSAGE_MAX:
172      _debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_MAX\n");
173      break;
174   default:
175      _debug_printf("\t\t.identity.usage = %i\n", (*cmd).identity.usage);
176      break;
177   }
178   _debug_printf("\t\t.identity.usageIndex = %u\n", (*cmd).identity.usageIndex);
179   _debug_printf("\t\t.array.surfaceId = %u\n", (*cmd).array.surfaceId);
180   _debug_printf("\t\t.array.offset = %u\n", (*cmd).array.offset);
181   _debug_printf("\t\t.array.stride = %u\n", (*cmd).array.stride);
182   _debug_printf("\t\t.rangeHint.first = %u\n", (*cmd).rangeHint.first);
183   _debug_printf("\t\t.rangeHint.last = %u\n", (*cmd).rangeHint.last);
184}
185
186static void
187dump_SVGA3dTextureState(const SVGA3dTextureState *cmd)
188{
189   _debug_printf("\t\t.stage = %u\n", (*cmd).stage);
190   switch((*cmd).name) {
191   case SVGA3D_TS_INVALID:
192      _debug_printf("\t\t.name = SVGA3D_TS_INVALID\n");
193      break;
194   case SVGA3D_TS_BIND_TEXTURE:
195      _debug_printf("\t\t.name = SVGA3D_TS_BIND_TEXTURE\n");
196      break;
197   case SVGA3D_TS_COLOROP:
198      _debug_printf("\t\t.name = SVGA3D_TS_COLOROP\n");
199      break;
200   case SVGA3D_TS_COLORARG1:
201      _debug_printf("\t\t.name = SVGA3D_TS_COLORARG1\n");
202      break;
203   case SVGA3D_TS_COLORARG2:
204      _debug_printf("\t\t.name = SVGA3D_TS_COLORARG2\n");
205      break;
206   case SVGA3D_TS_ALPHAOP:
207      _debug_printf("\t\t.name = SVGA3D_TS_ALPHAOP\n");
208      break;
209   case SVGA3D_TS_ALPHAARG1:
210      _debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG1\n");
211      break;
212   case SVGA3D_TS_ALPHAARG2:
213      _debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG2\n");
214      break;
215   case SVGA3D_TS_ADDRESSU:
216      _debug_printf("\t\t.name = SVGA3D_TS_ADDRESSU\n");
217      break;
218   case SVGA3D_TS_ADDRESSV:
219      _debug_printf("\t\t.name = SVGA3D_TS_ADDRESSV\n");
220      break;
221   case SVGA3D_TS_MIPFILTER:
222      _debug_printf("\t\t.name = SVGA3D_TS_MIPFILTER\n");
223      break;
224   case SVGA3D_TS_MAGFILTER:
225      _debug_printf("\t\t.name = SVGA3D_TS_MAGFILTER\n");
226      break;
227   case SVGA3D_TS_MINFILTER:
228      _debug_printf("\t\t.name = SVGA3D_TS_MINFILTER\n");
229      break;
230   case SVGA3D_TS_BORDERCOLOR:
231      _debug_printf("\t\t.name = SVGA3D_TS_BORDERCOLOR\n");
232      break;
233   case SVGA3D_TS_TEXCOORDINDEX:
234      _debug_printf("\t\t.name = SVGA3D_TS_TEXCOORDINDEX\n");
235      break;
236   case SVGA3D_TS_TEXTURETRANSFORMFLAGS:
237      _debug_printf("\t\t.name = SVGA3D_TS_TEXTURETRANSFORMFLAGS\n");
238      break;
239   case SVGA3D_TS_TEXCOORDGEN:
240      _debug_printf("\t\t.name = SVGA3D_TS_TEXCOORDGEN\n");
241      break;
242   case SVGA3D_TS_BUMPENVMAT00:
243      _debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT00\n");
244      break;
245   case SVGA3D_TS_BUMPENVMAT01:
246      _debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT01\n");
247      break;
248   case SVGA3D_TS_BUMPENVMAT10:
249      _debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT10\n");
250      break;
251   case SVGA3D_TS_BUMPENVMAT11:
252      _debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT11\n");
253      break;
254   case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL:
255      _debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_MIPMAP_LEVEL\n");
256      break;
257   case SVGA3D_TS_TEXTURE_LOD_BIAS:
258      _debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_LOD_BIAS\n");
259      break;
260   case SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL:
261      _debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL\n");
262      break;
263   case SVGA3D_TS_ADDRESSW:
264      _debug_printf("\t\t.name = SVGA3D_TS_ADDRESSW\n");
265      break;
266   case SVGA3D_TS_GAMMA:
267      _debug_printf("\t\t.name = SVGA3D_TS_GAMMA\n");
268      break;
269   case SVGA3D_TS_BUMPENVLSCALE:
270      _debug_printf("\t\t.name = SVGA3D_TS_BUMPENVLSCALE\n");
271      break;
272   case SVGA3D_TS_BUMPENVLOFFSET:
273      _debug_printf("\t\t.name = SVGA3D_TS_BUMPENVLOFFSET\n");
274      break;
275   case SVGA3D_TS_COLORARG0:
276      _debug_printf("\t\t.name = SVGA3D_TS_COLORARG0\n");
277      break;
278   case SVGA3D_TS_ALPHAARG0:
279      _debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG0\n");
280      break;
281   case SVGA3D_TS_MAX:
282      _debug_printf("\t\t.name = SVGA3D_TS_MAX\n");
283      break;
284   default:
285      _debug_printf("\t\t.name = %i\n", (*cmd).name);
286      break;
287   }
288   _debug_printf("\t\t.value = %u\n", (*cmd).value);
289   _debug_printf("\t\t.floatValue = %f\n", (*cmd).floatValue);
290}
291
292static void
293dump_SVGA3dCopyBox(const SVGA3dCopyBox *cmd)
294{
295   _debug_printf("\t\t.x = %u\n", (*cmd).x);
296   _debug_printf("\t\t.y = %u\n", (*cmd).y);
297   _debug_printf("\t\t.z = %u\n", (*cmd).z);
298   _debug_printf("\t\t.w = %u\n", (*cmd).w);
299   _debug_printf("\t\t.h = %u\n", (*cmd).h);
300   _debug_printf("\t\t.d = %u\n", (*cmd).d);
301   _debug_printf("\t\t.srcx = %u\n", (*cmd).srcx);
302   _debug_printf("\t\t.srcy = %u\n", (*cmd).srcy);
303   _debug_printf("\t\t.srcz = %u\n", (*cmd).srcz);
304}
305
306static void
307dump_SVGA3dCmdSetClipPlane(const SVGA3dCmdSetClipPlane *cmd)
308{
309   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
310   _debug_printf("\t\t.index = %u\n", (*cmd).index);
311   _debug_printf("\t\t.plane[0] = %f\n", (*cmd).plane[0]);
312   _debug_printf("\t\t.plane[1] = %f\n", (*cmd).plane[1]);
313   _debug_printf("\t\t.plane[2] = %f\n", (*cmd).plane[2]);
314   _debug_printf("\t\t.plane[3] = %f\n", (*cmd).plane[3]);
315}
316
317static void
318dump_SVGA3dCmdWaitForQuery(const SVGA3dCmdWaitForQuery *cmd)
319{
320   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
321   switch((*cmd).type) {
322   case SVGA3D_QUERYTYPE_OCCLUSION:
323      _debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
324      break;
325   case SVGA3D_QUERYTYPE_MAX:
326      _debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
327      break;
328   default:
329      _debug_printf("\t\t.type = %i\n", (*cmd).type);
330      break;
331   }
332   _debug_printf("\t\t.guestResult.gmrId = %u\n", (*cmd).guestResult.gmrId);
333   _debug_printf("\t\t.guestResult.offset = %u\n", (*cmd).guestResult.offset);
334}
335
336static void
337dump_SVGA3dCmdSetRenderTarget(const SVGA3dCmdSetRenderTarget *cmd)
338{
339   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
340   switch((*cmd).type) {
341   case SVGA3D_RT_DEPTH:
342      _debug_printf("\t\t.type = SVGA3D_RT_DEPTH\n");
343      break;
344   case SVGA3D_RT_STENCIL:
345      _debug_printf("\t\t.type = SVGA3D_RT_STENCIL\n");
346      break;
347   default:
348      _debug_printf("\t\t.type = SVGA3D_RT_COLOR%u\n", (*cmd).type - SVGA3D_RT_COLOR0);
349      break;
350   }
351   _debug_printf("\t\t.target.sid = %u\n", (*cmd).target.sid);
352   _debug_printf("\t\t.target.face = %u\n", (*cmd).target.face);
353   _debug_printf("\t\t.target.mipmap = %u\n", (*cmd).target.mipmap);
354}
355
356static void
357dump_SVGA3dCmdSetTextureState(const SVGA3dCmdSetTextureState *cmd)
358{
359   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
360}
361
362static void
363dump_SVGA3dCmdSurfaceCopy(const SVGA3dCmdSurfaceCopy *cmd)
364{
365   _debug_printf("\t\t.src.sid = %u\n", (*cmd).src.sid);
366   _debug_printf("\t\t.src.face = %u\n", (*cmd).src.face);
367   _debug_printf("\t\t.src.mipmap = %u\n", (*cmd).src.mipmap);
368   _debug_printf("\t\t.dest.sid = %u\n", (*cmd).dest.sid);
369   _debug_printf("\t\t.dest.face = %u\n", (*cmd).dest.face);
370   _debug_printf("\t\t.dest.mipmap = %u\n", (*cmd).dest.mipmap);
371}
372
373static void
374dump_SVGA3dCmdSetMaterial(const SVGA3dCmdSetMaterial *cmd)
375{
376   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
377   switch((*cmd).face) {
378   case SVGA3D_FACE_INVALID:
379      _debug_printf("\t\t.face = SVGA3D_FACE_INVALID\n");
380      break;
381   case SVGA3D_FACE_NONE:
382      _debug_printf("\t\t.face = SVGA3D_FACE_NONE\n");
383      break;
384   case SVGA3D_FACE_FRONT:
385      _debug_printf("\t\t.face = SVGA3D_FACE_FRONT\n");
386      break;
387   case SVGA3D_FACE_BACK:
388      _debug_printf("\t\t.face = SVGA3D_FACE_BACK\n");
389      break;
390   case SVGA3D_FACE_FRONT_BACK:
391      _debug_printf("\t\t.face = SVGA3D_FACE_FRONT_BACK\n");
392      break;
393   case SVGA3D_FACE_MAX:
394      _debug_printf("\t\t.face = SVGA3D_FACE_MAX\n");
395      break;
396   default:
397      _debug_printf("\t\t.face = %i\n", (*cmd).face);
398      break;
399   }
400   _debug_printf("\t\t.material.diffuse[0] = %f\n", (*cmd).material.diffuse[0]);
401   _debug_printf("\t\t.material.diffuse[1] = %f\n", (*cmd).material.diffuse[1]);
402   _debug_printf("\t\t.material.diffuse[2] = %f\n", (*cmd).material.diffuse[2]);
403   _debug_printf("\t\t.material.diffuse[3] = %f\n", (*cmd).material.diffuse[3]);
404   _debug_printf("\t\t.material.ambient[0] = %f\n", (*cmd).material.ambient[0]);
405   _debug_printf("\t\t.material.ambient[1] = %f\n", (*cmd).material.ambient[1]);
406   _debug_printf("\t\t.material.ambient[2] = %f\n", (*cmd).material.ambient[2]);
407   _debug_printf("\t\t.material.ambient[3] = %f\n", (*cmd).material.ambient[3]);
408   _debug_printf("\t\t.material.specular[0] = %f\n", (*cmd).material.specular[0]);
409   _debug_printf("\t\t.material.specular[1] = %f\n", (*cmd).material.specular[1]);
410   _debug_printf("\t\t.material.specular[2] = %f\n", (*cmd).material.specular[2]);
411   _debug_printf("\t\t.material.specular[3] = %f\n", (*cmd).material.specular[3]);
412   _debug_printf("\t\t.material.emissive[0] = %f\n", (*cmd).material.emissive[0]);
413   _debug_printf("\t\t.material.emissive[1] = %f\n", (*cmd).material.emissive[1]);
414   _debug_printf("\t\t.material.emissive[2] = %f\n", (*cmd).material.emissive[2]);
415   _debug_printf("\t\t.material.emissive[3] = %f\n", (*cmd).material.emissive[3]);
416   _debug_printf("\t\t.material.shininess = %f\n", (*cmd).material.shininess);
417}
418
419static void
420dump_SVGA3dCmdSetLightData(const SVGA3dCmdSetLightData *cmd)
421{
422   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
423   _debug_printf("\t\t.index = %u\n", (*cmd).index);
424   switch((*cmd).data.type) {
425   case SVGA3D_LIGHTTYPE_INVALID:
426      _debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_INVALID\n");
427      break;
428   case SVGA3D_LIGHTTYPE_POINT:
429      _debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_POINT\n");
430      break;
431   case SVGA3D_LIGHTTYPE_SPOT1:
432      _debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_SPOT1\n");
433      break;
434   case SVGA3D_LIGHTTYPE_SPOT2:
435      _debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_SPOT2\n");
436      break;
437   case SVGA3D_LIGHTTYPE_DIRECTIONAL:
438      _debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_DIRECTIONAL\n");
439      break;
440   case SVGA3D_LIGHTTYPE_MAX:
441      _debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_MAX\n");
442      break;
443   default:
444      _debug_printf("\t\t.data.type = %i\n", (*cmd).data.type);
445      break;
446   }
447   _debug_printf("\t\t.data.inWorldSpace = %u\n", (*cmd).data.inWorldSpace);
448   _debug_printf("\t\t.data.diffuse[0] = %f\n", (*cmd).data.diffuse[0]);
449   _debug_printf("\t\t.data.diffuse[1] = %f\n", (*cmd).data.diffuse[1]);
450   _debug_printf("\t\t.data.diffuse[2] = %f\n", (*cmd).data.diffuse[2]);
451   _debug_printf("\t\t.data.diffuse[3] = %f\n", (*cmd).data.diffuse[3]);
452   _debug_printf("\t\t.data.specular[0] = %f\n", (*cmd).data.specular[0]);
453   _debug_printf("\t\t.data.specular[1] = %f\n", (*cmd).data.specular[1]);
454   _debug_printf("\t\t.data.specular[2] = %f\n", (*cmd).data.specular[2]);
455   _debug_printf("\t\t.data.specular[3] = %f\n", (*cmd).data.specular[3]);
456   _debug_printf("\t\t.data.ambient[0] = %f\n", (*cmd).data.ambient[0]);
457   _debug_printf("\t\t.data.ambient[1] = %f\n", (*cmd).data.ambient[1]);
458   _debug_printf("\t\t.data.ambient[2] = %f\n", (*cmd).data.ambient[2]);
459   _debug_printf("\t\t.data.ambient[3] = %f\n", (*cmd).data.ambient[3]);
460   _debug_printf("\t\t.data.position[0] = %f\n", (*cmd).data.position[0]);
461   _debug_printf("\t\t.data.position[1] = %f\n", (*cmd).data.position[1]);
462   _debug_printf("\t\t.data.position[2] = %f\n", (*cmd).data.position[2]);
463   _debug_printf("\t\t.data.position[3] = %f\n", (*cmd).data.position[3]);
464   _debug_printf("\t\t.data.direction[0] = %f\n", (*cmd).data.direction[0]);
465   _debug_printf("\t\t.data.direction[1] = %f\n", (*cmd).data.direction[1]);
466   _debug_printf("\t\t.data.direction[2] = %f\n", (*cmd).data.direction[2]);
467   _debug_printf("\t\t.data.direction[3] = %f\n", (*cmd).data.direction[3]);
468   _debug_printf("\t\t.data.range = %f\n", (*cmd).data.range);
469   _debug_printf("\t\t.data.falloff = %f\n", (*cmd).data.falloff);
470   _debug_printf("\t\t.data.attenuation0 = %f\n", (*cmd).data.attenuation0);
471   _debug_printf("\t\t.data.attenuation1 = %f\n", (*cmd).data.attenuation1);
472   _debug_printf("\t\t.data.attenuation2 = %f\n", (*cmd).data.attenuation2);
473   _debug_printf("\t\t.data.theta = %f\n", (*cmd).data.theta);
474   _debug_printf("\t\t.data.phi = %f\n", (*cmd).data.phi);
475}
476
477static void
478dump_SVGA3dCmdSetViewport(const SVGA3dCmdSetViewport *cmd)
479{
480   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
481   _debug_printf("\t\t.rect.x = %u\n", (*cmd).rect.x);
482   _debug_printf("\t\t.rect.y = %u\n", (*cmd).rect.y);
483   _debug_printf("\t\t.rect.w = %u\n", (*cmd).rect.w);
484   _debug_printf("\t\t.rect.h = %u\n", (*cmd).rect.h);
485}
486
487static void
488dump_SVGA3dCmdSetScissorRect(const SVGA3dCmdSetScissorRect *cmd)
489{
490   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
491   _debug_printf("\t\t.rect.x = %u\n", (*cmd).rect.x);
492   _debug_printf("\t\t.rect.y = %u\n", (*cmd).rect.y);
493   _debug_printf("\t\t.rect.w = %u\n", (*cmd).rect.w);
494   _debug_printf("\t\t.rect.h = %u\n", (*cmd).rect.h);
495}
496
497static void
498dump_SVGA3dCopyRect(const SVGA3dCopyRect *cmd)
499{
500   _debug_printf("\t\t.x = %u\n", (*cmd).x);
501   _debug_printf("\t\t.y = %u\n", (*cmd).y);
502   _debug_printf("\t\t.w = %u\n", (*cmd).w);
503   _debug_printf("\t\t.h = %u\n", (*cmd).h);
504   _debug_printf("\t\t.srcx = %u\n", (*cmd).srcx);
505   _debug_printf("\t\t.srcy = %u\n", (*cmd).srcy);
506}
507
508static void
509dump_SVGA3dCmdSetShader(const SVGA3dCmdSetShader *cmd)
510{
511   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
512   switch((*cmd).type) {
513   case SVGA3D_SHADERTYPE_VS:
514      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
515      break;
516   case SVGA3D_SHADERTYPE_PS:
517      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
518      break;
519   case SVGA3D_SHADERTYPE_MAX:
520      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_MAX\n");
521      break;
522   default:
523      _debug_printf("\t\t.type = %i\n", (*cmd).type);
524      break;
525   }
526   _debug_printf("\t\t.shid = %u\n", (*cmd).shid);
527}
528
529static void
530dump_SVGA3dCmdEndQuery(const SVGA3dCmdEndQuery *cmd)
531{
532   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
533   switch((*cmd).type) {
534   case SVGA3D_QUERYTYPE_OCCLUSION:
535      _debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
536      break;
537   case SVGA3D_QUERYTYPE_MAX:
538      _debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
539      break;
540   default:
541      _debug_printf("\t\t.type = %i\n", (*cmd).type);
542      break;
543   }
544   _debug_printf("\t\t.guestResult.gmrId = %u\n", (*cmd).guestResult.gmrId);
545   _debug_printf("\t\t.guestResult.offset = %u\n", (*cmd).guestResult.offset);
546}
547
548static void
549dump_SVGA3dSize(const SVGA3dSize *cmd)
550{
551   _debug_printf("\t\t.width = %u\n", (*cmd).width);
552   _debug_printf("\t\t.height = %u\n", (*cmd).height);
553   _debug_printf("\t\t.depth = %u\n", (*cmd).depth);
554}
555
556static void
557dump_SVGA3dCmdDestroySurface(const SVGA3dCmdDestroySurface *cmd)
558{
559   _debug_printf("\t\t.sid = %u\n", (*cmd).sid);
560}
561
562static void
563dump_SVGA3dCmdDefineContext(const SVGA3dCmdDefineContext *cmd)
564{
565   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
566}
567
568static void
569dump_SVGA3dRect(const SVGA3dRect *cmd)
570{
571   _debug_printf("\t\t.x = %u\n", (*cmd).x);
572   _debug_printf("\t\t.y = %u\n", (*cmd).y);
573   _debug_printf("\t\t.w = %u\n", (*cmd).w);
574   _debug_printf("\t\t.h = %u\n", (*cmd).h);
575}
576
577static void
578dump_SVGA3dCmdBeginQuery(const SVGA3dCmdBeginQuery *cmd)
579{
580   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
581   switch((*cmd).type) {
582   case SVGA3D_QUERYTYPE_OCCLUSION:
583      _debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
584      break;
585   case SVGA3D_QUERYTYPE_MAX:
586      _debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
587      break;
588   default:
589      _debug_printf("\t\t.type = %i\n", (*cmd).type);
590      break;
591   }
592}
593
594static void
595dump_SVGA3dRenderState(const SVGA3dRenderState *cmd)
596{
597   switch((*cmd).state) {
598   case SVGA3D_RS_INVALID:
599      _debug_printf("\t\t.state = SVGA3D_RS_INVALID\n");
600      break;
601   case SVGA3D_RS_ZENABLE:
602      _debug_printf("\t\t.state = SVGA3D_RS_ZENABLE\n");
603      break;
604   case SVGA3D_RS_ZWRITEENABLE:
605      _debug_printf("\t\t.state = SVGA3D_RS_ZWRITEENABLE\n");
606      break;
607   case SVGA3D_RS_ALPHATESTENABLE:
608      _debug_printf("\t\t.state = SVGA3D_RS_ALPHATESTENABLE\n");
609      break;
610   case SVGA3D_RS_DITHERENABLE:
611      _debug_printf("\t\t.state = SVGA3D_RS_DITHERENABLE\n");
612      break;
613   case SVGA3D_RS_BLENDENABLE:
614      _debug_printf("\t\t.state = SVGA3D_RS_BLENDENABLE\n");
615      break;
616   case SVGA3D_RS_FOGENABLE:
617      _debug_printf("\t\t.state = SVGA3D_RS_FOGENABLE\n");
618      break;
619   case SVGA3D_RS_SPECULARENABLE:
620      _debug_printf("\t\t.state = SVGA3D_RS_SPECULARENABLE\n");
621      break;
622   case SVGA3D_RS_STENCILENABLE:
623      _debug_printf("\t\t.state = SVGA3D_RS_STENCILENABLE\n");
624      break;
625   case SVGA3D_RS_LIGHTINGENABLE:
626      _debug_printf("\t\t.state = SVGA3D_RS_LIGHTINGENABLE\n");
627      break;
628   case SVGA3D_RS_NORMALIZENORMALS:
629      _debug_printf("\t\t.state = SVGA3D_RS_NORMALIZENORMALS\n");
630      break;
631   case SVGA3D_RS_POINTSPRITEENABLE:
632      _debug_printf("\t\t.state = SVGA3D_RS_POINTSPRITEENABLE\n");
633      break;
634   case SVGA3D_RS_POINTSCALEENABLE:
635      _debug_printf("\t\t.state = SVGA3D_RS_POINTSCALEENABLE\n");
636      break;
637   case SVGA3D_RS_STENCILREF:
638      _debug_printf("\t\t.state = SVGA3D_RS_STENCILREF\n");
639      break;
640   case SVGA3D_RS_STENCILMASK:
641      _debug_printf("\t\t.state = SVGA3D_RS_STENCILMASK\n");
642      break;
643   case SVGA3D_RS_STENCILWRITEMASK:
644      _debug_printf("\t\t.state = SVGA3D_RS_STENCILWRITEMASK\n");
645      break;
646   case SVGA3D_RS_FOGSTART:
647      _debug_printf("\t\t.state = SVGA3D_RS_FOGSTART\n");
648      break;
649   case SVGA3D_RS_FOGEND:
650      _debug_printf("\t\t.state = SVGA3D_RS_FOGEND\n");
651      break;
652   case SVGA3D_RS_FOGDENSITY:
653      _debug_printf("\t\t.state = SVGA3D_RS_FOGDENSITY\n");
654      break;
655   case SVGA3D_RS_POINTSIZE:
656      _debug_printf("\t\t.state = SVGA3D_RS_POINTSIZE\n");
657      break;
658   case SVGA3D_RS_POINTSIZEMIN:
659      _debug_printf("\t\t.state = SVGA3D_RS_POINTSIZEMIN\n");
660      break;
661   case SVGA3D_RS_POINTSIZEMAX:
662      _debug_printf("\t\t.state = SVGA3D_RS_POINTSIZEMAX\n");
663      break;
664   case SVGA3D_RS_POINTSCALE_A:
665      _debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_A\n");
666      break;
667   case SVGA3D_RS_POINTSCALE_B:
668      _debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_B\n");
669      break;
670   case SVGA3D_RS_POINTSCALE_C:
671      _debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_C\n");
672      break;
673   case SVGA3D_RS_FOGCOLOR:
674      _debug_printf("\t\t.state = SVGA3D_RS_FOGCOLOR\n");
675      break;
676   case SVGA3D_RS_AMBIENT:
677      _debug_printf("\t\t.state = SVGA3D_RS_AMBIENT\n");
678      break;
679   case SVGA3D_RS_CLIPPLANEENABLE:
680      _debug_printf("\t\t.state = SVGA3D_RS_CLIPPLANEENABLE\n");
681      break;
682   case SVGA3D_RS_FOGMODE:
683      _debug_printf("\t\t.state = SVGA3D_RS_FOGMODE\n");
684      break;
685   case SVGA3D_RS_FILLMODE:
686      _debug_printf("\t\t.state = SVGA3D_RS_FILLMODE\n");
687      break;
688   case SVGA3D_RS_SHADEMODE:
689      _debug_printf("\t\t.state = SVGA3D_RS_SHADEMODE\n");
690      break;
691   case SVGA3D_RS_LINEPATTERN:
692      _debug_printf("\t\t.state = SVGA3D_RS_LINEPATTERN\n");
693      break;
694   case SVGA3D_RS_SRCBLEND:
695      _debug_printf("\t\t.state = SVGA3D_RS_SRCBLEND\n");
696      break;
697   case SVGA3D_RS_DSTBLEND:
698      _debug_printf("\t\t.state = SVGA3D_RS_DSTBLEND\n");
699      break;
700   case SVGA3D_RS_BLENDEQUATION:
701      _debug_printf("\t\t.state = SVGA3D_RS_BLENDEQUATION\n");
702      break;
703   case SVGA3D_RS_CULLMODE:
704      _debug_printf("\t\t.state = SVGA3D_RS_CULLMODE\n");
705      break;
706   case SVGA3D_RS_ZFUNC:
707      _debug_printf("\t\t.state = SVGA3D_RS_ZFUNC\n");
708      break;
709   case SVGA3D_RS_ALPHAFUNC:
710      _debug_printf("\t\t.state = SVGA3D_RS_ALPHAFUNC\n");
711      break;
712   case SVGA3D_RS_STENCILFUNC:
713      _debug_printf("\t\t.state = SVGA3D_RS_STENCILFUNC\n");
714      break;
715   case SVGA3D_RS_STENCILFAIL:
716      _debug_printf("\t\t.state = SVGA3D_RS_STENCILFAIL\n");
717      break;
718   case SVGA3D_RS_STENCILZFAIL:
719      _debug_printf("\t\t.state = SVGA3D_RS_STENCILZFAIL\n");
720      break;
721   case SVGA3D_RS_STENCILPASS:
722      _debug_printf("\t\t.state = SVGA3D_RS_STENCILPASS\n");
723      break;
724   case SVGA3D_RS_ALPHAREF:
725      _debug_printf("\t\t.state = SVGA3D_RS_ALPHAREF\n");
726      break;
727   case SVGA3D_RS_FRONTWINDING:
728      _debug_printf("\t\t.state = SVGA3D_RS_FRONTWINDING\n");
729      break;
730   case SVGA3D_RS_COORDINATETYPE:
731      _debug_printf("\t\t.state = SVGA3D_RS_COORDINATETYPE\n");
732      break;
733   case SVGA3D_RS_ZBIAS:
734      _debug_printf("\t\t.state = SVGA3D_RS_ZBIAS\n");
735      break;
736   case SVGA3D_RS_RANGEFOGENABLE:
737      _debug_printf("\t\t.state = SVGA3D_RS_RANGEFOGENABLE\n");
738      break;
739   case SVGA3D_RS_COLORWRITEENABLE:
740      _debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE\n");
741      break;
742   case SVGA3D_RS_VERTEXMATERIALENABLE:
743      _debug_printf("\t\t.state = SVGA3D_RS_VERTEXMATERIALENABLE\n");
744      break;
745   case SVGA3D_RS_DIFFUSEMATERIALSOURCE:
746      _debug_printf("\t\t.state = SVGA3D_RS_DIFFUSEMATERIALSOURCE\n");
747      break;
748   case SVGA3D_RS_SPECULARMATERIALSOURCE:
749      _debug_printf("\t\t.state = SVGA3D_RS_SPECULARMATERIALSOURCE\n");
750      break;
751   case SVGA3D_RS_AMBIENTMATERIALSOURCE:
752      _debug_printf("\t\t.state = SVGA3D_RS_AMBIENTMATERIALSOURCE\n");
753      break;
754   case SVGA3D_RS_EMISSIVEMATERIALSOURCE:
755      _debug_printf("\t\t.state = SVGA3D_RS_EMISSIVEMATERIALSOURCE\n");
756      break;
757   case SVGA3D_RS_TEXTUREFACTOR:
758      _debug_printf("\t\t.state = SVGA3D_RS_TEXTUREFACTOR\n");
759      break;
760   case SVGA3D_RS_LOCALVIEWER:
761      _debug_printf("\t\t.state = SVGA3D_RS_LOCALVIEWER\n");
762      break;
763   case SVGA3D_RS_SCISSORTESTENABLE:
764      _debug_printf("\t\t.state = SVGA3D_RS_SCISSORTESTENABLE\n");
765      break;
766   case SVGA3D_RS_BLENDCOLOR:
767      _debug_printf("\t\t.state = SVGA3D_RS_BLENDCOLOR\n");
768      break;
769   case SVGA3D_RS_STENCILENABLE2SIDED:
770      _debug_printf("\t\t.state = SVGA3D_RS_STENCILENABLE2SIDED\n");
771      break;
772   case SVGA3D_RS_CCWSTENCILFUNC:
773      _debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILFUNC\n");
774      break;
775   case SVGA3D_RS_CCWSTENCILFAIL:
776      _debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILFAIL\n");
777      break;
778   case SVGA3D_RS_CCWSTENCILZFAIL:
779      _debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILZFAIL\n");
780      break;
781   case SVGA3D_RS_CCWSTENCILPASS:
782      _debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILPASS\n");
783      break;
784   case SVGA3D_RS_VERTEXBLEND:
785      _debug_printf("\t\t.state = SVGA3D_RS_VERTEXBLEND\n");
786      break;
787   case SVGA3D_RS_SLOPESCALEDEPTHBIAS:
788      _debug_printf("\t\t.state = SVGA3D_RS_SLOPESCALEDEPTHBIAS\n");
789      break;
790   case SVGA3D_RS_DEPTHBIAS:
791      _debug_printf("\t\t.state = SVGA3D_RS_DEPTHBIAS\n");
792      break;
793   case SVGA3D_RS_OUTPUTGAMMA:
794      _debug_printf("\t\t.state = SVGA3D_RS_OUTPUTGAMMA\n");
795      break;
796   case SVGA3D_RS_ZVISIBLE:
797      _debug_printf("\t\t.state = SVGA3D_RS_ZVISIBLE\n");
798      break;
799   case SVGA3D_RS_LASTPIXEL:
800      _debug_printf("\t\t.state = SVGA3D_RS_LASTPIXEL\n");
801      break;
802   case SVGA3D_RS_CLIPPING:
803      _debug_printf("\t\t.state = SVGA3D_RS_CLIPPING\n");
804      break;
805   case SVGA3D_RS_WRAP0:
806      _debug_printf("\t\t.state = SVGA3D_RS_WRAP0\n");
807      break;
808   case SVGA3D_RS_WRAP1:
809      _debug_printf("\t\t.state = SVGA3D_RS_WRAP1\n");
810      break;
811   case SVGA3D_RS_WRAP2:
812      _debug_printf("\t\t.state = SVGA3D_RS_WRAP2\n");
813      break;
814   case SVGA3D_RS_WRAP3:
815      _debug_printf("\t\t.state = SVGA3D_RS_WRAP3\n");
816      break;
817   case SVGA3D_RS_WRAP4:
818      _debug_printf("\t\t.state = SVGA3D_RS_WRAP4\n");
819      break;
820   case SVGA3D_RS_WRAP5:
821      _debug_printf("\t\t.state = SVGA3D_RS_WRAP5\n");
822      break;
823   case SVGA3D_RS_WRAP6:
824      _debug_printf("\t\t.state = SVGA3D_RS_WRAP6\n");
825      break;
826   case SVGA3D_RS_WRAP7:
827      _debug_printf("\t\t.state = SVGA3D_RS_WRAP7\n");
828      break;
829   case SVGA3D_RS_WRAP8:
830      _debug_printf("\t\t.state = SVGA3D_RS_WRAP8\n");
831      break;
832   case SVGA3D_RS_WRAP9:
833      _debug_printf("\t\t.state = SVGA3D_RS_WRAP9\n");
834      break;
835   case SVGA3D_RS_WRAP10:
836      _debug_printf("\t\t.state = SVGA3D_RS_WRAP10\n");
837      break;
838   case SVGA3D_RS_WRAP11:
839      _debug_printf("\t\t.state = SVGA3D_RS_WRAP11\n");
840      break;
841   case SVGA3D_RS_WRAP12:
842      _debug_printf("\t\t.state = SVGA3D_RS_WRAP12\n");
843      break;
844   case SVGA3D_RS_WRAP13:
845      _debug_printf("\t\t.state = SVGA3D_RS_WRAP13\n");
846      break;
847   case SVGA3D_RS_WRAP14:
848      _debug_printf("\t\t.state = SVGA3D_RS_WRAP14\n");
849      break;
850   case SVGA3D_RS_WRAP15:
851      _debug_printf("\t\t.state = SVGA3D_RS_WRAP15\n");
852      break;
853   case SVGA3D_RS_MULTISAMPLEANTIALIAS:
854      _debug_printf("\t\t.state = SVGA3D_RS_MULTISAMPLEANTIALIAS\n");
855      break;
856   case SVGA3D_RS_MULTISAMPLEMASK:
857      _debug_printf("\t\t.state = SVGA3D_RS_MULTISAMPLEMASK\n");
858      break;
859   case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE:
860      _debug_printf("\t\t.state = SVGA3D_RS_INDEXEDVERTEXBLENDENABLE\n");
861      break;
862   case SVGA3D_RS_TWEENFACTOR:
863      _debug_printf("\t\t.state = SVGA3D_RS_TWEENFACTOR\n");
864      break;
865   case SVGA3D_RS_ANTIALIASEDLINEENABLE:
866      _debug_printf("\t\t.state = SVGA3D_RS_ANTIALIASEDLINEENABLE\n");
867      break;
868   case SVGA3D_RS_COLORWRITEENABLE1:
869      _debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE1\n");
870      break;
871   case SVGA3D_RS_COLORWRITEENABLE2:
872      _debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE2\n");
873      break;
874   case SVGA3D_RS_COLORWRITEENABLE3:
875      _debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE3\n");
876      break;
877   case SVGA3D_RS_SEPARATEALPHABLENDENABLE:
878      _debug_printf("\t\t.state = SVGA3D_RS_SEPARATEALPHABLENDENABLE\n");
879      break;
880   case SVGA3D_RS_SRCBLENDALPHA:
881      _debug_printf("\t\t.state = SVGA3D_RS_SRCBLENDALPHA\n");
882      break;
883   case SVGA3D_RS_DSTBLENDALPHA:
884      _debug_printf("\t\t.state = SVGA3D_RS_DSTBLENDALPHA\n");
885      break;
886   case SVGA3D_RS_BLENDEQUATIONALPHA:
887      _debug_printf("\t\t.state = SVGA3D_RS_BLENDEQUATIONALPHA\n");
888      break;
889   case SVGA3D_RS_MAX:
890      _debug_printf("\t\t.state = SVGA3D_RS_MAX\n");
891      break;
892   default:
893      _debug_printf("\t\t.state = %i\n", (*cmd).state);
894      break;
895   }
896   _debug_printf("\t\t.uintValue = %u\n", (*cmd).uintValue);
897   _debug_printf("\t\t.floatValue = %f\n", (*cmd).floatValue);
898}
899
900static void
901dump_SVGA3dVertexDivisor(const SVGA3dVertexDivisor *cmd)
902{
903   _debug_printf("\t\t.value = %u\n", (*cmd).value);
904   _debug_printf("\t\t.count = %u\n", (*cmd).count);
905   _debug_printf("\t\t.indexedData = %u\n", (*cmd).indexedData);
906   _debug_printf("\t\t.instanceData = %u\n", (*cmd).instanceData);
907}
908
909static void
910dump_SVGA3dCmdDefineShader(const SVGA3dCmdDefineShader *cmd)
911{
912   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
913   _debug_printf("\t\t.shid = %u\n", (*cmd).shid);
914   switch((*cmd).type) {
915   case SVGA3D_SHADERTYPE_VS:
916      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
917      break;
918   case SVGA3D_SHADERTYPE_PS:
919      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
920      break;
921   case SVGA3D_SHADERTYPE_MAX:
922      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_MAX\n");
923      break;
924   default:
925      _debug_printf("\t\t.type = %i\n", (*cmd).type);
926      break;
927   }
928}
929
930static void
931dump_SVGA3dCmdSetShaderConst(const SVGA3dCmdSetShaderConst *cmd, uint32 numConsts)
932{
933   uint32 i;
934   const float (*fvalues)[4];
935   const int32 (*ivalues)[4];
936   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
937   _debug_printf("\t\t.reg = %u\n", (*cmd).reg);
938   switch((*cmd).type) {
939   case SVGA3D_SHADERTYPE_VS:
940      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
941      break;
942   case SVGA3D_SHADERTYPE_PS:
943      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
944      break;
945   case SVGA3D_SHADERTYPE_MAX:
946      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_MAX\n");
947      break;
948   default:
949      _debug_printf("\t\t.type = %i\n", (*cmd).type);
950      break;
951   }
952   switch((*cmd).ctype) {
953   case SVGA3D_CONST_TYPE_FLOAT:
954      _debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_FLOAT\n");
955      fvalues = (const float (*)[4])cmd->values;
956      for (i = 0; i < numConsts; ++i) {
957         _debug_printf("\t\t.values[%u] = {%f, %f, %f, %f}\n",
958                       cmd->reg + i,
959                       fvalues[i][0],
960                       fvalues[i][1],
961                       fvalues[i][2],
962                       fvalues[i][3]);
963      }
964      break;
965   case SVGA3D_CONST_TYPE_INT:
966      _debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_INT\n");
967      ivalues = (const int32 (*)[4])cmd->values;
968      for (i = 0; i < numConsts; ++i) {
969         _debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
970                       cmd->reg + i,
971                       ivalues[i][0],
972                       ivalues[i][1],
973                       ivalues[i][2],
974                       ivalues[i][3]);
975      }
976      break;
977   case SVGA3D_CONST_TYPE_BOOL:
978      _debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_BOOL\n");
979      ivalues = (const int32 (*)[4])cmd->values;
980      for (i = 0; i < numConsts; ++i) {
981         _debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
982                       cmd->reg + i,
983                       ivalues[i][0],
984                       ivalues[i][1],
985                       ivalues[i][2],
986                       ivalues[i][3]);
987      }
988      break;
989   default:
990      _debug_printf("\t\t.ctype = %i\n", (*cmd).ctype);
991      ivalues = (const int32 (*)[4])cmd->values;
992      for (i = 0; i < numConsts; ++i) {
993         _debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
994                       cmd->reg + i,
995                       ivalues[i][0],
996                       ivalues[i][1],
997                       ivalues[i][2],
998                       ivalues[i][3]);
999      }
1000      break;
1001   }
1002}
1003
1004static void
1005dump_SVGA3dCmdSetZRange(const SVGA3dCmdSetZRange *cmd)
1006{
1007   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1008   _debug_printf("\t\t.zRange.min = %f\n", (*cmd).zRange.min);
1009   _debug_printf("\t\t.zRange.max = %f\n", (*cmd).zRange.max);
1010}
1011
1012static void
1013dump_SVGA3dCmdDrawPrimitives(const SVGA3dCmdDrawPrimitives *cmd)
1014{
1015   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1016   _debug_printf("\t\t.numVertexDecls = %u\n", (*cmd).numVertexDecls);
1017   _debug_printf("\t\t.numRanges = %u\n", (*cmd).numRanges);
1018}
1019
1020static void
1021dump_SVGA3dCmdSetLightEnabled(const SVGA3dCmdSetLightEnabled *cmd)
1022{
1023   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1024   _debug_printf("\t\t.index = %u\n", (*cmd).index);
1025   _debug_printf("\t\t.enabled = %u\n", (*cmd).enabled);
1026}
1027
1028static void
1029dump_SVGA3dPrimitiveRange(const SVGA3dPrimitiveRange *cmd)
1030{
1031   switch((*cmd).primType) {
1032   case SVGA3D_PRIMITIVE_INVALID:
1033      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_INVALID\n");
1034      break;
1035   case SVGA3D_PRIMITIVE_TRIANGLELIST:
1036      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLELIST\n");
1037      break;
1038   case SVGA3D_PRIMITIVE_POINTLIST:
1039      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_POINTLIST\n");
1040      break;
1041   case SVGA3D_PRIMITIVE_LINELIST:
1042      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_LINELIST\n");
1043      break;
1044   case SVGA3D_PRIMITIVE_LINESTRIP:
1045      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_LINESTRIP\n");
1046      break;
1047   case SVGA3D_PRIMITIVE_TRIANGLESTRIP:
1048      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLESTRIP\n");
1049      break;
1050   case SVGA3D_PRIMITIVE_TRIANGLEFAN:
1051      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLEFAN\n");
1052      break;
1053   case SVGA3D_PRIMITIVE_MAX:
1054      _debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_MAX\n");
1055      break;
1056   default:
1057      _debug_printf("\t\t.primType = %i\n", (*cmd).primType);
1058      break;
1059   }
1060   _debug_printf("\t\t.primitiveCount = %u\n", (*cmd).primitiveCount);
1061   _debug_printf("\t\t.indexArray.surfaceId = %u\n", (*cmd).indexArray.surfaceId);
1062   _debug_printf("\t\t.indexArray.offset = %u\n", (*cmd).indexArray.offset);
1063   _debug_printf("\t\t.indexArray.stride = %u\n", (*cmd).indexArray.stride);
1064   _debug_printf("\t\t.indexWidth = %u\n", (*cmd).indexWidth);
1065   _debug_printf("\t\t.indexBias = %i\n", (*cmd).indexBias);
1066}
1067
1068static void
1069dump_SVGA3dCmdPresent(const SVGA3dCmdPresent *cmd)
1070{
1071   _debug_printf("\t\t.sid = %u\n", (*cmd).sid);
1072}
1073
1074static void
1075dump_SVGA3dCmdSetRenderState(const SVGA3dCmdSetRenderState *cmd)
1076{
1077   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1078}
1079
1080static void
1081dump_SVGA3dCmdSurfaceStretchBlt(const SVGA3dCmdSurfaceStretchBlt *cmd)
1082{
1083   _debug_printf("\t\t.src.sid = %u\n", (*cmd).src.sid);
1084   _debug_printf("\t\t.src.face = %u\n", (*cmd).src.face);
1085   _debug_printf("\t\t.src.mipmap = %u\n", (*cmd).src.mipmap);
1086   _debug_printf("\t\t.dest.sid = %u\n", (*cmd).dest.sid);
1087   _debug_printf("\t\t.dest.face = %u\n", (*cmd).dest.face);
1088   _debug_printf("\t\t.dest.mipmap = %u\n", (*cmd).dest.mipmap);
1089   _debug_printf("\t\t.boxSrc.x = %u\n", (*cmd).boxSrc.x);
1090   _debug_printf("\t\t.boxSrc.y = %u\n", (*cmd).boxSrc.y);
1091   _debug_printf("\t\t.boxSrc.z = %u\n", (*cmd).boxSrc.z);
1092   _debug_printf("\t\t.boxSrc.w = %u\n", (*cmd).boxSrc.w);
1093   _debug_printf("\t\t.boxSrc.h = %u\n", (*cmd).boxSrc.h);
1094   _debug_printf("\t\t.boxSrc.d = %u\n", (*cmd).boxSrc.d);
1095   _debug_printf("\t\t.boxDest.x = %u\n", (*cmd).boxDest.x);
1096   _debug_printf("\t\t.boxDest.y = %u\n", (*cmd).boxDest.y);
1097   _debug_printf("\t\t.boxDest.z = %u\n", (*cmd).boxDest.z);
1098   _debug_printf("\t\t.boxDest.w = %u\n", (*cmd).boxDest.w);
1099   _debug_printf("\t\t.boxDest.h = %u\n", (*cmd).boxDest.h);
1100   _debug_printf("\t\t.boxDest.d = %u\n", (*cmd).boxDest.d);
1101   switch((*cmd).mode) {
1102   case SVGA3D_STRETCH_BLT_POINT:
1103      _debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_POINT\n");
1104      break;
1105   case SVGA3D_STRETCH_BLT_LINEAR:
1106      _debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_LINEAR\n");
1107      break;
1108   case SVGA3D_STRETCH_BLT_MAX:
1109      _debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_MAX\n");
1110      break;
1111   default:
1112      _debug_printf("\t\t.mode = %i\n", (*cmd).mode);
1113      break;
1114   }
1115}
1116
1117static void
1118dump_SVGA3dCmdSurfaceDMA(const SVGA3dCmdSurfaceDMA *cmd)
1119{
1120   _debug_printf("\t\t.guest.ptr.gmrId = %u\n", (*cmd).guest.ptr.gmrId);
1121   _debug_printf("\t\t.guest.ptr.offset = %u\n", (*cmd).guest.ptr.offset);
1122   _debug_printf("\t\t.guest.pitch = %u\n", (*cmd).guest.pitch);
1123   _debug_printf("\t\t.host.sid = %u\n", (*cmd).host.sid);
1124   _debug_printf("\t\t.host.face = %u\n", (*cmd).host.face);
1125   _debug_printf("\t\t.host.mipmap = %u\n", (*cmd).host.mipmap);
1126   switch((*cmd).transfer) {
1127   case SVGA3D_WRITE_HOST_VRAM:
1128      _debug_printf("\t\t.transfer = SVGA3D_WRITE_HOST_VRAM\n");
1129      break;
1130   case SVGA3D_READ_HOST_VRAM:
1131      _debug_printf("\t\t.transfer = SVGA3D_READ_HOST_VRAM\n");
1132      break;
1133   default:
1134      _debug_printf("\t\t.transfer = %i\n", (*cmd).transfer);
1135      break;
1136   }
1137}
1138
1139static void
1140dump_SVGA3dCmdSurfaceDMASuffix(const SVGA3dCmdSurfaceDMASuffix *cmd)
1141{
1142   _debug_printf("\t\t.suffixSize = %u\n", (*cmd).suffixSize);
1143   _debug_printf("\t\t.maximumOffset = %u\n", (*cmd).maximumOffset);
1144   _debug_printf("\t\t.flags.discard = %u\n", (*cmd).flags.discard);
1145   _debug_printf("\t\t.flags.unsynchronized = %u\n", (*cmd).flags.unsynchronized);
1146}
1147
1148static void
1149dump_SVGA3dCmdSetTransform(const SVGA3dCmdSetTransform *cmd)
1150{
1151   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1152   switch((*cmd).type) {
1153   case SVGA3D_TRANSFORM_INVALID:
1154      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_INVALID\n");
1155      break;
1156   case SVGA3D_TRANSFORM_WORLD:
1157      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD\n");
1158      break;
1159   case SVGA3D_TRANSFORM_VIEW:
1160      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_VIEW\n");
1161      break;
1162   case SVGA3D_TRANSFORM_PROJECTION:
1163      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_PROJECTION\n");
1164      break;
1165   case SVGA3D_TRANSFORM_TEXTURE0:
1166      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE0\n");
1167      break;
1168   case SVGA3D_TRANSFORM_TEXTURE1:
1169      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE1\n");
1170      break;
1171   case SVGA3D_TRANSFORM_TEXTURE2:
1172      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE2\n");
1173      break;
1174   case SVGA3D_TRANSFORM_TEXTURE3:
1175      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE3\n");
1176      break;
1177   case SVGA3D_TRANSFORM_TEXTURE4:
1178      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE4\n");
1179      break;
1180   case SVGA3D_TRANSFORM_TEXTURE5:
1181      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE5\n");
1182      break;
1183   case SVGA3D_TRANSFORM_TEXTURE6:
1184      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE6\n");
1185      break;
1186   case SVGA3D_TRANSFORM_TEXTURE7:
1187      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE7\n");
1188      break;
1189   case SVGA3D_TRANSFORM_WORLD1:
1190      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD1\n");
1191      break;
1192   case SVGA3D_TRANSFORM_WORLD2:
1193      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD2\n");
1194      break;
1195   case SVGA3D_TRANSFORM_WORLD3:
1196      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD3\n");
1197      break;
1198   case SVGA3D_TRANSFORM_MAX:
1199      _debug_printf("\t\t.type = SVGA3D_TRANSFORM_MAX\n");
1200      break;
1201   default:
1202      _debug_printf("\t\t.type = %i\n", (*cmd).type);
1203      break;
1204   }
1205   _debug_printf("\t\t.matrix[0] = %f\n", (*cmd).matrix[0]);
1206   _debug_printf("\t\t.matrix[1] = %f\n", (*cmd).matrix[1]);
1207   _debug_printf("\t\t.matrix[2] = %f\n", (*cmd).matrix[2]);
1208   _debug_printf("\t\t.matrix[3] = %f\n", (*cmd).matrix[3]);
1209   _debug_printf("\t\t.matrix[4] = %f\n", (*cmd).matrix[4]);
1210   _debug_printf("\t\t.matrix[5] = %f\n", (*cmd).matrix[5]);
1211   _debug_printf("\t\t.matrix[6] = %f\n", (*cmd).matrix[6]);
1212   _debug_printf("\t\t.matrix[7] = %f\n", (*cmd).matrix[7]);
1213   _debug_printf("\t\t.matrix[8] = %f\n", (*cmd).matrix[8]);
1214   _debug_printf("\t\t.matrix[9] = %f\n", (*cmd).matrix[9]);
1215   _debug_printf("\t\t.matrix[10] = %f\n", (*cmd).matrix[10]);
1216   _debug_printf("\t\t.matrix[11] = %f\n", (*cmd).matrix[11]);
1217   _debug_printf("\t\t.matrix[12] = %f\n", (*cmd).matrix[12]);
1218   _debug_printf("\t\t.matrix[13] = %f\n", (*cmd).matrix[13]);
1219   _debug_printf("\t\t.matrix[14] = %f\n", (*cmd).matrix[14]);
1220   _debug_printf("\t\t.matrix[15] = %f\n", (*cmd).matrix[15]);
1221}
1222
1223static void
1224dump_SVGA3dCmdDestroyShader(const SVGA3dCmdDestroyShader *cmd)
1225{
1226   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1227   _debug_printf("\t\t.shid = %u\n", (*cmd).shid);
1228   switch((*cmd).type) {
1229   case SVGA3D_SHADERTYPE_VS:
1230      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
1231      break;
1232   case SVGA3D_SHADERTYPE_PS:
1233      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
1234      break;
1235   case SVGA3D_SHADERTYPE_MAX:
1236      _debug_printf("\t\t.type = SVGA3D_SHADERTYPE_MAX\n");
1237      break;
1238   default:
1239      _debug_printf("\t\t.type = %i\n", (*cmd).type);
1240      break;
1241   }
1242}
1243
1244static void
1245dump_SVGA3dCmdDestroyContext(const SVGA3dCmdDestroyContext *cmd)
1246{
1247   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1248}
1249
1250static void
1251dump_SVGA3dCmdClear(const SVGA3dCmdClear *cmd)
1252{
1253   _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1254   switch((*cmd).clearFlag) {
1255   case SVGA3D_CLEAR_COLOR:
1256      _debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_COLOR\n");
1257      break;
1258   case SVGA3D_CLEAR_DEPTH:
1259      _debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_DEPTH\n");
1260      break;
1261   case SVGA3D_CLEAR_STENCIL:
1262      _debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_STENCIL\n");
1263      break;
1264   default:
1265      _debug_printf("\t\t.clearFlag = %i\n", (*cmd).clearFlag);
1266      break;
1267   }
1268   _debug_printf("\t\t.color = %u\n", (*cmd).color);
1269   _debug_printf("\t\t.depth = %f\n", (*cmd).depth);
1270   _debug_printf("\t\t.stencil = %u\n", (*cmd).stencil);
1271}
1272
1273static void
1274dump_SVGA3dCmdDefineSurface(const SVGA3dCmdDefineSurface *cmd)
1275{
1276   _debug_printf("\t\t.sid = %u\n", (*cmd).sid);
1277   switch((*cmd).surfaceFlags) {
1278   case SVGA3D_SURFACE_CUBEMAP:
1279      _debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_CUBEMAP\n");
1280      break;
1281   case SVGA3D_SURFACE_HINT_STATIC:
1282      _debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_STATIC\n");
1283      break;
1284   case SVGA3D_SURFACE_HINT_DYNAMIC:
1285      _debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_DYNAMIC\n");
1286      break;
1287   case SVGA3D_SURFACE_HINT_INDEXBUFFER:
1288      _debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_INDEXBUFFER\n");
1289      break;
1290   case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
1291      _debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_VERTEXBUFFER\n");
1292      break;
1293   default:
1294      _debug_printf("\t\t.surfaceFlags = %i\n", (*cmd).surfaceFlags);
1295      break;
1296   }
1297   switch((*cmd).format) {
1298   case SVGA3D_FORMAT_INVALID:
1299      _debug_printf("\t\t.format = SVGA3D_FORMAT_INVALID\n");
1300      break;
1301   case SVGA3D_X8R8G8B8:
1302      _debug_printf("\t\t.format = SVGA3D_X8R8G8B8\n");
1303      break;
1304   case SVGA3D_A8R8G8B8:
1305      _debug_printf("\t\t.format = SVGA3D_A8R8G8B8\n");
1306      break;
1307   case SVGA3D_R5G6B5:
1308      _debug_printf("\t\t.format = SVGA3D_R5G6B5\n");
1309      break;
1310   case SVGA3D_X1R5G5B5:
1311      _debug_printf("\t\t.format = SVGA3D_X1R5G5B5\n");
1312      break;
1313   case SVGA3D_A1R5G5B5:
1314      _debug_printf("\t\t.format = SVGA3D_A1R5G5B5\n");
1315      break;
1316   case SVGA3D_A4R4G4B4:
1317      _debug_printf("\t\t.format = SVGA3D_A4R4G4B4\n");
1318      break;
1319   case SVGA3D_Z_D32:
1320      _debug_printf("\t\t.format = SVGA3D_Z_D32\n");
1321      break;
1322   case SVGA3D_Z_D16:
1323      _debug_printf("\t\t.format = SVGA3D_Z_D16\n");
1324      break;
1325   case SVGA3D_Z_D24S8:
1326      _debug_printf("\t\t.format = SVGA3D_Z_D24S8\n");
1327      break;
1328   case SVGA3D_Z_D15S1:
1329      _debug_printf("\t\t.format = SVGA3D_Z_D15S1\n");
1330      break;
1331   case SVGA3D_LUMINANCE8:
1332      _debug_printf("\t\t.format = SVGA3D_LUMINANCE8\n");
1333      break;
1334   case SVGA3D_LUMINANCE4_ALPHA4:
1335      _debug_printf("\t\t.format = SVGA3D_LUMINANCE4_ALPHA4\n");
1336      break;
1337   case SVGA3D_LUMINANCE16:
1338      _debug_printf("\t\t.format = SVGA3D_LUMINANCE16\n");
1339      break;
1340   case SVGA3D_LUMINANCE8_ALPHA8:
1341      _debug_printf("\t\t.format = SVGA3D_LUMINANCE8_ALPHA8\n");
1342      break;
1343   case SVGA3D_DXT1:
1344      _debug_printf("\t\t.format = SVGA3D_DXT1\n");
1345      break;
1346   case SVGA3D_DXT2:
1347      _debug_printf("\t\t.format = SVGA3D_DXT2\n");
1348      break;
1349   case SVGA3D_DXT3:
1350      _debug_printf("\t\t.format = SVGA3D_DXT3\n");
1351      break;
1352   case SVGA3D_DXT4:
1353      _debug_printf("\t\t.format = SVGA3D_DXT4\n");
1354      break;
1355   case SVGA3D_DXT5:
1356      _debug_printf("\t\t.format = SVGA3D_DXT5\n");
1357      break;
1358   case SVGA3D_BUMPU8V8:
1359      _debug_printf("\t\t.format = SVGA3D_BUMPU8V8\n");
1360      break;
1361   case SVGA3D_BUMPL6V5U5:
1362      _debug_printf("\t\t.format = SVGA3D_BUMPL6V5U5\n");
1363      break;
1364   case SVGA3D_BUMPX8L8V8U8:
1365      _debug_printf("\t\t.format = SVGA3D_BUMPX8L8V8U8\n");
1366      break;
1367   case SVGA3D_BUMPL8V8U8:
1368      _debug_printf("\t\t.format = SVGA3D_BUMPL8V8U8\n");
1369      break;
1370   case SVGA3D_ARGB_S10E5:
1371      _debug_printf("\t\t.format = SVGA3D_ARGB_S10E5\n");
1372      break;
1373   case SVGA3D_ARGB_S23E8:
1374      _debug_printf("\t\t.format = SVGA3D_ARGB_S23E8\n");
1375      break;
1376   case SVGA3D_A2R10G10B10:
1377      _debug_printf("\t\t.format = SVGA3D_A2R10G10B10\n");
1378      break;
1379   case SVGA3D_V8U8:
1380      _debug_printf("\t\t.format = SVGA3D_V8U8\n");
1381      break;
1382   case SVGA3D_Q8W8V8U8:
1383      _debug_printf("\t\t.format = SVGA3D_Q8W8V8U8\n");
1384      break;
1385   case SVGA3D_CxV8U8:
1386      _debug_printf("\t\t.format = SVGA3D_CxV8U8\n");
1387      break;
1388   case SVGA3D_X8L8V8U8:
1389      _debug_printf("\t\t.format = SVGA3D_X8L8V8U8\n");
1390      break;
1391   case SVGA3D_A2W10V10U10:
1392      _debug_printf("\t\t.format = SVGA3D_A2W10V10U10\n");
1393      break;
1394   case SVGA3D_ALPHA8:
1395      _debug_printf("\t\t.format = SVGA3D_ALPHA8\n");
1396      break;
1397   case SVGA3D_R_S10E5:
1398      _debug_printf("\t\t.format = SVGA3D_R_S10E5\n");
1399      break;
1400   case SVGA3D_R_S23E8:
1401      _debug_printf("\t\t.format = SVGA3D_R_S23E8\n");
1402      break;
1403   case SVGA3D_RG_S10E5:
1404      _debug_printf("\t\t.format = SVGA3D_RG_S10E5\n");
1405      break;
1406   case SVGA3D_RG_S23E8:
1407      _debug_printf("\t\t.format = SVGA3D_RG_S23E8\n");
1408      break;
1409   case SVGA3D_BUFFER:
1410      _debug_printf("\t\t.format = SVGA3D_BUFFER\n");
1411      break;
1412   case SVGA3D_Z_D24X8:
1413      _debug_printf("\t\t.format = SVGA3D_Z_D24X8\n");
1414      break;
1415   case SVGA3D_G16R16:
1416      _debug_printf("\t\t.format = SVGA3D_G16R16\n");
1417      break;
1418   case SVGA3D_A16B16G16R16:
1419      _debug_printf("\t\t.format = SVGA3D_A16B16G16R16\n");
1420      break;
1421   case SVGA3D_UYVY:
1422      _debug_printf("\t\t.format = SVGA3D_UYVY\n");
1423      break;
1424   case SVGA3D_YUY2:
1425      _debug_printf("\t\t.format = SVGA3D_YUY2\n");
1426      break;
1427   case SVGA3D_NV12:
1428      _debug_printf("\t\t.format = SVGA3D_NV12\n");
1429      break;
1430   case SVGA3D_AYUV:
1431      _debug_printf("\t\t.format = SVGA3D_AYUV\n");
1432      break;
1433   case SVGA3D_Z_DF16:
1434      _debug_printf("\t\t.format = SVGA3D_Z_D16\n");
1435      break;
1436   case SVGA3D_Z_DF24:
1437      _debug_printf("\t\t.format = SVGA3D_Z_DF24\n");
1438      break;
1439   case SVGA3D_Z_D24S8_INT:
1440      _debug_printf("\t\t.format = SVGA3D_Z_D24S8_INT\n");
1441      break;
1442   default:
1443      _debug_printf("\t\t.format = %i\n", (*cmd).format);
1444      break;
1445   }
1446   _debug_printf("\t\t.face[0].numMipLevels = %u\n", (*cmd).face[0].numMipLevels);
1447   _debug_printf("\t\t.face[1].numMipLevels = %u\n", (*cmd).face[1].numMipLevels);
1448   _debug_printf("\t\t.face[2].numMipLevels = %u\n", (*cmd).face[2].numMipLevels);
1449   _debug_printf("\t\t.face[3].numMipLevels = %u\n", (*cmd).face[3].numMipLevels);
1450   _debug_printf("\t\t.face[4].numMipLevels = %u\n", (*cmd).face[4].numMipLevels);
1451   _debug_printf("\t\t.face[5].numMipLevels = %u\n", (*cmd).face[5].numMipLevels);
1452}
1453
1454static void
1455dump_SVGASignedRect(const SVGASignedRect *cmd)
1456{
1457   _debug_printf("\t\t.left = %i\n", (*cmd).left);
1458   _debug_printf("\t\t.top = %i\n", (*cmd).top);
1459   _debug_printf("\t\t.right = %i\n", (*cmd).right);
1460   _debug_printf("\t\t.bottom = %i\n", (*cmd).bottom);
1461}
1462
1463static void
1464dump_SVGA3dCmdBlitSurfaceToScreen(const SVGA3dCmdBlitSurfaceToScreen *cmd)
1465{
1466   _debug_printf("\t\t.srcImage.sid = %u\n", (*cmd).srcImage.sid);
1467   _debug_printf("\t\t.srcImage.face = %u\n", (*cmd).srcImage.face);
1468   _debug_printf("\t\t.srcImage.mipmap = %u\n", (*cmd).srcImage.mipmap);
1469   _debug_printf("\t\t.srcRect.left = %i\n", (*cmd).srcRect.left);
1470   _debug_printf("\t\t.srcRect.top = %i\n", (*cmd).srcRect.top);
1471   _debug_printf("\t\t.srcRect.right = %i\n", (*cmd).srcRect.right);
1472   _debug_printf("\t\t.srcRect.bottom = %i\n", (*cmd).srcRect.bottom);
1473   _debug_printf("\t\t.destScreenId = %u\n", (*cmd).destScreenId);
1474   _debug_printf("\t\t.destRect.left = %i\n", (*cmd).destRect.left);
1475   _debug_printf("\t\t.destRect.top = %i\n", (*cmd).destRect.top);
1476   _debug_printf("\t\t.destRect.right = %i\n", (*cmd).destRect.right);
1477   _debug_printf("\t\t.destRect.bottom = %i\n", (*cmd).destRect.bottom);
1478}
1479
1480
1481void
1482svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size)
1483{
1484   const uint8_t *body = (const uint8_t *)data;
1485   const uint8_t *next = body + size;
1486
1487   switch(cmd_id) {
1488   case SVGA_3D_CMD_SURFACE_DEFINE:
1489      _debug_printf("\tSVGA_3D_CMD_SURFACE_DEFINE\n");
1490      {
1491         const SVGA3dCmdDefineSurface *cmd = (const SVGA3dCmdDefineSurface *)body;
1492         dump_SVGA3dCmdDefineSurface(cmd);
1493         body = (const uint8_t *)&cmd[1];
1494         while(body + sizeof(SVGA3dSize) <= next) {
1495            dump_SVGA3dSize((const SVGA3dSize *)body);
1496            body += sizeof(SVGA3dSize);
1497         }
1498      }
1499      break;
1500   case SVGA_3D_CMD_SURFACE_DESTROY:
1501      _debug_printf("\tSVGA_3D_CMD_SURFACE_DESTROY\n");
1502      {
1503         const SVGA3dCmdDestroySurface *cmd = (const SVGA3dCmdDestroySurface *)body;
1504         dump_SVGA3dCmdDestroySurface(cmd);
1505         body = (const uint8_t *)&cmd[1];
1506      }
1507      break;
1508   case SVGA_3D_CMD_SURFACE_COPY:
1509      _debug_printf("\tSVGA_3D_CMD_SURFACE_COPY\n");
1510      {
1511         const SVGA3dCmdSurfaceCopy *cmd = (const SVGA3dCmdSurfaceCopy *)body;
1512         dump_SVGA3dCmdSurfaceCopy(cmd);
1513         body = (const uint8_t *)&cmd[1];
1514         while(body + sizeof(SVGA3dCopyBox) <= next) {
1515            dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
1516            body += sizeof(SVGA3dCopyBox);
1517         }
1518      }
1519      break;
1520   case SVGA_3D_CMD_SURFACE_STRETCHBLT:
1521      _debug_printf("\tSVGA_3D_CMD_SURFACE_STRETCHBLT\n");
1522      {
1523         const SVGA3dCmdSurfaceStretchBlt *cmd = (const SVGA3dCmdSurfaceStretchBlt *)body;
1524         dump_SVGA3dCmdSurfaceStretchBlt(cmd);
1525         body = (const uint8_t *)&cmd[1];
1526      }
1527      break;
1528   case SVGA_3D_CMD_SURFACE_DMA:
1529      _debug_printf("\tSVGA_3D_CMD_SURFACE_DMA\n");
1530      {
1531         const SVGA3dCmdSurfaceDMA *cmd = (const SVGA3dCmdSurfaceDMA *)body;
1532         dump_SVGA3dCmdSurfaceDMA(cmd);
1533         body = (const uint8_t *)&cmd[1];
1534         while(body + sizeof(SVGA3dCopyBox) <= next) {
1535            dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
1536            body += sizeof(SVGA3dCopyBox);
1537         }
1538         while(body + sizeof(SVGA3dCmdSurfaceDMASuffix) <= next) {
1539            dump_SVGA3dCmdSurfaceDMASuffix((const SVGA3dCmdSurfaceDMASuffix *)body);
1540            body += sizeof(SVGA3dCmdSurfaceDMASuffix);
1541         }
1542      }
1543      break;
1544   case SVGA_3D_CMD_CONTEXT_DEFINE:
1545      _debug_printf("\tSVGA_3D_CMD_CONTEXT_DEFINE\n");
1546      {
1547         const SVGA3dCmdDefineContext *cmd = (const SVGA3dCmdDefineContext *)body;
1548         dump_SVGA3dCmdDefineContext(cmd);
1549         body = (const uint8_t *)&cmd[1];
1550      }
1551      break;
1552   case SVGA_3D_CMD_CONTEXT_DESTROY:
1553      _debug_printf("\tSVGA_3D_CMD_CONTEXT_DESTROY\n");
1554      {
1555         const SVGA3dCmdDestroyContext *cmd = (const SVGA3dCmdDestroyContext *)body;
1556         dump_SVGA3dCmdDestroyContext(cmd);
1557         body = (const uint8_t *)&cmd[1];
1558      }
1559      break;
1560   case SVGA_3D_CMD_SETTRANSFORM:
1561      _debug_printf("\tSVGA_3D_CMD_SETTRANSFORM\n");
1562      {
1563         const SVGA3dCmdSetTransform *cmd = (const SVGA3dCmdSetTransform *)body;
1564         dump_SVGA3dCmdSetTransform(cmd);
1565         body = (const uint8_t *)&cmd[1];
1566      }
1567      break;
1568   case SVGA_3D_CMD_SETZRANGE:
1569      _debug_printf("\tSVGA_3D_CMD_SETZRANGE\n");
1570      {
1571         const SVGA3dCmdSetZRange *cmd = (const SVGA3dCmdSetZRange *)body;
1572         dump_SVGA3dCmdSetZRange(cmd);
1573         body = (const uint8_t *)&cmd[1];
1574      }
1575      break;
1576   case SVGA_3D_CMD_SETRENDERSTATE:
1577      _debug_printf("\tSVGA_3D_CMD_SETRENDERSTATE\n");
1578      {
1579         const SVGA3dCmdSetRenderState *cmd = (const SVGA3dCmdSetRenderState *)body;
1580         dump_SVGA3dCmdSetRenderState(cmd);
1581         body = (const uint8_t *)&cmd[1];
1582         while(body + sizeof(SVGA3dRenderState) <= next) {
1583            dump_SVGA3dRenderState((const SVGA3dRenderState *)body);
1584            body += sizeof(SVGA3dRenderState);
1585         }
1586      }
1587      break;
1588   case SVGA_3D_CMD_SETRENDERTARGET:
1589      _debug_printf("\tSVGA_3D_CMD_SETRENDERTARGET\n");
1590      {
1591         const SVGA3dCmdSetRenderTarget *cmd = (const SVGA3dCmdSetRenderTarget *)body;
1592         dump_SVGA3dCmdSetRenderTarget(cmd);
1593         body = (const uint8_t *)&cmd[1];
1594      }
1595      break;
1596   case SVGA_3D_CMD_SETTEXTURESTATE:
1597      _debug_printf("\tSVGA_3D_CMD_SETTEXTURESTATE\n");
1598      {
1599         const SVGA3dCmdSetTextureState *cmd = (const SVGA3dCmdSetTextureState *)body;
1600         dump_SVGA3dCmdSetTextureState(cmd);
1601         body = (const uint8_t *)&cmd[1];
1602         while(body + sizeof(SVGA3dTextureState) <= next) {
1603            dump_SVGA3dTextureState((const SVGA3dTextureState *)body);
1604            body += sizeof(SVGA3dTextureState);
1605         }
1606      }
1607      break;
1608   case SVGA_3D_CMD_SETMATERIAL:
1609      _debug_printf("\tSVGA_3D_CMD_SETMATERIAL\n");
1610      {
1611         const SVGA3dCmdSetMaterial *cmd = (const SVGA3dCmdSetMaterial *)body;
1612         dump_SVGA3dCmdSetMaterial(cmd);
1613         body = (const uint8_t *)&cmd[1];
1614      }
1615      break;
1616   case SVGA_3D_CMD_SETLIGHTDATA:
1617      _debug_printf("\tSVGA_3D_CMD_SETLIGHTDATA\n");
1618      {
1619         const SVGA3dCmdSetLightData *cmd = (const SVGA3dCmdSetLightData *)body;
1620         dump_SVGA3dCmdSetLightData(cmd);
1621         body = (const uint8_t *)&cmd[1];
1622      }
1623      break;
1624   case SVGA_3D_CMD_SETLIGHTENABLED:
1625      _debug_printf("\tSVGA_3D_CMD_SETLIGHTENABLED\n");
1626      {
1627         const SVGA3dCmdSetLightEnabled *cmd = (const SVGA3dCmdSetLightEnabled *)body;
1628         dump_SVGA3dCmdSetLightEnabled(cmd);
1629         body = (const uint8_t *)&cmd[1];
1630      }
1631      break;
1632   case SVGA_3D_CMD_SETVIEWPORT:
1633      _debug_printf("\tSVGA_3D_CMD_SETVIEWPORT\n");
1634      {
1635         const SVGA3dCmdSetViewport *cmd = (const SVGA3dCmdSetViewport *)body;
1636         dump_SVGA3dCmdSetViewport(cmd);
1637         body = (const uint8_t *)&cmd[1];
1638      }
1639      break;
1640   case SVGA_3D_CMD_SETCLIPPLANE:
1641      _debug_printf("\tSVGA_3D_CMD_SETCLIPPLANE\n");
1642      {
1643         const SVGA3dCmdSetClipPlane *cmd = (const SVGA3dCmdSetClipPlane *)body;
1644         dump_SVGA3dCmdSetClipPlane(cmd);
1645         body = (const uint8_t *)&cmd[1];
1646      }
1647      break;
1648   case SVGA_3D_CMD_CLEAR:
1649      _debug_printf("\tSVGA_3D_CMD_CLEAR\n");
1650      {
1651         const SVGA3dCmdClear *cmd = (const SVGA3dCmdClear *)body;
1652         dump_SVGA3dCmdClear(cmd);
1653         body = (const uint8_t *)&cmd[1];
1654         while(body + sizeof(SVGA3dRect) <= next) {
1655            dump_SVGA3dRect((const SVGA3dRect *)body);
1656            body += sizeof(SVGA3dRect);
1657         }
1658      }
1659      break;
1660   case SVGA_3D_CMD_PRESENT:
1661      _debug_printf("\tSVGA_3D_CMD_PRESENT\n");
1662      {
1663         const SVGA3dCmdPresent *cmd = (const SVGA3dCmdPresent *)body;
1664         dump_SVGA3dCmdPresent(cmd);
1665         body = (const uint8_t *)&cmd[1];
1666         while(body + sizeof(SVGA3dCopyRect) <= next) {
1667            dump_SVGA3dCopyRect((const SVGA3dCopyRect *)body);
1668            body += sizeof(SVGA3dCopyRect);
1669         }
1670      }
1671      break;
1672   case SVGA_3D_CMD_SHADER_DEFINE:
1673      _debug_printf("\tSVGA_3D_CMD_SHADER_DEFINE\n");
1674      {
1675         const SVGA3dCmdDefineShader *cmd = (const SVGA3dCmdDefineShader *)body;
1676         dump_SVGA3dCmdDefineShader(cmd);
1677         body = (const uint8_t *)&cmd[1];
1678         svga_shader_dump((const uint32_t *)body,
1679                      (unsigned)(next - body)/sizeof(uint32_t),
1680                      FALSE );
1681         body = next;
1682      }
1683      break;
1684   case SVGA_3D_CMD_SHADER_DESTROY:
1685      _debug_printf("\tSVGA_3D_CMD_SHADER_DESTROY\n");
1686      {
1687         const SVGA3dCmdDestroyShader *cmd = (const SVGA3dCmdDestroyShader *)body;
1688         dump_SVGA3dCmdDestroyShader(cmd);
1689         body = (const uint8_t *)&cmd[1];
1690      }
1691      break;
1692   case SVGA_3D_CMD_SET_SHADER:
1693      _debug_printf("\tSVGA_3D_CMD_SET_SHADER\n");
1694      {
1695         const SVGA3dCmdSetShader *cmd = (const SVGA3dCmdSetShader *)body;
1696         dump_SVGA3dCmdSetShader(cmd);
1697         body = (const uint8_t *)&cmd[1];
1698      }
1699      break;
1700   case SVGA_3D_CMD_SET_SHADER_CONST:
1701      _debug_printf("\tSVGA_3D_CMD_SET_SHADER_CONST\n");
1702      {
1703         const SVGA3dCmdSetShaderConst *cmd = (const SVGA3dCmdSetShaderConst *)body;
1704         uint32 numConsts = 1 + (size - sizeof *cmd) / (4 * sizeof(uint32));
1705         dump_SVGA3dCmdSetShaderConst(cmd, numConsts);
1706         body = next;
1707      }
1708      break;
1709   case SVGA_3D_CMD_DRAW_PRIMITIVES:
1710      _debug_printf("\tSVGA_3D_CMD_DRAW_PRIMITIVES\n");
1711      {
1712         const SVGA3dCmdDrawPrimitives *cmd = (const SVGA3dCmdDrawPrimitives *)body;
1713         unsigned i, j;
1714         dump_SVGA3dCmdDrawPrimitives(cmd);
1715         body = (const uint8_t *)&cmd[1];
1716         for(i = 0; i < cmd->numVertexDecls; ++i) {
1717            dump_SVGA3dVertexDecl((const SVGA3dVertexDecl *)body);
1718            body += sizeof(SVGA3dVertexDecl);
1719         }
1720         for(j = 0; j < cmd->numRanges; ++j) {
1721            dump_SVGA3dPrimitiveRange((const SVGA3dPrimitiveRange *)body);
1722            body += sizeof(SVGA3dPrimitiveRange);
1723         }
1724         while(body + sizeof(SVGA3dVertexDivisor) <= next) {
1725            dump_SVGA3dVertexDivisor((const SVGA3dVertexDivisor *)body);
1726            body += sizeof(SVGA3dVertexDivisor);
1727         }
1728      }
1729      break;
1730   case SVGA_3D_CMD_SETSCISSORRECT:
1731      _debug_printf("\tSVGA_3D_CMD_SETSCISSORRECT\n");
1732      {
1733         const SVGA3dCmdSetScissorRect *cmd = (const SVGA3dCmdSetScissorRect *)body;
1734         dump_SVGA3dCmdSetScissorRect(cmd);
1735         body = (const uint8_t *)&cmd[1];
1736      }
1737      break;
1738   case SVGA_3D_CMD_BEGIN_QUERY:
1739      _debug_printf("\tSVGA_3D_CMD_BEGIN_QUERY\n");
1740      {
1741         const SVGA3dCmdBeginQuery *cmd = (const SVGA3dCmdBeginQuery *)body;
1742         dump_SVGA3dCmdBeginQuery(cmd);
1743         body = (const uint8_t *)&cmd[1];
1744      }
1745      break;
1746   case SVGA_3D_CMD_END_QUERY:
1747      _debug_printf("\tSVGA_3D_CMD_END_QUERY\n");
1748      {
1749         const SVGA3dCmdEndQuery *cmd = (const SVGA3dCmdEndQuery *)body;
1750         dump_SVGA3dCmdEndQuery(cmd);
1751         body = (const uint8_t *)&cmd[1];
1752      }
1753      break;
1754   case SVGA_3D_CMD_WAIT_FOR_QUERY:
1755      _debug_printf("\tSVGA_3D_CMD_WAIT_FOR_QUERY\n");
1756      {
1757         const SVGA3dCmdWaitForQuery *cmd = (const SVGA3dCmdWaitForQuery *)body;
1758         dump_SVGA3dCmdWaitForQuery(cmd);
1759         body = (const uint8_t *)&cmd[1];
1760      }
1761      break;
1762   case SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN:
1763      _debug_printf("\tSVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN\n");
1764      {
1765         const SVGA3dCmdBlitSurfaceToScreen *cmd = (const SVGA3dCmdBlitSurfaceToScreen *)body;
1766         dump_SVGA3dCmdBlitSurfaceToScreen(cmd);
1767         body = (const uint8_t *)&cmd[1];
1768         while(body + sizeof(SVGASignedRect) <= next) {
1769            dump_SVGASignedRect((const SVGASignedRect *)body);
1770            body += sizeof(SVGASignedRect);
1771         }
1772      }
1773      break;
1774   default:
1775      _debug_printf("\t0x%08x\n", cmd_id);
1776      break;
1777   }
1778
1779   while(body + sizeof(uint32_t) <= next) {
1780      _debug_printf("\t\t0x%08x\n", *(const uint32_t *)body);
1781      body += sizeof(uint32_t);
1782   }
1783   while(body + sizeof(uint32_t) <= next)
1784      _debug_printf("\t\t0x%02x\n", *body++);
1785}
1786
1787
1788void
1789svga_dump_commands(const void *commands, uint32_t size)
1790{
1791   const uint8_t *next = commands;
1792   const uint8_t *last = next + size;
1793
1794   assert(size % sizeof(uint32_t) == 0);
1795
1796   while(next < last) {
1797      const uint32_t cmd_id = *(const uint32_t *)next;
1798
1799      if(SVGA_3D_CMD_BASE <= cmd_id && cmd_id < SVGA_3D_CMD_MAX) {
1800         const SVGA3dCmdHeader *header = (const SVGA3dCmdHeader *)next;
1801         const uint8_t *body = (const uint8_t *)&header[1];
1802
1803         next = body + header->size;
1804         if(next > last)
1805            break;
1806
1807         svga_dump_command(cmd_id, body, header->size);
1808      }
1809      else if(cmd_id == SVGA_CMD_FENCE) {
1810         _debug_printf("\tSVGA_CMD_FENCE\n");
1811         _debug_printf("\t\t0x%08x\n", ((const uint32_t *)next)[1]);
1812         next += 2*sizeof(uint32_t);
1813      }
1814      else {
1815         _debug_printf("\t0x%08x\n", cmd_id);
1816         next += sizeof(uint32_t);
1817      }
1818   }
1819}
1820
1821