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