projects / mesa.git / blob
? search:


7feb5e14c5756dddb0ae20b7d06e6f1fe2fb1a1c
[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 void
41 dump_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
186 static void
187 dump_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
292 static void
293 dump_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
306 static void
307 dump_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
317 static void
318 dump_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
336 static void
337 dump_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
356 static void
357 dump_SVGA3dCmdSetTextureState(const SVGA3dCmdSetTextureState *cmd)
358 {
359 _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
360 }
361
362 static void
363 dump_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
373 static void
374 dump_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
419 static void
420 dump_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
477 static void
478 dump_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
487 static void
488 dump_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
497 static void
498 dump_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
508 static void
509 dump_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
529 static void
530 dump_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
548 static void
549 dump_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
556 static void
557 dump_SVGA3dCmdDestroySurface(const SVGA3dCmdDestroySurface *cmd)
558 {
559 _debug_printf("\t\t.sid = %u\n", (*cmd).sid);
560 }
561
562 static void
563 dump_SVGA3dCmdDefineContext(const SVGA3dCmdDefineContext *cmd)
564 {
565 _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
566 }
567
568 static void
569 dump_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
577 static void
578 dump_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
594 static void
595 dump_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
900 static void
901 dump_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
909 static void
910 dump_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
930 static void
931 dump_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
1004 static void
1005 dump_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
1012 static void
1013 dump_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
1020 static void
1021 dump_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
1028 static void
1029 dump_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
1068 static void
1069 dump_SVGA3dCmdPresent(const SVGA3dCmdPresent *cmd)
1070 {
1071 _debug_printf("\t\t.sid = %u\n", (*cmd).sid);
1072 }
1073
1074 static void
1075 dump_SVGA3dCmdSetRenderState(const SVGA3dCmdSetRenderState *cmd)
1076 {
1077 _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1078 }
1079
1080 static void
1081 dump_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
1117 static void
1118 dump_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
1139 static void
1140 dump_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
1148 static void
1149 dump_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
1223 static void
1224 dump_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
1244 static void
1245 dump_SVGA3dCmdDestroyContext(const SVGA3dCmdDestroyContext *cmd)
1246 {
1247 _debug_printf("\t\t.cid = %u\n", (*cmd).cid);
1248 }
1249
1250 static void
1251 dump_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
1273 static void
1274 dump_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 default:
1434 _debug_printf("\t\t.format = %i\n", (*cmd).format);
1435 break;
1436 }
1437 _debug_printf("\t\t.face[0].numMipLevels = %u\n", (*cmd).face[0].numMipLevels);
1438 _debug_printf("\t\t.face[1].numMipLevels = %u\n", (*cmd).face[1].numMipLevels);
1439 _debug_printf("\t\t.face[2].numMipLevels = %u\n", (*cmd).face[2].numMipLevels);
1440 _debug_printf("\t\t.face[3].numMipLevels = %u\n", (*cmd).face[3].numMipLevels);
1441 _debug_printf("\t\t.face[4].numMipLevels = %u\n", (*cmd).face[4].numMipLevels);
1442 _debug_printf("\t\t.face[5].numMipLevels = %u\n", (*cmd).face[5].numMipLevels);
1443 }
1444
1445 static void
1446 dump_SVGASignedRect(const SVGASignedRect *cmd)
1447 {
1448 _debug_printf("\t\t.left = %i\n", (*cmd).left);
1449 _debug_printf("\t\t.top = %i\n", (*cmd).top);
1450 _debug_printf("\t\t.right = %i\n", (*cmd).right);
1451 _debug_printf("\t\t.bottom = %i\n", (*cmd).bottom);
1452 }
1453
1454 static void
1455 dump_SVGA3dCmdBlitSurfaceToScreen(const SVGA3dCmdBlitSurfaceToScreen *cmd)
1456 {
1457 _debug_printf("\t\t.srcImage.sid = %u\n", (*cmd).srcImage.sid);
1458 _debug_printf("\t\t.srcImage.face = %u\n", (*cmd).srcImage.face);
1459 _debug_printf("\t\t.srcImage.mipmap = %u\n", (*cmd).srcImage.mipmap);
1460 _debug_printf("\t\t.srcRect.left = %i\n", (*cmd).srcRect.left);
1461 _debug_printf("\t\t.srcRect.top = %i\n", (*cmd).srcRect.top);
1462 _debug_printf("\t\t.srcRect.right = %i\n", (*cmd).srcRect.right);
1463 _debug_printf("\t\t.srcRect.bottom = %i\n", (*cmd).srcRect.bottom);
1464 _debug_printf("\t\t.destScreenId = %u\n", (*cmd).destScreenId);
1465 _debug_printf("\t\t.destRect.left = %i\n", (*cmd).destRect.left);
1466 _debug_printf("\t\t.destRect.top = %i\n", (*cmd).destRect.top);
1467 _debug_printf("\t\t.destRect.right = %i\n", (*cmd).destRect.right);
1468 _debug_printf("\t\t.destRect.bottom = %i\n", (*cmd).destRect.bottom);
1469 }
1470
1471
1472 void
1473 svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size)
1474 {
1475 const uint8_t *body = (const uint8_t *)data;
1476 const uint8_t *next = body + size;
1477
1478 switch(cmd_id) {
1479 case SVGA_3D_CMD_SURFACE_DEFINE:
1480 _debug_printf("\tSVGA_3D_CMD_SURFACE_DEFINE\n");
1481 {
1482 const SVGA3dCmdDefineSurface *cmd = (const SVGA3dCmdDefineSurface *)body;
1483 dump_SVGA3dCmdDefineSurface(cmd);
1484 body = (const uint8_t *)&cmd[1];
1485 while(body + sizeof(SVGA3dSize) <= next) {
1486 dump_SVGA3dSize((const SVGA3dSize *)body);
1487 body += sizeof(SVGA3dSize);
1488 }
1489 }
1490 break;
1491 case SVGA_3D_CMD_SURFACE_DESTROY:
1492 _debug_printf("\tSVGA_3D_CMD_SURFACE_DESTROY\n");
1493 {
1494 const SVGA3dCmdDestroySurface *cmd = (const SVGA3dCmdDestroySurface *)body;
1495 dump_SVGA3dCmdDestroySurface(cmd);
1496 body = (const uint8_t *)&cmd[1];
1497 }
1498 break;
1499 case SVGA_3D_CMD_SURFACE_COPY:
1500 _debug_printf("\tSVGA_3D_CMD_SURFACE_COPY\n");
1501 {
1502 const SVGA3dCmdSurfaceCopy *cmd = (const SVGA3dCmdSurfaceCopy *)body;
1503 dump_SVGA3dCmdSurfaceCopy(cmd);
1504 body = (const uint8_t *)&cmd[1];
1505 while(body + sizeof(SVGA3dCopyBox) <= next) {
1506 dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
1507 body += sizeof(SVGA3dCopyBox);
1508 }
1509 }
1510 break;
1511 case SVGA_3D_CMD_SURFACE_STRETCHBLT:
1512 _debug_printf("\tSVGA_3D_CMD_SURFACE_STRETCHBLT\n");
1513 {
1514 const SVGA3dCmdSurfaceStretchBlt *cmd = (const SVGA3dCmdSurfaceStretchBlt *)body;
1515 dump_SVGA3dCmdSurfaceStretchBlt(cmd);
1516 body = (const uint8_t *)&cmd[1];
1517 }
1518 break;
1519 case SVGA_3D_CMD_SURFACE_DMA:
1520 _debug_printf("\tSVGA_3D_CMD_SURFACE_DMA\n");
1521 {
1522 const SVGA3dCmdSurfaceDMA *cmd = (const SVGA3dCmdSurfaceDMA *)body;
1523 dump_SVGA3dCmdSurfaceDMA(cmd);
1524 body = (const uint8_t *)&cmd[1];
1525 while(body + sizeof(SVGA3dCopyBox) <= next) {
1526 dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
1527 body += sizeof(SVGA3dCopyBox);
1528 }
1529 while(body + sizeof(SVGA3dCmdSurfaceDMASuffix) <= next) {
1530 dump_SVGA3dCmdSurfaceDMASuffix((const SVGA3dCmdSurfaceDMASuffix *)body);
1531 body += sizeof(SVGA3dCmdSurfaceDMASuffix);
1532 }
1533 }
1534 break;
1535 case SVGA_3D_CMD_CONTEXT_DEFINE:
1536 _debug_printf("\tSVGA_3D_CMD_CONTEXT_DEFINE\n");
1537 {
1538 const SVGA3dCmdDefineContext *cmd = (const SVGA3dCmdDefineContext *)body;
1539 dump_SVGA3dCmdDefineContext(cmd);
1540 body = (const uint8_t *)&cmd[1];
1541 }
1542 break;
1543 case SVGA_3D_CMD_CONTEXT_DESTROY:
1544 _debug_printf("\tSVGA_3D_CMD_CONTEXT_DESTROY\n");
1545 {
1546 const SVGA3dCmdDestroyContext *cmd = (const SVGA3dCmdDestroyContext *)body;
1547 dump_SVGA3dCmdDestroyContext(cmd);
1548 body = (const uint8_t *)&cmd[1];
1549 }
1550 break;
1551 case SVGA_3D_CMD_SETTRANSFORM:
1552 _debug_printf("\tSVGA_3D_CMD_SETTRANSFORM\n");
1553 {
1554 const SVGA3dCmdSetTransform *cmd = (const SVGA3dCmdSetTransform *)body;
1555 dump_SVGA3dCmdSetTransform(cmd);
1556 body = (const uint8_t *)&cmd[1];
1557 }
1558 break;
1559 case SVGA_3D_CMD_SETZRANGE:
1560 _debug_printf("\tSVGA_3D_CMD_SETZRANGE\n");
1561 {
1562 const SVGA3dCmdSetZRange *cmd = (const SVGA3dCmdSetZRange *)body;
1563 dump_SVGA3dCmdSetZRange(cmd);
1564 body = (const uint8_t *)&cmd[1];
1565 }
1566 break;
1567 case SVGA_3D_CMD_SETRENDERSTATE:
1568 _debug_printf("\tSVGA_3D_CMD_SETRENDERSTATE\n");
1569 {
1570 const SVGA3dCmdSetRenderState *cmd = (const SVGA3dCmdSetRenderState *)body;
1571 dump_SVGA3dCmdSetRenderState(cmd);
1572 body = (const uint8_t *)&cmd[1];
1573 while(body + sizeof(SVGA3dRenderState) <= next) {
1574 dump_SVGA3dRenderState((const SVGA3dRenderState *)body);
1575 body += sizeof(SVGA3dRenderState);
1576 }
1577 }
1578 break;
1579 case SVGA_3D_CMD_SETRENDERTARGET:
1580 _debug_printf("\tSVGA_3D_CMD_SETRENDERTARGET\n");
1581 {
1582 const SVGA3dCmdSetRenderTarget *cmd = (const SVGA3dCmdSetRenderTarget *)body;
1583 dump_SVGA3dCmdSetRenderTarget(cmd);
1584 body = (const uint8_t *)&cmd[1];
1585 }
1586 break;
1587 case SVGA_3D_CMD_SETTEXTURESTATE:
1588 _debug_printf("\tSVGA_3D_CMD_SETTEXTURESTATE\n");
1589 {
1590 const SVGA3dCmdSetTextureState *cmd = (const SVGA3dCmdSetTextureState *)body;
1591 dump_SVGA3dCmdSetTextureState(cmd);
1592 body = (const uint8_t *)&cmd[1];
1593 while(body + sizeof(SVGA3dTextureState) <= next) {
1594 dump_SVGA3dTextureState((const SVGA3dTextureState *)body);
1595 body += sizeof(SVGA3dTextureState);
1596 }
1597 }
1598 break;
1599 case SVGA_3D_CMD_SETMATERIAL:
1600 _debug_printf("\tSVGA_3D_CMD_SETMATERIAL\n");
1601 {
1602 const SVGA3dCmdSetMaterial *cmd = (const SVGA3dCmdSetMaterial *)body;
1603 dump_SVGA3dCmdSetMaterial(cmd);
1604 body = (const uint8_t *)&cmd[1];
1605 }
1606 break;
1607 case SVGA_3D_CMD_SETLIGHTDATA:
1608 _debug_printf("\tSVGA_3D_CMD_SETLIGHTDATA\n");
1609 {
1610 const SVGA3dCmdSetLightData *cmd = (const SVGA3dCmdSetLightData *)body;
1611 dump_SVGA3dCmdSetLightData(cmd);
1612 body = (const uint8_t *)&cmd[1];
1613 }
1614 break;
1615 case SVGA_3D_CMD_SETLIGHTENABLED:
1616 _debug_printf("\tSVGA_3D_CMD_SETLIGHTENABLED\n");
1617 {
1618 const SVGA3dCmdSetLightEnabled *cmd = (const SVGA3dCmdSetLightEnabled *)body;
1619 dump_SVGA3dCmdSetLightEnabled(cmd);
1620 body = (const uint8_t *)&cmd[1];
1621 }
1622 break;
1623 case SVGA_3D_CMD_SETVIEWPORT:
1624 _debug_printf("\tSVGA_3D_CMD_SETVIEWPORT\n");
1625 {
1626 const SVGA3dCmdSetViewport *cmd = (const SVGA3dCmdSetViewport *)body;
1627 dump_SVGA3dCmdSetViewport(cmd);
1628 body = (const uint8_t *)&cmd[1];
1629 }
1630 break;
1631 case SVGA_3D_CMD_SETCLIPPLANE:
1632 _debug_printf("\tSVGA_3D_CMD_SETCLIPPLANE\n");
1633 {
1634 const SVGA3dCmdSetClipPlane *cmd = (const SVGA3dCmdSetClipPlane *)body;
1635 dump_SVGA3dCmdSetClipPlane(cmd);
1636 body = (const uint8_t *)&cmd[1];
1637 }
1638 break;
1639 case SVGA_3D_CMD_CLEAR:
1640 _debug_printf("\tSVGA_3D_CMD_CLEAR\n");
1641 {
1642 const SVGA3dCmdClear *cmd = (const SVGA3dCmdClear *)body;
1643 dump_SVGA3dCmdClear(cmd);
1644 body = (const uint8_t *)&cmd[1];
1645 while(body + sizeof(SVGA3dRect) <= next) {
1646 dump_SVGA3dRect((const SVGA3dRect *)body);
1647 body += sizeof(SVGA3dRect);
1648 }
1649 }
1650 break;
1651 case SVGA_3D_CMD_PRESENT:
1652 _debug_printf("\tSVGA_3D_CMD_PRESENT\n");
1653 {
1654 const SVGA3dCmdPresent *cmd = (const SVGA3dCmdPresent *)body;
1655 dump_SVGA3dCmdPresent(cmd);
1656 body = (const uint8_t *)&cmd[1];
1657 while(body + sizeof(SVGA3dCopyRect) <= next) {
1658 dump_SVGA3dCopyRect((const SVGA3dCopyRect *)body);
1659 body += sizeof(SVGA3dCopyRect);
1660 }
1661 }
1662 break;
1663 case SVGA_3D_CMD_SHADER_DEFINE:
1664 _debug_printf("\tSVGA_3D_CMD_SHADER_DEFINE\n");
1665 {
1666 const SVGA3dCmdDefineShader *cmd = (const SVGA3dCmdDefineShader *)body;
1667 dump_SVGA3dCmdDefineShader(cmd);
1668 body = (const uint8_t *)&cmd[1];
1669 svga_shader_dump((const uint32_t *)body,
1670 (unsigned)(next - body)/sizeof(uint32_t),
1671 FALSE );
1672 body = next;
1673 }
1674 break;
1675 case SVGA_3D_CMD_SHADER_DESTROY:
1676 _debug_printf("\tSVGA_3D_CMD_SHADER_DESTROY\n");
1677 {
1678 const SVGA3dCmdDestroyShader *cmd = (const SVGA3dCmdDestroyShader *)body;
1679 dump_SVGA3dCmdDestroyShader(cmd);
1680 body = (const uint8_t *)&cmd[1];
1681 }
1682 break;
1683 case SVGA_3D_CMD_SET_SHADER:
1684 _debug_printf("\tSVGA_3D_CMD_SET_SHADER\n");
1685 {
1686 const SVGA3dCmdSetShader *cmd = (const SVGA3dCmdSetShader *)body;
1687 dump_SVGA3dCmdSetShader(cmd);
1688 body = (const uint8_t *)&cmd[1];
1689 }
1690 break;
1691 case SVGA_3D_CMD_SET_SHADER_CONST:
1692 _debug_printf("\tSVGA_3D_CMD_SET_SHADER_CONST\n");
1693 {
1694 const SVGA3dCmdSetShaderConst *cmd = (const SVGA3dCmdSetShaderConst *)body;
1695 uint32 numConsts = 1 + (size - sizeof *cmd) / (4 * sizeof(uint32));
1696 dump_SVGA3dCmdSetShaderConst(cmd, numConsts);
1697 body = next;
1698 }
1699 break;
1700 case SVGA_3D_CMD_DRAW_PRIMITIVES:
1701 _debug_printf("\tSVGA_3D_CMD_DRAW_PRIMITIVES\n");
1702 {
1703 const SVGA3dCmdDrawPrimitives *cmd = (const SVGA3dCmdDrawPrimitives *)body;
1704 unsigned i, j;
1705 dump_SVGA3dCmdDrawPrimitives(cmd);
1706 body = (const uint8_t *)&cmd[1];
1707 for(i = 0; i < cmd->numVertexDecls; ++i) {
1708 dump_SVGA3dVertexDecl((const SVGA3dVertexDecl *)body);
1709 body += sizeof(SVGA3dVertexDecl);
1710 }
1711 for(j = 0; j < cmd->numRanges; ++j) {
1712 dump_SVGA3dPrimitiveRange((const SVGA3dPrimitiveRange *)body);
1713 body += sizeof(SVGA3dPrimitiveRange);
1714 }
1715 while(body + sizeof(SVGA3dVertexDivisor) <= next) {
1716 dump_SVGA3dVertexDivisor((const SVGA3dVertexDivisor *)body);
1717 body += sizeof(SVGA3dVertexDivisor);
1718 }
1719 }
1720 break;
1721 case SVGA_3D_CMD_SETSCISSORRECT:
1722 _debug_printf("\tSVGA_3D_CMD_SETSCISSORRECT\n");
1723 {
1724 const SVGA3dCmdSetScissorRect *cmd = (const SVGA3dCmdSetScissorRect *)body;
1725 dump_SVGA3dCmdSetScissorRect(cmd);
1726 body = (const uint8_t *)&cmd[1];
1727 }
1728 break;
1729 case SVGA_3D_CMD_BEGIN_QUERY:
1730 _debug_printf("\tSVGA_3D_CMD_BEGIN_QUERY\n");
1731 {
1732 const SVGA3dCmdBeginQuery *cmd = (const SVGA3dCmdBeginQuery *)body;
1733 dump_SVGA3dCmdBeginQuery(cmd);
1734 body = (const uint8_t *)&cmd[1];
1735 }
1736 break;
1737 case SVGA_3D_CMD_END_QUERY:
1738 _debug_printf("\tSVGA_3D_CMD_END_QUERY\n");
1739 {
1740 const SVGA3dCmdEndQuery *cmd = (const SVGA3dCmdEndQuery *)body;
1741 dump_SVGA3dCmdEndQuery(cmd);
1742 body = (const uint8_t *)&cmd[1];
1743 }
1744 break;
1745 case SVGA_3D_CMD_WAIT_FOR_QUERY:
1746 _debug_printf("\tSVGA_3D_CMD_WAIT_FOR_QUERY\n");
1747 {
1748 const SVGA3dCmdWaitForQuery *cmd = (const SVGA3dCmdWaitForQuery *)body;
1749 dump_SVGA3dCmdWaitForQuery(cmd);
1750 body = (const uint8_t *)&cmd[1];
1751 }
1752 break;
1753 case SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN:
1754 _debug_printf("\tSVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN\n");
1755 {
1756 const SVGA3dCmdBlitSurfaceToScreen *cmd = (const SVGA3dCmdBlitSurfaceToScreen *)body;
1757 dump_SVGA3dCmdBlitSurfaceToScreen(cmd);
1758 body = (const uint8_t *)&cmd[1];
1759 while(body + sizeof(SVGASignedRect) <= next) {
1760 dump_SVGASignedRect((const SVGASignedRect *)body);
1761 body += sizeof(SVGASignedRect);
1762 }
1763 }
1764 break;
1765 default:
1766 _debug_printf("\t0x%08x\n", cmd_id);
1767 break;
1768 }
1769
1770 while(body + sizeof(uint32_t) <= next) {
1771 _debug_printf("\t\t0x%08x\n", *(const uint32_t *)body);
1772 body += sizeof(uint32_t);
1773 }
1774 while(body + sizeof(uint32_t) <= next)
1775 _debug_printf("\t\t0x%02x\n", *body++);
1776 }
1777
1778
1779 void
1780 svga_dump_commands(const void *commands, uint32_t size)
1781 {
1782 const uint8_t *next = commands;
1783 const uint8_t *last = next + size;
1784
1785 assert(size % sizeof(uint32_t) == 0);
1786
1787 while(next < last) {
1788 const uint32_t cmd_id = *(const uint32_t *)next;
1789
1790 if(SVGA_3D_CMD_BASE <= cmd_id && cmd_id < SVGA_3D_CMD_MAX) {
1791 const SVGA3dCmdHeader *header = (const SVGA3dCmdHeader *)next;
1792 const uint8_t *body = (const uint8_t *)&header[1];
1793
1794 next = body + header->size;
1795 if(next > last)
1796 break;
1797
1798 svga_dump_command(cmd_id, body, header->size);
1799 }
1800 else if(cmd_id == SVGA_CMD_FENCE) {
1801 _debug_printf("\tSVGA_CMD_FENCE\n");
1802 _debug_printf("\t\t0x%08x\n", ((const uint32_t *)next)[1]);
1803 next += 2*sizeof(uint32_t);
1804 }
1805 else {
1806 _debug_printf("\t0x%08x\n", cmd_id);
1807 next += sizeof(uint32_t);
1808 }
1809 }
1810 }
1811