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