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