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