src/gallium/drivers/svga/svgadump/svga_dump.c

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