projects / mesa.git / blob
? search:


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