Subversion Repositories Kolibri OS

Rev

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