Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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