BlueGreycalmElegant

Català-Valencià – Catalan中文 – Chinese (Simplified)中文 – Chinese (Traditional)Česky – CzechDansk – DanishNederlands – DutchEnglish – EnglishSuomi – FinnishFrançais – FrenchDeutsch – Germanעברית – Hebrewहिंदी – HindiMagyar – HungarianBahasa Indonesia – IndonesianItaliano – Italian日本語 – Japanese한국어 – KoreanМакедонски – Macedonianमराठी – MarathiNorsk – NorwegianPolski – PolishPortuguês – PortuguesePortuguês – Portuguese (Brazil)Русский – RussianSlovenčina – SlovakSlovenščina – SlovenianEspañol – SpanishSvenska – SwedishTürkçe – TurkishУкраїнська – UkrainianOëzbekcha – Uzbek

Compare Revisions

• This comparison shows the changes necessary to convert path

  → /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/ @ 5563

  → /contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/ @ 5564

  ↔ Reverse comparison

• Compare Path:	Rev

  With Path:	Rev

Regard whitespace Rev 5563 → Rev 5564

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_dump.c
0,0 → 1,2044
/**********************************************************
* Copyright 2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
/**
* @file
* Dump SVGA commands.
*
* Generated automatically from svga3d_reg.h by svga_dump.py.
*/
#include "svga_types.h"
#include "svga_shader_dump.h"
#include "svga3d_reg.h"
#include "util/u_debug.h"
#include "svga_dump.h"
static const char *
shader_name(unsigned type)
{
switch (type) {
case SVGA3D_SHADERTYPE_VS:
return "SVGA3D_SHADERTYPE_VS";
case SVGA3D_SHADERTYPE_PS:
return "SVGA3D_SHADERTYPE_PS";
case SVGA3D_SHADERTYPE_GS:
return "SVGA3D_SHADERTYPE_GS";
default:
return "unknown shader type!";
}
}
static void
dump_SVGA3dVertexDecl(const SVGA3dVertexDecl *cmd)
{
switch((*cmd).identity.type) {
case SVGA3D_DECLTYPE_FLOAT1:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT1\n");
break;
case SVGA3D_DECLTYPE_FLOAT2:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT2\n");
break;
case SVGA3D_DECLTYPE_FLOAT3:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT3\n");
break;
case SVGA3D_DECLTYPE_FLOAT4:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT4\n");
break;
case SVGA3D_DECLTYPE_D3DCOLOR:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_D3DCOLOR\n");
break;
case SVGA3D_DECLTYPE_UBYTE4:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UBYTE4\n");
break;
case SVGA3D_DECLTYPE_SHORT2:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT2\n");
break;
case SVGA3D_DECLTYPE_SHORT4:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT4\n");
break;
case SVGA3D_DECLTYPE_UBYTE4N:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UBYTE4N\n");
break;
case SVGA3D_DECLTYPE_SHORT2N:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT2N\n");
break;
case SVGA3D_DECLTYPE_SHORT4N:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_SHORT4N\n");
break;
case SVGA3D_DECLTYPE_USHORT2N:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_USHORT2N\n");
break;
case SVGA3D_DECLTYPE_USHORT4N:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_USHORT4N\n");
break;
case SVGA3D_DECLTYPE_UDEC3:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_UDEC3\n");
break;
case SVGA3D_DECLTYPE_DEC3N:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_DEC3N\n");
break;
case SVGA3D_DECLTYPE_FLOAT16_2:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT16_2\n");
break;
case SVGA3D_DECLTYPE_FLOAT16_4:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_FLOAT16_4\n");
break;
case SVGA3D_DECLTYPE_MAX:
_debug_printf("\t\t.identity.type = SVGA3D_DECLTYPE_MAX\n");
break;
default:
_debug_printf("\t\t.identity.type = %i\n", (*cmd).identity.type);
break;
}
switch((*cmd).identity.method) {
case SVGA3D_DECLMETHOD_DEFAULT:
_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_DEFAULT\n");
break;
case SVGA3D_DECLMETHOD_PARTIALU:
_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_PARTIALU\n");
break;
case SVGA3D_DECLMETHOD_PARTIALV:
_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_PARTIALV\n");
break;
case SVGA3D_DECLMETHOD_CROSSUV:
_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_CROSSUV\n");
break;
case SVGA3D_DECLMETHOD_UV:
_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_UV\n");
break;
case SVGA3D_DECLMETHOD_LOOKUP:
_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_LOOKUP\n");
break;
case SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED:
_debug_printf("\t\t.identity.method = SVGA3D_DECLMETHOD_LOOKUPPRESAMPLED\n");
break;
default:
_debug_printf("\t\t.identity.method = %i\n", (*cmd).identity.method);
break;
}
switch((*cmd).identity.usage) {
case SVGA3D_DECLUSAGE_POSITION:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_POSITION\n");
break;
case SVGA3D_DECLUSAGE_BLENDWEIGHT:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BLENDWEIGHT\n");
break;
case SVGA3D_DECLUSAGE_BLENDINDICES:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BLENDINDICES\n");
break;
case SVGA3D_DECLUSAGE_NORMAL:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_NORMAL\n");
break;
case SVGA3D_DECLUSAGE_PSIZE:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_PSIZE\n");
break;
case SVGA3D_DECLUSAGE_TEXCOORD:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TEXCOORD\n");
break;
case SVGA3D_DECLUSAGE_TANGENT:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TANGENT\n");
break;
case SVGA3D_DECLUSAGE_BINORMAL:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_BINORMAL\n");
break;
case SVGA3D_DECLUSAGE_TESSFACTOR:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_TESSFACTOR\n");
break;
case SVGA3D_DECLUSAGE_POSITIONT:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_POSITIONT\n");
break;
case SVGA3D_DECLUSAGE_COLOR:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_COLOR\n");
break;
case SVGA3D_DECLUSAGE_FOG:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_FOG\n");
break;
case SVGA3D_DECLUSAGE_DEPTH:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_DEPTH\n");
break;
case SVGA3D_DECLUSAGE_SAMPLE:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_SAMPLE\n");
break;
case SVGA3D_DECLUSAGE_MAX:
_debug_printf("\t\t.identity.usage = SVGA3D_DECLUSAGE_MAX\n");
break;
default:
_debug_printf("\t\t.identity.usage = %i\n", (*cmd).identity.usage);
break;
}
_debug_printf("\t\t.identity.usageIndex = %u\n", (*cmd).identity.usageIndex);
_debug_printf("\t\t.array.surfaceId = %u\n", (*cmd).array.surfaceId);
_debug_printf("\t\t.array.offset = %u\n", (*cmd).array.offset);
_debug_printf("\t\t.array.stride = %u\n", (*cmd).array.stride);
_debug_printf("\t\t.rangeHint.first = %u\n", (*cmd).rangeHint.first);
_debug_printf("\t\t.rangeHint.last = %u\n", (*cmd).rangeHint.last);
}
static void
dump_SVGA3dTextureState(const SVGA3dTextureState *cmd)
{
_debug_printf("\t\t.stage = %u\n", (*cmd).stage);
switch((*cmd).name) {
case SVGA3D_TS_INVALID:
_debug_printf("\t\t.name = SVGA3D_TS_INVALID\n");
break;
case SVGA3D_TS_BIND_TEXTURE:
_debug_printf("\t\t.name = SVGA3D_TS_BIND_TEXTURE\n");
break;
case SVGA3D_TS_COLOROP:
_debug_printf("\t\t.name = SVGA3D_TS_COLOROP\n");
break;
case SVGA3D_TS_COLORARG1:
_debug_printf("\t\t.name = SVGA3D_TS_COLORARG1\n");
break;
case SVGA3D_TS_COLORARG2:
_debug_printf("\t\t.name = SVGA3D_TS_COLORARG2\n");
break;
case SVGA3D_TS_ALPHAOP:
_debug_printf("\t\t.name = SVGA3D_TS_ALPHAOP\n");
break;
case SVGA3D_TS_ALPHAARG1:
_debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG1\n");
break;
case SVGA3D_TS_ALPHAARG2:
_debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG2\n");
break;
case SVGA3D_TS_ADDRESSU:
_debug_printf("\t\t.name = SVGA3D_TS_ADDRESSU\n");
break;
case SVGA3D_TS_ADDRESSV:
_debug_printf("\t\t.name = SVGA3D_TS_ADDRESSV\n");
break;
case SVGA3D_TS_MIPFILTER:
_debug_printf("\t\t.name = SVGA3D_TS_MIPFILTER\n");
break;
case SVGA3D_TS_MAGFILTER:
_debug_printf("\t\t.name = SVGA3D_TS_MAGFILTER\n");
break;
case SVGA3D_TS_MINFILTER:
_debug_printf("\t\t.name = SVGA3D_TS_MINFILTER\n");
break;
case SVGA3D_TS_BORDERCOLOR:
_debug_printf("\t\t.name = SVGA3D_TS_BORDERCOLOR\n");
break;
case SVGA3D_TS_TEXCOORDINDEX:
_debug_printf("\t\t.name = SVGA3D_TS_TEXCOORDINDEX\n");
break;
case SVGA3D_TS_TEXTURETRANSFORMFLAGS:
_debug_printf("\t\t.name = SVGA3D_TS_TEXTURETRANSFORMFLAGS\n");
break;
case SVGA3D_TS_TEXCOORDGEN:
_debug_printf("\t\t.name = SVGA3D_TS_TEXCOORDGEN\n");
break;
case SVGA3D_TS_BUMPENVMAT00:
_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT00\n");
break;
case SVGA3D_TS_BUMPENVMAT01:
_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT01\n");
break;
case SVGA3D_TS_BUMPENVMAT10:
_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT10\n");
break;
case SVGA3D_TS_BUMPENVMAT11:
_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVMAT11\n");
break;
case SVGA3D_TS_TEXTURE_MIPMAP_LEVEL:
_debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_MIPMAP_LEVEL\n");
break;
case SVGA3D_TS_TEXTURE_LOD_BIAS:
_debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_LOD_BIAS\n");
break;
case SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL:
_debug_printf("\t\t.name = SVGA3D_TS_TEXTURE_ANISOTROPIC_LEVEL\n");
break;
case SVGA3D_TS_ADDRESSW:
_debug_printf("\t\t.name = SVGA3D_TS_ADDRESSW\n");
break;
case SVGA3D_TS_GAMMA:
_debug_printf("\t\t.name = SVGA3D_TS_GAMMA\n");
break;
case SVGA3D_TS_BUMPENVLSCALE:
_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVLSCALE\n");
break;
case SVGA3D_TS_BUMPENVLOFFSET:
_debug_printf("\t\t.name = SVGA3D_TS_BUMPENVLOFFSET\n");
break;
case SVGA3D_TS_COLORARG0:
_debug_printf("\t\t.name = SVGA3D_TS_COLORARG0\n");
break;
case SVGA3D_TS_ALPHAARG0:
_debug_printf("\t\t.name = SVGA3D_TS_ALPHAARG0\n");
break;
case SVGA3D_TS_MAX:
_debug_printf("\t\t.name = SVGA3D_TS_MAX\n");
break;
default:
_debug_printf("\t\t.name = %i\n", (*cmd).name);
break;
}
_debug_printf("\t\t.value = %u\n", (*cmd).value);
_debug_printf("\t\t.floatValue = %f\n", (*cmd).floatValue);
}
static void
dump_SVGA3dCopyBox(const SVGA3dCopyBox *cmd)
{
_debug_printf("\t\t.x = %u\n", (*cmd).x);
_debug_printf("\t\t.y = %u\n", (*cmd).y);
_debug_printf("\t\t.z = %u\n", (*cmd).z);
_debug_printf("\t\t.w = %u\n", (*cmd).w);
_debug_printf("\t\t.h = %u\n", (*cmd).h);
_debug_printf("\t\t.d = %u\n", (*cmd).d);
_debug_printf("\t\t.srcx = %u\n", (*cmd).srcx);
_debug_printf("\t\t.srcy = %u\n", (*cmd).srcy);
_debug_printf("\t\t.srcz = %u\n", (*cmd).srcz);
}
static void
dump_SVGA3dCmdSetClipPlane(const SVGA3dCmdSetClipPlane *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.index = %u\n", (*cmd).index);
_debug_printf("\t\t.plane[0] = %f\n", (*cmd).plane[0]);
_debug_printf("\t\t.plane[1] = %f\n", (*cmd).plane[1]);
_debug_printf("\t\t.plane[2] = %f\n", (*cmd).plane[2]);
_debug_printf("\t\t.plane[3] = %f\n", (*cmd).plane[3]);
}
static void
dump_SVGA3dCmdWaitForQuery(const SVGA3dCmdWaitForQuery *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
switch((*cmd).type) {
case SVGA3D_QUERYTYPE_OCCLUSION:
_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
break;
case SVGA3D_QUERYTYPE_MAX:
_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
break;
default:
_debug_printf("\t\t.type = %i\n", (*cmd).type);
break;
}
_debug_printf("\t\t.guestResult.gmrId = %u\n", (*cmd).guestResult.gmrId);
_debug_printf("\t\t.guestResult.offset = %u\n", (*cmd).guestResult.offset);
}
static void
dump_SVGA3dCmdSetRenderTarget(const SVGA3dCmdSetRenderTarget *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
switch((*cmd).type) {
case SVGA3D_RT_DEPTH:
_debug_printf("\t\t.type = SVGA3D_RT_DEPTH\n");
break;
case SVGA3D_RT_STENCIL:
_debug_printf("\t\t.type = SVGA3D_RT_STENCIL\n");
break;
default:
_debug_printf("\t\t.type = SVGA3D_RT_COLOR%u\n", (*cmd).type - SVGA3D_RT_COLOR0);
break;
}
_debug_printf("\t\t.target.sid = %u\n", (*cmd).target.sid);
_debug_printf("\t\t.target.face = %u\n", (*cmd).target.face);
_debug_printf("\t\t.target.mipmap = %u\n", (*cmd).target.mipmap);
}
static void
dump_SVGA3dCmdSetTextureState(const SVGA3dCmdSetTextureState *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
}
static void
dump_SVGA3dCmdSurfaceCopy(const SVGA3dCmdSurfaceCopy *cmd)
{
_debug_printf("\t\t.src.sid = %u\n", (*cmd).src.sid);
_debug_printf("\t\t.src.face = %u\n", (*cmd).src.face);
_debug_printf("\t\t.src.mipmap = %u\n", (*cmd).src.mipmap);
_debug_printf("\t\t.dest.sid = %u\n", (*cmd).dest.sid);
_debug_printf("\t\t.dest.face = %u\n", (*cmd).dest.face);
_debug_printf("\t\t.dest.mipmap = %u\n", (*cmd).dest.mipmap);
}
static void
dump_SVGA3dCmdSetMaterial(const SVGA3dCmdSetMaterial *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
switch((*cmd).face) {
case SVGA3D_FACE_INVALID:
_debug_printf("\t\t.face = SVGA3D_FACE_INVALID\n");
break;
case SVGA3D_FACE_NONE:
_debug_printf("\t\t.face = SVGA3D_FACE_NONE\n");
break;
case SVGA3D_FACE_FRONT:
_debug_printf("\t\t.face = SVGA3D_FACE_FRONT\n");
break;
case SVGA3D_FACE_BACK:
_debug_printf("\t\t.face = SVGA3D_FACE_BACK\n");
break;
case SVGA3D_FACE_FRONT_BACK:
_debug_printf("\t\t.face = SVGA3D_FACE_FRONT_BACK\n");
break;
case SVGA3D_FACE_MAX:
_debug_printf("\t\t.face = SVGA3D_FACE_MAX\n");
break;
default:
_debug_printf("\t\t.face = %i\n", (*cmd).face);
break;
}
_debug_printf("\t\t.material.diffuse[0] = %f\n", (*cmd).material.diffuse[0]);
_debug_printf("\t\t.material.diffuse[1] = %f\n", (*cmd).material.diffuse[1]);
_debug_printf("\t\t.material.diffuse[2] = %f\n", (*cmd).material.diffuse[2]);
_debug_printf("\t\t.material.diffuse[3] = %f\n", (*cmd).material.diffuse[3]);
_debug_printf("\t\t.material.ambient[0] = %f\n", (*cmd).material.ambient[0]);
_debug_printf("\t\t.material.ambient[1] = %f\n", (*cmd).material.ambient[1]);
_debug_printf("\t\t.material.ambient[2] = %f\n", (*cmd).material.ambient[2]);
_debug_printf("\t\t.material.ambient[3] = %f\n", (*cmd).material.ambient[3]);
_debug_printf("\t\t.material.specular[0] = %f\n", (*cmd).material.specular[0]);
_debug_printf("\t\t.material.specular[1] = %f\n", (*cmd).material.specular[1]);
_debug_printf("\t\t.material.specular[2] = %f\n", (*cmd).material.specular[2]);
_debug_printf("\t\t.material.specular[3] = %f\n", (*cmd).material.specular[3]);
_debug_printf("\t\t.material.emissive[0] = %f\n", (*cmd).material.emissive[0]);
_debug_printf("\t\t.material.emissive[1] = %f\n", (*cmd).material.emissive[1]);
_debug_printf("\t\t.material.emissive[2] = %f\n", (*cmd).material.emissive[2]);
_debug_printf("\t\t.material.emissive[3] = %f\n", (*cmd).material.emissive[3]);
_debug_printf("\t\t.material.shininess = %f\n", (*cmd).material.shininess);
}
static void
dump_SVGA3dCmdSetLightData(const SVGA3dCmdSetLightData *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.index = %u\n", (*cmd).index);
switch((*cmd).data.type) {
case SVGA3D_LIGHTTYPE_INVALID:
_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_INVALID\n");
break;
case SVGA3D_LIGHTTYPE_POINT:
_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_POINT\n");
break;
case SVGA3D_LIGHTTYPE_SPOT1:
_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_SPOT1\n");
break;
case SVGA3D_LIGHTTYPE_SPOT2:
_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_SPOT2\n");
break;
case SVGA3D_LIGHTTYPE_DIRECTIONAL:
_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_DIRECTIONAL\n");
break;
case SVGA3D_LIGHTTYPE_MAX:
_debug_printf("\t\t.data.type = SVGA3D_LIGHTTYPE_MAX\n");
break;
default:
_debug_printf("\t\t.data.type = %i\n", (*cmd).data.type);
break;
}
_debug_printf("\t\t.data.inWorldSpace = %u\n", (*cmd).data.inWorldSpace);
_debug_printf("\t\t.data.diffuse[0] = %f\n", (*cmd).data.diffuse[0]);
_debug_printf("\t\t.data.diffuse[1] = %f\n", (*cmd).data.diffuse[1]);
_debug_printf("\t\t.data.diffuse[2] = %f\n", (*cmd).data.diffuse[2]);
_debug_printf("\t\t.data.diffuse[3] = %f\n", (*cmd).data.diffuse[3]);
_debug_printf("\t\t.data.specular[0] = %f\n", (*cmd).data.specular[0]);
_debug_printf("\t\t.data.specular[1] = %f\n", (*cmd).data.specular[1]);
_debug_printf("\t\t.data.specular[2] = %f\n", (*cmd).data.specular[2]);
_debug_printf("\t\t.data.specular[3] = %f\n", (*cmd).data.specular[3]);
_debug_printf("\t\t.data.ambient[0] = %f\n", (*cmd).data.ambient[0]);
_debug_printf("\t\t.data.ambient[1] = %f\n", (*cmd).data.ambient[1]);
_debug_printf("\t\t.data.ambient[2] = %f\n", (*cmd).data.ambient[2]);
_debug_printf("\t\t.data.ambient[3] = %f\n", (*cmd).data.ambient[3]);
_debug_printf("\t\t.data.position[0] = %f\n", (*cmd).data.position[0]);
_debug_printf("\t\t.data.position[1] = %f\n", (*cmd).data.position[1]);
_debug_printf("\t\t.data.position[2] = %f\n", (*cmd).data.position[2]);
_debug_printf("\t\t.data.position[3] = %f\n", (*cmd).data.position[3]);
_debug_printf("\t\t.data.direction[0] = %f\n", (*cmd).data.direction[0]);
_debug_printf("\t\t.data.direction[1] = %f\n", (*cmd).data.direction[1]);
_debug_printf("\t\t.data.direction[2] = %f\n", (*cmd).data.direction[2]);
_debug_printf("\t\t.data.direction[3] = %f\n", (*cmd).data.direction[3]);
_debug_printf("\t\t.data.range = %f\n", (*cmd).data.range);
_debug_printf("\t\t.data.falloff = %f\n", (*cmd).data.falloff);
_debug_printf("\t\t.data.attenuation0 = %f\n", (*cmd).data.attenuation0);
_debug_printf("\t\t.data.attenuation1 = %f\n", (*cmd).data.attenuation1);
_debug_printf("\t\t.data.attenuation2 = %f\n", (*cmd).data.attenuation2);
_debug_printf("\t\t.data.theta = %f\n", (*cmd).data.theta);
_debug_printf("\t\t.data.phi = %f\n", (*cmd).data.phi);
}
static void
dump_SVGA3dCmdSetViewport(const SVGA3dCmdSetViewport *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.rect.x = %u\n", (*cmd).rect.x);
_debug_printf("\t\t.rect.y = %u\n", (*cmd).rect.y);
_debug_printf("\t\t.rect.w = %u\n", (*cmd).rect.w);
_debug_printf("\t\t.rect.h = %u\n", (*cmd).rect.h);
}
static void
dump_SVGA3dCmdSetScissorRect(const SVGA3dCmdSetScissorRect *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.rect.x = %u\n", (*cmd).rect.x);
_debug_printf("\t\t.rect.y = %u\n", (*cmd).rect.y);
_debug_printf("\t\t.rect.w = %u\n", (*cmd).rect.w);
_debug_printf("\t\t.rect.h = %u\n", (*cmd).rect.h);
}
static void
dump_SVGA3dCopyRect(const SVGA3dCopyRect *cmd)
{
_debug_printf("\t\t.x = %u\n", (*cmd).x);
_debug_printf("\t\t.y = %u\n", (*cmd).y);
_debug_printf("\t\t.w = %u\n", (*cmd).w);
_debug_printf("\t\t.h = %u\n", (*cmd).h);
_debug_printf("\t\t.srcx = %u\n", (*cmd).srcx);
_debug_printf("\t\t.srcy = %u\n", (*cmd).srcy);
}
static void
dump_SVGA3dCmdSetShader(const SVGA3dCmdSetShader *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
_debug_printf("\t\t.shid = %u\n", (*cmd).shid);
}
static void
dump_SVGA3dCmdEndQuery(const SVGA3dCmdEndQuery *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
switch((*cmd).type) {
case SVGA3D_QUERYTYPE_OCCLUSION:
_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
break;
case SVGA3D_QUERYTYPE_MAX:
_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
break;
default:
_debug_printf("\t\t.type = %i\n", (*cmd).type);
break;
}
_debug_printf("\t\t.guestResult.gmrId = %u\n", (*cmd).guestResult.gmrId);
_debug_printf("\t\t.guestResult.offset = %u\n", (*cmd).guestResult.offset);
}
static void
dump_SVGA3dSize(const SVGA3dSize *cmd)
{
_debug_printf("\t\t.width = %u\n", (*cmd).width);
_debug_printf("\t\t.height = %u\n", (*cmd).height);
_debug_printf("\t\t.depth = %u\n", (*cmd).depth);
}
static void
dump_SVGA3dCmdDestroySurface(const SVGA3dCmdDestroySurface *cmd)
{
_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
}
static void
dump_SVGA3dCmdDefineContext(const SVGA3dCmdDefineContext *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
}
static void
dump_SVGA3dRect(const SVGA3dRect *cmd)
{
_debug_printf("\t\t.x = %u\n", (*cmd).x);
_debug_printf("\t\t.y = %u\n", (*cmd).y);
_debug_printf("\t\t.w = %u\n", (*cmd).w);
_debug_printf("\t\t.h = %u\n", (*cmd).h);
}
static void
dump_SVGA3dCmdBeginQuery(const SVGA3dCmdBeginQuery *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
switch((*cmd).type) {
case SVGA3D_QUERYTYPE_OCCLUSION:
_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_OCCLUSION\n");
break;
case SVGA3D_QUERYTYPE_MAX:
_debug_printf("\t\t.type = SVGA3D_QUERYTYPE_MAX\n");
break;
default:
_debug_printf("\t\t.type = %i\n", (*cmd).type);
break;
}
}
static void
dump_SVGA3dRenderState(const SVGA3dRenderState *cmd)
{
switch((*cmd).state) {
case SVGA3D_RS_INVALID:
_debug_printf("\t\t.state = SVGA3D_RS_INVALID\n");
break;
case SVGA3D_RS_ZENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_ZENABLE\n");
break;
case SVGA3D_RS_ZWRITEENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_ZWRITEENABLE\n");
break;
case SVGA3D_RS_ALPHATESTENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_ALPHATESTENABLE\n");
break;
case SVGA3D_RS_DITHERENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_DITHERENABLE\n");
break;
case SVGA3D_RS_BLENDENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_BLENDENABLE\n");
break;
case SVGA3D_RS_FOGENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_FOGENABLE\n");
break;
case SVGA3D_RS_SPECULARENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_SPECULARENABLE\n");
break;
case SVGA3D_RS_STENCILENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILENABLE\n");
break;
case SVGA3D_RS_LIGHTINGENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_LIGHTINGENABLE\n");
break;
case SVGA3D_RS_NORMALIZENORMALS:
_debug_printf("\t\t.state = SVGA3D_RS_NORMALIZENORMALS\n");
break;
case SVGA3D_RS_POINTSPRITEENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSPRITEENABLE\n");
break;
case SVGA3D_RS_POINTSCALEENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALEENABLE\n");
break;
case SVGA3D_RS_STENCILREF:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILREF\n");
break;
case SVGA3D_RS_STENCILMASK:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILMASK\n");
break;
case SVGA3D_RS_STENCILWRITEMASK:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILWRITEMASK\n");
break;
case SVGA3D_RS_FOGSTART:
_debug_printf("\t\t.state = SVGA3D_RS_FOGSTART\n");
break;
case SVGA3D_RS_FOGEND:
_debug_printf("\t\t.state = SVGA3D_RS_FOGEND\n");
break;
case SVGA3D_RS_FOGDENSITY:
_debug_printf("\t\t.state = SVGA3D_RS_FOGDENSITY\n");
break;
case SVGA3D_RS_POINTSIZE:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSIZE\n");
break;
case SVGA3D_RS_POINTSIZEMIN:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSIZEMIN\n");
break;
case SVGA3D_RS_POINTSIZEMAX:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSIZEMAX\n");
break;
case SVGA3D_RS_POINTSCALE_A:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_A\n");
break;
case SVGA3D_RS_POINTSCALE_B:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_B\n");
break;
case SVGA3D_RS_POINTSCALE_C:
_debug_printf("\t\t.state = SVGA3D_RS_POINTSCALE_C\n");
break;
case SVGA3D_RS_FOGCOLOR:
_debug_printf("\t\t.state = SVGA3D_RS_FOGCOLOR\n");
break;
case SVGA3D_RS_AMBIENT:
_debug_printf("\t\t.state = SVGA3D_RS_AMBIENT\n");
break;
case SVGA3D_RS_CLIPPLANEENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_CLIPPLANEENABLE\n");
break;
case SVGA3D_RS_FOGMODE:
_debug_printf("\t\t.state = SVGA3D_RS_FOGMODE\n");
break;
case SVGA3D_RS_FILLMODE:
_debug_printf("\t\t.state = SVGA3D_RS_FILLMODE\n");
break;
case SVGA3D_RS_SHADEMODE:
_debug_printf("\t\t.state = SVGA3D_RS_SHADEMODE\n");
break;
case SVGA3D_RS_LINEPATTERN:
_debug_printf("\t\t.state = SVGA3D_RS_LINEPATTERN\n");
break;
case SVGA3D_RS_SRCBLEND:
_debug_printf("\t\t.state = SVGA3D_RS_SRCBLEND\n");
break;
case SVGA3D_RS_DSTBLEND:
_debug_printf("\t\t.state = SVGA3D_RS_DSTBLEND\n");
break;
case SVGA3D_RS_BLENDEQUATION:
_debug_printf("\t\t.state = SVGA3D_RS_BLENDEQUATION\n");
break;
case SVGA3D_RS_CULLMODE:
_debug_printf("\t\t.state = SVGA3D_RS_CULLMODE\n");
break;
case SVGA3D_RS_ZFUNC:
_debug_printf("\t\t.state = SVGA3D_RS_ZFUNC\n");
break;
case SVGA3D_RS_ALPHAFUNC:
_debug_printf("\t\t.state = SVGA3D_RS_ALPHAFUNC\n");
break;
case SVGA3D_RS_STENCILFUNC:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILFUNC\n");
break;
case SVGA3D_RS_STENCILFAIL:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILFAIL\n");
break;
case SVGA3D_RS_STENCILZFAIL:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILZFAIL\n");
break;
case SVGA3D_RS_STENCILPASS:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILPASS\n");
break;
case SVGA3D_RS_ALPHAREF:
_debug_printf("\t\t.state = SVGA3D_RS_ALPHAREF\n");
break;
case SVGA3D_RS_FRONTWINDING:
_debug_printf("\t\t.state = SVGA3D_RS_FRONTWINDING\n");
break;
case SVGA3D_RS_COORDINATETYPE:
_debug_printf("\t\t.state = SVGA3D_RS_COORDINATETYPE\n");
break;
case SVGA3D_RS_ZBIAS:
_debug_printf("\t\t.state = SVGA3D_RS_ZBIAS\n");
break;
case SVGA3D_RS_RANGEFOGENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_RANGEFOGENABLE\n");
break;
case SVGA3D_RS_COLORWRITEENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE\n");
break;
case SVGA3D_RS_VERTEXMATERIALENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_VERTEXMATERIALENABLE\n");
break;
case SVGA3D_RS_DIFFUSEMATERIALSOURCE:
_debug_printf("\t\t.state = SVGA3D_RS_DIFFUSEMATERIALSOURCE\n");
break;
case SVGA3D_RS_SPECULARMATERIALSOURCE:
_debug_printf("\t\t.state = SVGA3D_RS_SPECULARMATERIALSOURCE\n");
break;
case SVGA3D_RS_AMBIENTMATERIALSOURCE:
_debug_printf("\t\t.state = SVGA3D_RS_AMBIENTMATERIALSOURCE\n");
break;
case SVGA3D_RS_EMISSIVEMATERIALSOURCE:
_debug_printf("\t\t.state = SVGA3D_RS_EMISSIVEMATERIALSOURCE\n");
break;
case SVGA3D_RS_TEXTUREFACTOR:
_debug_printf("\t\t.state = SVGA3D_RS_TEXTUREFACTOR\n");
break;
case SVGA3D_RS_LOCALVIEWER:
_debug_printf("\t\t.state = SVGA3D_RS_LOCALVIEWER\n");
break;
case SVGA3D_RS_SCISSORTESTENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_SCISSORTESTENABLE\n");
break;
case SVGA3D_RS_BLENDCOLOR:
_debug_printf("\t\t.state = SVGA3D_RS_BLENDCOLOR\n");
break;
case SVGA3D_RS_STENCILENABLE2SIDED:
_debug_printf("\t\t.state = SVGA3D_RS_STENCILENABLE2SIDED\n");
break;
case SVGA3D_RS_CCWSTENCILFUNC:
_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILFUNC\n");
break;
case SVGA3D_RS_CCWSTENCILFAIL:
_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILFAIL\n");
break;
case SVGA3D_RS_CCWSTENCILZFAIL:
_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILZFAIL\n");
break;
case SVGA3D_RS_CCWSTENCILPASS:
_debug_printf("\t\t.state = SVGA3D_RS_CCWSTENCILPASS\n");
break;
case SVGA3D_RS_VERTEXBLEND:
_debug_printf("\t\t.state = SVGA3D_RS_VERTEXBLEND\n");
break;
case SVGA3D_RS_SLOPESCALEDEPTHBIAS:
_debug_printf("\t\t.state = SVGA3D_RS_SLOPESCALEDEPTHBIAS\n");
break;
case SVGA3D_RS_DEPTHBIAS:
_debug_printf("\t\t.state = SVGA3D_RS_DEPTHBIAS\n");
break;
case SVGA3D_RS_OUTPUTGAMMA:
_debug_printf("\t\t.state = SVGA3D_RS_OUTPUTGAMMA\n");
break;
case SVGA3D_RS_ZVISIBLE:
_debug_printf("\t\t.state = SVGA3D_RS_ZVISIBLE\n");
break;
case SVGA3D_RS_LASTPIXEL:
_debug_printf("\t\t.state = SVGA3D_RS_LASTPIXEL\n");
break;
case SVGA3D_RS_CLIPPING:
_debug_printf("\t\t.state = SVGA3D_RS_CLIPPING\n");
break;
case SVGA3D_RS_WRAP0:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP0\n");
break;
case SVGA3D_RS_WRAP1:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP1\n");
break;
case SVGA3D_RS_WRAP2:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP2\n");
break;
case SVGA3D_RS_WRAP3:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP3\n");
break;
case SVGA3D_RS_WRAP4:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP4\n");
break;
case SVGA3D_RS_WRAP5:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP5\n");
break;
case SVGA3D_RS_WRAP6:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP6\n");
break;
case SVGA3D_RS_WRAP7:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP7\n");
break;
case SVGA3D_RS_WRAP8:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP8\n");
break;
case SVGA3D_RS_WRAP9:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP9\n");
break;
case SVGA3D_RS_WRAP10:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP10\n");
break;
case SVGA3D_RS_WRAP11:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP11\n");
break;
case SVGA3D_RS_WRAP12:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP12\n");
break;
case SVGA3D_RS_WRAP13:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP13\n");
break;
case SVGA3D_RS_WRAP14:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP14\n");
break;
case SVGA3D_RS_WRAP15:
_debug_printf("\t\t.state = SVGA3D_RS_WRAP15\n");
break;
case SVGA3D_RS_MULTISAMPLEANTIALIAS:
_debug_printf("\t\t.state = SVGA3D_RS_MULTISAMPLEANTIALIAS\n");
break;
case SVGA3D_RS_MULTISAMPLEMASK:
_debug_printf("\t\t.state = SVGA3D_RS_MULTISAMPLEMASK\n");
break;
case SVGA3D_RS_INDEXEDVERTEXBLENDENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_INDEXEDVERTEXBLENDENABLE\n");
break;
case SVGA3D_RS_TWEENFACTOR:
_debug_printf("\t\t.state = SVGA3D_RS_TWEENFACTOR\n");
break;
case SVGA3D_RS_ANTIALIASEDLINEENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_ANTIALIASEDLINEENABLE\n");
break;
case SVGA3D_RS_COLORWRITEENABLE1:
_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE1\n");
break;
case SVGA3D_RS_COLORWRITEENABLE2:
_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE2\n");
break;
case SVGA3D_RS_COLORWRITEENABLE3:
_debug_printf("\t\t.state = SVGA3D_RS_COLORWRITEENABLE3\n");
break;
case SVGA3D_RS_SEPARATEALPHABLENDENABLE:
_debug_printf("\t\t.state = SVGA3D_RS_SEPARATEALPHABLENDENABLE\n");
break;
case SVGA3D_RS_SRCBLENDALPHA:
_debug_printf("\t\t.state = SVGA3D_RS_SRCBLENDALPHA\n");
break;
case SVGA3D_RS_DSTBLENDALPHA:
_debug_printf("\t\t.state = SVGA3D_RS_DSTBLENDALPHA\n");
break;
case SVGA3D_RS_BLENDEQUATIONALPHA:
_debug_printf("\t\t.state = SVGA3D_RS_BLENDEQUATIONALPHA\n");
break;
case SVGA3D_RS_MAX:
_debug_printf("\t\t.state = SVGA3D_RS_MAX\n");
break;
default:
_debug_printf("\t\t.state = %i\n", (*cmd).state);
break;
}
_debug_printf("\t\t.uintValue = %u\n", (*cmd).uintValue);
_debug_printf("\t\t.floatValue = %f\n", (*cmd).floatValue);
}
static void
dump_SVGA3dVertexDivisor(const SVGA3dVertexDivisor *cmd)
{
_debug_printf("\t\t.value = %u\n", (*cmd).value);
_debug_printf("\t\t.count = %u\n", (*cmd).count);
_debug_printf("\t\t.indexedData = %u\n", (*cmd).indexedData);
_debug_printf("\t\t.instanceData = %u\n", (*cmd).instanceData);
}
static void
dump_SVGA3dCmdDefineShader(const SVGA3dCmdDefineShader *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.shid = %u\n", (*cmd).shid);
switch((*cmd).type) {
case SVGA3D_SHADERTYPE_VS:
_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
break;
case SVGA3D_SHADERTYPE_PS:
_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
break;
case SVGA3D_SHADERTYPE_PREDX_MAX:
_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_MAX\n");
break;
default:
_debug_printf("\t\t.type = %i\n", (*cmd).type);
break;
}
}
static void
dump_constants(SVGA3dShaderConstType type, unsigned start,
unsigned numConsts, const void *buf)
{
unsigned i;
const float (*fvalues)[4];
const int32 (*ivalues)[4];
switch (type) {
case SVGA3D_CONST_TYPE_FLOAT:
_debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_FLOAT\n");
fvalues = (const float (*)[4]) buf;
for (i = 0; i < numConsts; ++i) {
_debug_printf("\t\t.values[%u] = {%f, %f, %f, %f}\n",
start + i,
fvalues[i][0],
fvalues[i][1],
fvalues[i][2],
fvalues[i][3]);
}
break;
case SVGA3D_CONST_TYPE_INT:
_debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_INT\n");
ivalues = (const int32 (*)[4]) buf;
for (i = 0; i < numConsts; ++i) {
_debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
start + i,
ivalues[i][0],
ivalues[i][1],
ivalues[i][2],
ivalues[i][3]);
}
break;
case SVGA3D_CONST_TYPE_BOOL:
_debug_printf("\t\t.ctype = SVGA3D_CONST_TYPE_BOOL\n");
ivalues = (const int32 (*)[4]) buf;
for (i = 0; i < numConsts; ++i) {
_debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
start + i,
ivalues[i][0],
ivalues[i][1],
ivalues[i][2],
ivalues[i][3]);
}
break;
default:
_debug_printf("\t\t.ctype = %i\n", type);
ivalues = (const int32 (*)[4]) buf;
for (i = 0; i < numConsts; ++i) {
_debug_printf("\t\t.values[%u] = {%i, %i, %i, %i}\n",
start + i,
ivalues[i][0],
ivalues[i][1],
ivalues[i][2],
ivalues[i][3]);
}
break;
}
}
static void
dump_SVGA3dCmdSetShaderConst(const SVGA3dCmdSetShaderConst *cmd, uint32 numConsts)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.reg = %u\n", (*cmd).reg);
_debug_printf("\t\t.type = %s\n", shader_name((*cmd).type));
dump_constants((*cmd).ctype, cmd->reg, numConsts, cmd->values);
}
static void
dump_SVGA3dCmdSetGBShaderConstInline(const SVGA3dCmdSetGBShaderConstInline *cmd, uint32 numConsts)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.reg = %u\n", (*cmd).regStart);
_debug_printf("\t\t.type = %s\n", shader_name((*cmd).shaderType));
dump_constants((*cmd).constType, cmd->regStart, numConsts, &cmd[1]);
}
static void
dump_SVGA3dCmdSetZRange(const SVGA3dCmdSetZRange *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.zRange.min = %f\n", (*cmd).zRange.min);
_debug_printf("\t\t.zRange.max = %f\n", (*cmd).zRange.max);
}
static void
dump_SVGA3dCmdDrawPrimitives(const SVGA3dCmdDrawPrimitives *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.numVertexDecls = %u\n", (*cmd).numVertexDecls);
_debug_printf("\t\t.numRanges = %u\n", (*cmd).numRanges);
}
static void
dump_SVGA3dCmdSetLightEnabled(const SVGA3dCmdSetLightEnabled *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.index = %u\n", (*cmd).index);
_debug_printf("\t\t.enabled = %u\n", (*cmd).enabled);
}
static void
dump_SVGA3dPrimitiveRange(const SVGA3dPrimitiveRange *cmd)
{
switch((*cmd).primType) {
case SVGA3D_PRIMITIVE_INVALID:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_INVALID\n");
break;
case SVGA3D_PRIMITIVE_TRIANGLELIST:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLELIST\n");
break;
case SVGA3D_PRIMITIVE_POINTLIST:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_POINTLIST\n");
break;
case SVGA3D_PRIMITIVE_LINELIST:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_LINELIST\n");
break;
case SVGA3D_PRIMITIVE_LINESTRIP:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_LINESTRIP\n");
break;
case SVGA3D_PRIMITIVE_TRIANGLESTRIP:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLESTRIP\n");
break;
case SVGA3D_PRIMITIVE_TRIANGLEFAN:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_TRIANGLEFAN\n");
break;
case SVGA3D_PRIMITIVE_MAX:
_debug_printf("\t\t.primType = SVGA3D_PRIMITIVE_MAX\n");
break;
default:
_debug_printf("\t\t.primType = %i\n", (*cmd).primType);
break;
}
_debug_printf("\t\t.primitiveCount = %u\n", (*cmd).primitiveCount);
_debug_printf("\t\t.indexArray.surfaceId = %u\n", (*cmd).indexArray.surfaceId);
_debug_printf("\t\t.indexArray.offset = %u\n", (*cmd).indexArray.offset);
_debug_printf("\t\t.indexArray.stride = %u\n", (*cmd).indexArray.stride);
_debug_printf("\t\t.indexWidth = %u\n", (*cmd).indexWidth);
_debug_printf("\t\t.indexBias = %i\n", (*cmd).indexBias);
}
static void
dump_SVGA3dCmdPresent(const SVGA3dCmdPresent *cmd)
{
_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
}
static void
dump_SVGA3dCmdSetRenderState(const SVGA3dCmdSetRenderState *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
}
static void
dump_SVGA3dCmdSurfaceStretchBlt(const SVGA3dCmdSurfaceStretchBlt *cmd)
{
_debug_printf("\t\t.src.sid = %u\n", (*cmd).src.sid);
_debug_printf("\t\t.src.face = %u\n", (*cmd).src.face);
_debug_printf("\t\t.src.mipmap = %u\n", (*cmd).src.mipmap);
_debug_printf("\t\t.dest.sid = %u\n", (*cmd).dest.sid);
_debug_printf("\t\t.dest.face = %u\n", (*cmd).dest.face);
_debug_printf("\t\t.dest.mipmap = %u\n", (*cmd).dest.mipmap);
_debug_printf("\t\t.boxSrc.x = %u\n", (*cmd).boxSrc.x);
_debug_printf("\t\t.boxSrc.y = %u\n", (*cmd).boxSrc.y);
_debug_printf("\t\t.boxSrc.z = %u\n", (*cmd).boxSrc.z);
_debug_printf("\t\t.boxSrc.w = %u\n", (*cmd).boxSrc.w);
_debug_printf("\t\t.boxSrc.h = %u\n", (*cmd).boxSrc.h);
_debug_printf("\t\t.boxSrc.d = %u\n", (*cmd).boxSrc.d);
_debug_printf("\t\t.boxDest.x = %u\n", (*cmd).boxDest.x);
_debug_printf("\t\t.boxDest.y = %u\n", (*cmd).boxDest.y);
_debug_printf("\t\t.boxDest.z = %u\n", (*cmd).boxDest.z);
_debug_printf("\t\t.boxDest.w = %u\n", (*cmd).boxDest.w);
_debug_printf("\t\t.boxDest.h = %u\n", (*cmd).boxDest.h);
_debug_printf("\t\t.boxDest.d = %u\n", (*cmd).boxDest.d);
switch((*cmd).mode) {
case SVGA3D_STRETCH_BLT_POINT:
_debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_POINT\n");
break;
case SVGA3D_STRETCH_BLT_LINEAR:
_debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_LINEAR\n");
break;
case SVGA3D_STRETCH_BLT_MAX:
_debug_printf("\t\t.mode = SVGA3D_STRETCH_BLT_MAX\n");
break;
default:
_debug_printf("\t\t.mode = %i\n", (*cmd).mode);
break;
}
}
static void
dump_SVGA3dCmdSurfaceDMA(const SVGA3dCmdSurfaceDMA *cmd)
{
_debug_printf("\t\t.guest.ptr.gmrId = %u\n", (*cmd).guest.ptr.gmrId);
_debug_printf("\t\t.guest.ptr.offset = %u\n", (*cmd).guest.ptr.offset);
_debug_printf("\t\t.guest.pitch = %u\n", (*cmd).guest.pitch);
_debug_printf("\t\t.host.sid = %u\n", (*cmd).host.sid);
_debug_printf("\t\t.host.face = %u\n", (*cmd).host.face);
_debug_printf("\t\t.host.mipmap = %u\n", (*cmd).host.mipmap);
switch((*cmd).transfer) {
case SVGA3D_WRITE_HOST_VRAM:
_debug_printf("\t\t.transfer = SVGA3D_WRITE_HOST_VRAM\n");
break;
case SVGA3D_READ_HOST_VRAM:
_debug_printf("\t\t.transfer = SVGA3D_READ_HOST_VRAM\n");
break;
default:
_debug_printf("\t\t.transfer = %i\n", (*cmd).transfer);
break;
}
}
static void
dump_SVGA3dCmdSurfaceDMASuffix(const SVGA3dCmdSurfaceDMASuffix *cmd)
{
_debug_printf("\t\t.suffixSize = %u\n", (*cmd).suffixSize);
_debug_printf("\t\t.maximumOffset = %u\n", (*cmd).maximumOffset);
_debug_printf("\t\t.flags.discard = %u\n", (*cmd).flags.discard);
_debug_printf("\t\t.flags.unsynchronized = %u\n", (*cmd).flags.unsynchronized);
}
static void
dump_SVGA3dCmdSetTransform(const SVGA3dCmdSetTransform *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
switch((*cmd).type) {
case SVGA3D_TRANSFORM_INVALID:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_INVALID\n");
break;
case SVGA3D_TRANSFORM_WORLD:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD\n");
break;
case SVGA3D_TRANSFORM_VIEW:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_VIEW\n");
break;
case SVGA3D_TRANSFORM_PROJECTION:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_PROJECTION\n");
break;
case SVGA3D_TRANSFORM_TEXTURE0:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE0\n");
break;
case SVGA3D_TRANSFORM_TEXTURE1:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE1\n");
break;
case SVGA3D_TRANSFORM_TEXTURE2:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE2\n");
break;
case SVGA3D_TRANSFORM_TEXTURE3:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE3\n");
break;
case SVGA3D_TRANSFORM_TEXTURE4:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE4\n");
break;
case SVGA3D_TRANSFORM_TEXTURE5:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE5\n");
break;
case SVGA3D_TRANSFORM_TEXTURE6:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE6\n");
break;
case SVGA3D_TRANSFORM_TEXTURE7:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_TEXTURE7\n");
break;
case SVGA3D_TRANSFORM_WORLD1:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD1\n");
break;
case SVGA3D_TRANSFORM_WORLD2:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD2\n");
break;
case SVGA3D_TRANSFORM_WORLD3:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_WORLD3\n");
break;
case SVGA3D_TRANSFORM_MAX:
_debug_printf("\t\t.type = SVGA3D_TRANSFORM_MAX\n");
break;
default:
_debug_printf("\t\t.type = %i\n", (*cmd).type);
break;
}
_debug_printf("\t\t.matrix[0] = %f\n", (*cmd).matrix[0]);
_debug_printf("\t\t.matrix[1] = %f\n", (*cmd).matrix[1]);
_debug_printf("\t\t.matrix[2] = %f\n", (*cmd).matrix[2]);
_debug_printf("\t\t.matrix[3] = %f\n", (*cmd).matrix[3]);
_debug_printf("\t\t.matrix[4] = %f\n", (*cmd).matrix[4]);
_debug_printf("\t\t.matrix[5] = %f\n", (*cmd).matrix[5]);
_debug_printf("\t\t.matrix[6] = %f\n", (*cmd).matrix[6]);
_debug_printf("\t\t.matrix[7] = %f\n", (*cmd).matrix[7]);
_debug_printf("\t\t.matrix[8] = %f\n", (*cmd).matrix[8]);
_debug_printf("\t\t.matrix[9] = %f\n", (*cmd).matrix[9]);
_debug_printf("\t\t.matrix[10] = %f\n", (*cmd).matrix[10]);
_debug_printf("\t\t.matrix[11] = %f\n", (*cmd).matrix[11]);
_debug_printf("\t\t.matrix[12] = %f\n", (*cmd).matrix[12]);
_debug_printf("\t\t.matrix[13] = %f\n", (*cmd).matrix[13]);
_debug_printf("\t\t.matrix[14] = %f\n", (*cmd).matrix[14]);
_debug_printf("\t\t.matrix[15] = %f\n", (*cmd).matrix[15]);
}
static void
dump_SVGA3dCmdDestroyShader(const SVGA3dCmdDestroyShader *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
_debug_printf("\t\t.shid = %u\n", (*cmd).shid);
switch((*cmd).type) {
case SVGA3D_SHADERTYPE_VS:
_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_VS\n");
break;
case SVGA3D_SHADERTYPE_PS:
_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_PS\n");
break;
case SVGA3D_SHADERTYPE_PREDX_MAX:
_debug_printf("\t\t.type = SVGA3D_SHADERTYPE_MAX\n");
break;
default:
_debug_printf("\t\t.type = %i\n", (*cmd).type);
break;
}
}
static void
dump_SVGA3dCmdDestroyContext(const SVGA3dCmdDestroyContext *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
}
static void
dump_SVGA3dCmdClear(const SVGA3dCmdClear *cmd)
{
_debug_printf("\t\t.cid = %u\n", (*cmd).cid);
switch((*cmd).clearFlag) {
case SVGA3D_CLEAR_COLOR:
_debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_COLOR\n");
break;
case SVGA3D_CLEAR_DEPTH:
_debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_DEPTH\n");
break;
case SVGA3D_CLEAR_STENCIL:
_debug_printf("\t\t.clearFlag = SVGA3D_CLEAR_STENCIL\n");
break;
default:
_debug_printf("\t\t.clearFlag = %i\n", (*cmd).clearFlag);
break;
}
_debug_printf("\t\t.color = %u\n", (*cmd).color);
_debug_printf("\t\t.depth = %f\n", (*cmd).depth);
_debug_printf("\t\t.stencil = %u\n", (*cmd).stencil);
}
static void
dump_SVGA3dCmdDefineSurface(const SVGA3dCmdDefineSurface *cmd)
{
_debug_printf("\t\t.sid = %u\n", (*cmd).sid);
switch((*cmd).surfaceFlags) {
case SVGA3D_SURFACE_CUBEMAP:
_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_CUBEMAP\n");
break;
case SVGA3D_SURFACE_HINT_STATIC:
_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_STATIC\n");
break;
case SVGA3D_SURFACE_HINT_DYNAMIC:
_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_DYNAMIC\n");
break;
case SVGA3D_SURFACE_HINT_INDEXBUFFER:
_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_INDEXBUFFER\n");
break;
case SVGA3D_SURFACE_HINT_VERTEXBUFFER:
_debug_printf("\t\t.surfaceFlags = SVGA3D_SURFACE_HINT_VERTEXBUFFER\n");
break;
default:
_debug_printf("\t\t.surfaceFlags = %i\n", (*cmd).surfaceFlags);
break;
}
switch((*cmd).format) {
case SVGA3D_FORMAT_INVALID:
_debug_printf("\t\t.format = SVGA3D_FORMAT_INVALID\n");
break;
case SVGA3D_X8R8G8B8:
_debug_printf("\t\t.format = SVGA3D_X8R8G8B8\n");
break;
case SVGA3D_A8R8G8B8:
_debug_printf("\t\t.format = SVGA3D_A8R8G8B8\n");
break;
case SVGA3D_R5G6B5:
_debug_printf("\t\t.format = SVGA3D_R5G6B5\n");
break;
case SVGA3D_X1R5G5B5:
_debug_printf("\t\t.format = SVGA3D_X1R5G5B5\n");
break;
case SVGA3D_A1R5G5B5:
_debug_printf("\t\t.format = SVGA3D_A1R5G5B5\n");
break;
case SVGA3D_A4R4G4B4:
_debug_printf("\t\t.format = SVGA3D_A4R4G4B4\n");
break;
case SVGA3D_Z_D32:
_debug_printf("\t\t.format = SVGA3D_Z_D32\n");
break;
case SVGA3D_Z_D16:
_debug_printf("\t\t.format = SVGA3D_Z_D16\n");
break;
case SVGA3D_Z_D24S8:
_debug_printf("\t\t.format = SVGA3D_Z_D24S8\n");
break;
case SVGA3D_Z_D15S1:
_debug_printf("\t\t.format = SVGA3D_Z_D15S1\n");
break;
case SVGA3D_LUMINANCE8:
_debug_printf("\t\t.format = SVGA3D_LUMINANCE8\n");
break;
case SVGA3D_LUMINANCE4_ALPHA4:
_debug_printf("\t\t.format = SVGA3D_LUMINANCE4_ALPHA4\n");
break;
case SVGA3D_LUMINANCE16:
_debug_printf("\t\t.format = SVGA3D_LUMINANCE16\n");
break;
case SVGA3D_LUMINANCE8_ALPHA8:
_debug_printf("\t\t.format = SVGA3D_LUMINANCE8_ALPHA8\n");
break;
case SVGA3D_DXT1:
_debug_printf("\t\t.format = SVGA3D_DXT1\n");
break;
case SVGA3D_DXT2:
_debug_printf("\t\t.format = SVGA3D_DXT2\n");
break;
case SVGA3D_DXT3:
_debug_printf("\t\t.format = SVGA3D_DXT3\n");
break;
case SVGA3D_DXT4:
_debug_printf("\t\t.format = SVGA3D_DXT4\n");
break;
case SVGA3D_DXT5:
_debug_printf("\t\t.format = SVGA3D_DXT5\n");
break;
case SVGA3D_BUMPU8V8:
_debug_printf("\t\t.format = SVGA3D_BUMPU8V8\n");
break;
case SVGA3D_BUMPL6V5U5:
_debug_printf("\t\t.format = SVGA3D_BUMPL6V5U5\n");
break;
case SVGA3D_BUMPX8L8V8U8:
_debug_printf("\t\t.format = SVGA3D_BUMPX8L8V8U8\n");
break;
case SVGA3D_BUMPL8V8U8:
_debug_printf("\t\t.format = SVGA3D_BUMPL8V8U8\n");
break;
case SVGA3D_ARGB_S10E5:
_debug_printf("\t\t.format = SVGA3D_ARGB_S10E5\n");
break;
case SVGA3D_ARGB_S23E8:
_debug_printf("\t\t.format = SVGA3D_ARGB_S23E8\n");
break;
case SVGA3D_A2R10G10B10:
_debug_printf("\t\t.format = SVGA3D_A2R10G10B10\n");
break;
case SVGA3D_V8U8:
_debug_printf("\t\t.format = SVGA3D_V8U8\n");
break;
case SVGA3D_Q8W8V8U8:
_debug_printf("\t\t.format = SVGA3D_Q8W8V8U8\n");
break;
case SVGA3D_CxV8U8:
_debug_printf("\t\t.format = SVGA3D_CxV8U8\n");
break;
case SVGA3D_X8L8V8U8:
_debug_printf("\t\t.format = SVGA3D_X8L8V8U8\n");
break;
case SVGA3D_A2W10V10U10:
_debug_printf("\t\t.format = SVGA3D_A2W10V10U10\n");
break;
case SVGA3D_ALPHA8:
_debug_printf("\t\t.format = SVGA3D_ALPHA8\n");
break;
case SVGA3D_R_S10E5:
_debug_printf("\t\t.format = SVGA3D_R_S10E5\n");
break;
case SVGA3D_R_S23E8:
_debug_printf("\t\t.format = SVGA3D_R_S23E8\n");
break;
case SVGA3D_RG_S10E5:
_debug_printf("\t\t.format = SVGA3D_RG_S10E5\n");
break;
case SVGA3D_RG_S23E8:
_debug_printf("\t\t.format = SVGA3D_RG_S23E8\n");
break;
case SVGA3D_BUFFER:
_debug_printf("\t\t.format = SVGA3D_BUFFER\n");
break;
case SVGA3D_Z_D24X8:
_debug_printf("\t\t.format = SVGA3D_Z_D24X8\n");
break;
case SVGA3D_G16R16:
_debug_printf("\t\t.format = SVGA3D_G16R16\n");
break;
case SVGA3D_A16B16G16R16:
_debug_printf("\t\t.format = SVGA3D_A16B16G16R16\n");
break;
case SVGA3D_UYVY:
_debug_printf("\t\t.format = SVGA3D_UYVY\n");
break;
case SVGA3D_YUY2:
_debug_printf("\t\t.format = SVGA3D_YUY2\n");
break;
case SVGA3D_NV12:
_debug_printf("\t\t.format = SVGA3D_NV12\n");
break;
case SVGA3D_AYUV:
_debug_printf("\t\t.format = SVGA3D_AYUV\n");
break;
case SVGA3D_Z_DF16:
_debug_printf("\t\t.format = SVGA3D_Z_D16\n");
break;
case SVGA3D_Z_DF24:
_debug_printf("\t\t.format = SVGA3D_Z_DF24\n");
break;
case SVGA3D_Z_D24S8_INT:
_debug_printf("\t\t.format = SVGA3D_Z_D24S8_INT\n");
break;
default:
_debug_printf("\t\t.format = %i\n", (*cmd).format);
break;
}
_debug_printf("\t\t.face[0].numMipLevels = %u\n", (*cmd).face[0].numMipLevels);
_debug_printf("\t\t.face[1].numMipLevels = %u\n", (*cmd).face[1].numMipLevels);
_debug_printf("\t\t.face[2].numMipLevels = %u\n", (*cmd).face[2].numMipLevels);
_debug_printf("\t\t.face[3].numMipLevels = %u\n", (*cmd).face[3].numMipLevels);
_debug_printf("\t\t.face[4].numMipLevels = %u\n", (*cmd).face[4].numMipLevels);
_debug_printf("\t\t.face[5].numMipLevels = %u\n", (*cmd).face[5].numMipLevels);
}
static void
dump_SVGASignedRect(const SVGASignedRect *cmd)
{
_debug_printf("\t\t.left = %i\n", (*cmd).left);
_debug_printf("\t\t.top = %i\n", (*cmd).top);
_debug_printf("\t\t.right = %i\n", (*cmd).right);
_debug_printf("\t\t.bottom = %i\n", (*cmd).bottom);
}
static void
dump_SVGA3dCmdBlitSurfaceToScreen(const SVGA3dCmdBlitSurfaceToScreen *cmd)
{
_debug_printf("\t\t.srcImage.sid = %u\n", (*cmd).srcImage.sid);
_debug_printf("\t\t.srcImage.face = %u\n", (*cmd).srcImage.face);
_debug_printf("\t\t.srcImage.mipmap = %u\n", (*cmd).srcImage.mipmap);
_debug_printf("\t\t.srcRect.left = %i\n", (*cmd).srcRect.left);
_debug_printf("\t\t.srcRect.top = %i\n", (*cmd).srcRect.top);
_debug_printf("\t\t.srcRect.right = %i\n", (*cmd).srcRect.right);
_debug_printf("\t\t.srcRect.bottom = %i\n", (*cmd).srcRect.bottom);
_debug_printf("\t\t.destScreenId = %u\n", (*cmd).destScreenId);
_debug_printf("\t\t.destRect.left = %i\n", (*cmd).destRect.left);
_debug_printf("\t\t.destRect.top = %i\n", (*cmd).destRect.top);
_debug_printf("\t\t.destRect.right = %i\n", (*cmd).destRect.right);
_debug_printf("\t\t.destRect.bottom = %i\n", (*cmd).destRect.bottom);
}
static void
dump_SVGA3dCmdDefineGBContext(const SVGA3dCmdDefineGBContext *cmd)
{
_debug_printf("\t\t.cid = %u\n", cmd->cid);
}
static void
dump_SVGA3dCmdBindGBContext(const SVGA3dCmdBindGBContext *cmd)
{
_debug_printf("\t\t.cid = %u\n", cmd->cid);
_debug_printf("\t\t.mobid = %u\n", cmd->mobid);
_debug_printf("\t\t.validContents = %u\n", cmd->validContents);
}
static void
dump_SVGA3dCmdDestroyGBContext(const SVGA3dCmdDestroyGBContext *cmd)
{
_debug_printf("\t\t.cid = %u\n", cmd->cid);
}
static void
dump_SVGA3dCmdDefineGBShader(const SVGA3dCmdDefineGBShader *cmd)
{
_debug_printf("\t\t.shid = %u\n", cmd->shid);
_debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
_debug_printf("\t\t.sizeInBytes = %u\n", cmd->sizeInBytes);
}
static void
dump_SVGA3dCmdBindGBShader(const SVGA3dCmdBindGBShader *cmd)
{
_debug_printf("\t\t.shid = %u\n", cmd->shid);
_debug_printf("\t\t.mobid = %u\n", cmd->mobid);
_debug_printf("\t\t.offsetInBytes = %u\n", cmd->offsetInBytes);
}
static void
dump_SVGA3dCmdDestroyGBShader(const SVGA3dCmdDestroyGBShader *cmd)
{
_debug_printf("\t\t.shid = %u\n", cmd->shid);
}
static void
dump_SVGA3dCmdBindGBShaderConsts(const SVGA3dCmdBindGBShaderConsts *cmd)
{
_debug_printf("\t\t.cid = %u\n", cmd->cid);
_debug_printf("\t\t.shaderType = %u\n", cmd->shaderType);
_debug_printf("\t\t.shaderConstType = %u\n", cmd->shaderConstType);
_debug_printf("\t\t.sid = %u\n", cmd->sid);
}
static void
dump_SVGA3dCmdBindGBSurface(const SVGA3dCmdBindGBSurface *cmd)
{
_debug_printf("\t\t.sid = %u\n", cmd->sid);
_debug_printf("\t\t.mobid = %u\n", cmd->mobid);
}
static void
dump_SVGA3dCmdUpdateGBSurface(const SVGA3dCmdUpdateGBSurface *cmd)
{
_debug_printf("\t\t.sid = %u\n", cmd->sid);
}
static void
dump_SVGA3dCmdUpdateGBImage(const SVGA3dCmdUpdateGBImage *cmd)
{
_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
_debug_printf("\t\t.box = %u, %u, %u %u x %u x %u\n",
cmd->box.x, cmd->box.y, cmd->box.z,
cmd->box.w, cmd->box.h, cmd->box.d);
}
static void
dump_SVGA3dCmdReadbackGBImage(const SVGA3dCmdReadbackGBImage *cmd)
{
_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
}
static void
dump_SVGA3dCmdInvalidateGBImage(const SVGA3dCmdInvalidateGBImage *cmd)
{
_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
}
static void
dump_SVGA3dCmdInvalidateGBImagePartial(const SVGA3dCmdInvalidateGBImagePartial *cmd)
{
_debug_printf("\t\t.image.sid = %u\n", cmd->image.sid);
_debug_printf("\t\t.image.face = %u\n", cmd->image.face);
_debug_printf("\t\t.image.mipmap = %u\n", cmd->image.mipmap);
_debug_printf("\t\t.box = %u, %u, %u %u x %u x %u\n",
cmd->box.x, cmd->box.y, cmd->box.z,
cmd->box.w, cmd->box.h, cmd->box.d);
_debug_printf("\t\t.invertBox = %u\n", cmd->invertBox);
}
void
svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size)
{
const uint8_t *body = (const uint8_t *)data;
const uint8_t *next = body + size;
switch(cmd_id) {
case SVGA_3D_CMD_SURFACE_DEFINE:
_debug_printf("\tSVGA_3D_CMD_SURFACE_DEFINE\n");
{
const SVGA3dCmdDefineSurface *cmd = (const SVGA3dCmdDefineSurface *)body;
dump_SVGA3dCmdDefineSurface(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGA3dSize) <= next) {
dump_SVGA3dSize((const SVGA3dSize *)body);
body += sizeof(SVGA3dSize);
}
}
break;
case SVGA_3D_CMD_SURFACE_DESTROY:
_debug_printf("\tSVGA_3D_CMD_SURFACE_DESTROY\n");
{
const SVGA3dCmdDestroySurface *cmd = (const SVGA3dCmdDestroySurface *)body;
dump_SVGA3dCmdDestroySurface(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SURFACE_COPY:
_debug_printf("\tSVGA_3D_CMD_SURFACE_COPY\n");
{
const SVGA3dCmdSurfaceCopy *cmd = (const SVGA3dCmdSurfaceCopy *)body;
dump_SVGA3dCmdSurfaceCopy(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGA3dCopyBox) <= next) {
dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
body += sizeof(SVGA3dCopyBox);
}
}
break;
case SVGA_3D_CMD_SURFACE_STRETCHBLT:
_debug_printf("\tSVGA_3D_CMD_SURFACE_STRETCHBLT\n");
{
const SVGA3dCmdSurfaceStretchBlt *cmd = (const SVGA3dCmdSurfaceStretchBlt *)body;
dump_SVGA3dCmdSurfaceStretchBlt(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SURFACE_DMA:
_debug_printf("\tSVGA_3D_CMD_SURFACE_DMA\n");
{
const SVGA3dCmdSurfaceDMA *cmd = (const SVGA3dCmdSurfaceDMA *)body;
dump_SVGA3dCmdSurfaceDMA(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGA3dCopyBox) <= next) {
dump_SVGA3dCopyBox((const SVGA3dCopyBox *)body);
body += sizeof(SVGA3dCopyBox);
}
while(body + sizeof(SVGA3dCmdSurfaceDMASuffix) <= next) {
dump_SVGA3dCmdSurfaceDMASuffix((const SVGA3dCmdSurfaceDMASuffix *)body);
body += sizeof(SVGA3dCmdSurfaceDMASuffix);
}
}
break;
case SVGA_3D_CMD_CONTEXT_DEFINE:
_debug_printf("\tSVGA_3D_CMD_CONTEXT_DEFINE\n");
{
const SVGA3dCmdDefineContext *cmd = (const SVGA3dCmdDefineContext *)body;
dump_SVGA3dCmdDefineContext(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_CONTEXT_DESTROY:
_debug_printf("\tSVGA_3D_CMD_CONTEXT_DESTROY\n");
{
const SVGA3dCmdDestroyContext *cmd = (const SVGA3dCmdDestroyContext *)body;
dump_SVGA3dCmdDestroyContext(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETTRANSFORM:
_debug_printf("\tSVGA_3D_CMD_SETTRANSFORM\n");
{
const SVGA3dCmdSetTransform *cmd = (const SVGA3dCmdSetTransform *)body;
dump_SVGA3dCmdSetTransform(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETZRANGE:
_debug_printf("\tSVGA_3D_CMD_SETZRANGE\n");
{
const SVGA3dCmdSetZRange *cmd = (const SVGA3dCmdSetZRange *)body;
dump_SVGA3dCmdSetZRange(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETRENDERSTATE:
_debug_printf("\tSVGA_3D_CMD_SETRENDERSTATE\n");
{
const SVGA3dCmdSetRenderState *cmd = (const SVGA3dCmdSetRenderState *)body;
dump_SVGA3dCmdSetRenderState(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGA3dRenderState) <= next) {
dump_SVGA3dRenderState((const SVGA3dRenderState *)body);
body += sizeof(SVGA3dRenderState);
}
}
break;
case SVGA_3D_CMD_SETRENDERTARGET:
_debug_printf("\tSVGA_3D_CMD_SETRENDERTARGET\n");
{
const SVGA3dCmdSetRenderTarget *cmd = (const SVGA3dCmdSetRenderTarget *)body;
dump_SVGA3dCmdSetRenderTarget(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETTEXTURESTATE:
_debug_printf("\tSVGA_3D_CMD_SETTEXTURESTATE\n");
{
const SVGA3dCmdSetTextureState *cmd = (const SVGA3dCmdSetTextureState *)body;
dump_SVGA3dCmdSetTextureState(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGA3dTextureState) <= next) {
dump_SVGA3dTextureState((const SVGA3dTextureState *)body);
body += sizeof(SVGA3dTextureState);
}
}
break;
case SVGA_3D_CMD_SETMATERIAL:
_debug_printf("\tSVGA_3D_CMD_SETMATERIAL\n");
{
const SVGA3dCmdSetMaterial *cmd = (const SVGA3dCmdSetMaterial *)body;
dump_SVGA3dCmdSetMaterial(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETLIGHTDATA:
_debug_printf("\tSVGA_3D_CMD_SETLIGHTDATA\n");
{
const SVGA3dCmdSetLightData *cmd = (const SVGA3dCmdSetLightData *)body;
dump_SVGA3dCmdSetLightData(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETLIGHTENABLED:
_debug_printf("\tSVGA_3D_CMD_SETLIGHTENABLED\n");
{
const SVGA3dCmdSetLightEnabled *cmd = (const SVGA3dCmdSetLightEnabled *)body;
dump_SVGA3dCmdSetLightEnabled(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETVIEWPORT:
_debug_printf("\tSVGA_3D_CMD_SETVIEWPORT\n");
{
const SVGA3dCmdSetViewport *cmd = (const SVGA3dCmdSetViewport *)body;
dump_SVGA3dCmdSetViewport(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SETCLIPPLANE:
_debug_printf("\tSVGA_3D_CMD_SETCLIPPLANE\n");
{
const SVGA3dCmdSetClipPlane *cmd = (const SVGA3dCmdSetClipPlane *)body;
dump_SVGA3dCmdSetClipPlane(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_CLEAR:
_debug_printf("\tSVGA_3D_CMD_CLEAR\n");
{
const SVGA3dCmdClear *cmd = (const SVGA3dCmdClear *)body;
dump_SVGA3dCmdClear(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGA3dRect) <= next) {
dump_SVGA3dRect((const SVGA3dRect *)body);
body += sizeof(SVGA3dRect);
}
}
break;
case SVGA_3D_CMD_PRESENT:
_debug_printf("\tSVGA_3D_CMD_PRESENT\n");
{
const SVGA3dCmdPresent *cmd = (const SVGA3dCmdPresent *)body;
dump_SVGA3dCmdPresent(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGA3dCopyRect) <= next) {
dump_SVGA3dCopyRect((const SVGA3dCopyRect *)body);
body += sizeof(SVGA3dCopyRect);
}
}
break;
case SVGA_3D_CMD_SHADER_DEFINE:
_debug_printf("\tSVGA_3D_CMD_SHADER_DEFINE\n");
{
const SVGA3dCmdDefineShader *cmd = (const SVGA3dCmdDefineShader *)body;
dump_SVGA3dCmdDefineShader(cmd);
body = (const uint8_t *)&cmd[1];
svga_shader_dump((const uint32_t *)body,
(unsigned)(next - body)/sizeof(uint32_t),
FALSE );
body = next;
}
break;
case SVGA_3D_CMD_SHADER_DESTROY:
_debug_printf("\tSVGA_3D_CMD_SHADER_DESTROY\n");
{
const SVGA3dCmdDestroyShader *cmd = (const SVGA3dCmdDestroyShader *)body;
dump_SVGA3dCmdDestroyShader(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SET_SHADER:
_debug_printf("\tSVGA_3D_CMD_SET_SHADER\n");
{
const SVGA3dCmdSetShader *cmd = (const SVGA3dCmdSetShader *)body;
dump_SVGA3dCmdSetShader(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SET_SHADER_CONST:
_debug_printf("\tSVGA_3D_CMD_SET_SHADER_CONST\n");
{
const SVGA3dCmdSetShaderConst *cmd = (const SVGA3dCmdSetShaderConst *)body;
uint32 numConsts = 1 + (size - sizeof *cmd) / (4 * sizeof(uint32));
dump_SVGA3dCmdSetShaderConst(cmd, numConsts);
body = next;
}
break;
case SVGA_3D_CMD_DRAW_PRIMITIVES:
_debug_printf("\tSVGA_3D_CMD_DRAW_PRIMITIVES\n");
{
const SVGA3dCmdDrawPrimitives *cmd = (const SVGA3dCmdDrawPrimitives *)body;
unsigned i, j;
dump_SVGA3dCmdDrawPrimitives(cmd);
body = (const uint8_t *)&cmd[1];
for(i = 0; i < cmd->numVertexDecls; ++i) {
dump_SVGA3dVertexDecl((const SVGA3dVertexDecl *)body);
body += sizeof(SVGA3dVertexDecl);
}
for(j = 0; j < cmd->numRanges; ++j) {
dump_SVGA3dPrimitiveRange((const SVGA3dPrimitiveRange *)body);
body += sizeof(SVGA3dPrimitiveRange);
}
while(body + sizeof(SVGA3dVertexDivisor) <= next) {
dump_SVGA3dVertexDivisor((const SVGA3dVertexDivisor *)body);
body += sizeof(SVGA3dVertexDivisor);
}
}
break;
case SVGA_3D_CMD_SETSCISSORRECT:
_debug_printf("\tSVGA_3D_CMD_SETSCISSORRECT\n");
{
const SVGA3dCmdSetScissorRect *cmd = (const SVGA3dCmdSetScissorRect *)body;
dump_SVGA3dCmdSetScissorRect(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_BEGIN_QUERY:
_debug_printf("\tSVGA_3D_CMD_BEGIN_QUERY\n");
{
const SVGA3dCmdBeginQuery *cmd = (const SVGA3dCmdBeginQuery *)body;
dump_SVGA3dCmdBeginQuery(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_END_QUERY:
_debug_printf("\tSVGA_3D_CMD_END_QUERY\n");
{
const SVGA3dCmdEndQuery *cmd = (const SVGA3dCmdEndQuery *)body;
dump_SVGA3dCmdEndQuery(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_WAIT_FOR_QUERY:
_debug_printf("\tSVGA_3D_CMD_WAIT_FOR_QUERY\n");
{
const SVGA3dCmdWaitForQuery *cmd = (const SVGA3dCmdWaitForQuery *)body;
dump_SVGA3dCmdWaitForQuery(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN:
_debug_printf("\tSVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN\n");
{
const SVGA3dCmdBlitSurfaceToScreen *cmd = (const SVGA3dCmdBlitSurfaceToScreen *)body;
dump_SVGA3dCmdBlitSurfaceToScreen(cmd);
body = (const uint8_t *)&cmd[1];
while(body + sizeof(SVGASignedRect) <= next) {
dump_SVGASignedRect((const SVGASignedRect *)body);
body += sizeof(SVGASignedRect);
}
}
break;
case SVGA_3D_CMD_DEFINE_GB_CONTEXT:
_debug_printf("\tSVGA_3D_CMD_DEFINE_GB_CONTEXT\n");
{
const SVGA3dCmdDefineGBContext *cmd = (const SVGA3dCmdDefineGBContext *) body;
dump_SVGA3dCmdDefineGBContext(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_BIND_GB_CONTEXT:
_debug_printf("\tSVGA_3D_CMD_BIND_GB_CONTEXT\n");
{
const SVGA3dCmdBindGBContext *cmd = (const SVGA3dCmdBindGBContext *) body;
dump_SVGA3dCmdBindGBContext(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_DESTROY_GB_CONTEXT:
_debug_printf("\tSVGA_3D_CMD_DESTROY_GB_CONTEXT\n");
{
const SVGA3dCmdDestroyGBContext *cmd = (const SVGA3dCmdDestroyGBContext *) body;
dump_SVGA3dCmdDestroyGBContext(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_DEFINE_GB_SHADER:
_debug_printf("\tSVGA_3D_CMD_DEFINE_GB_SHADER\n");
{
const SVGA3dCmdDefineGBShader *cmd = (const SVGA3dCmdDefineGBShader *) body;
dump_SVGA3dCmdDefineGBShader(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_BIND_GB_SHADER:
_debug_printf("\tSVGA_3D_CMD_BIND_GB_SHADER\n");
{
const SVGA3dCmdBindGBShader *cmd = (const SVGA3dCmdBindGBShader *) body;
dump_SVGA3dCmdBindGBShader(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_DESTROY_GB_SHADER:
_debug_printf("\tSVGA_3D_CMD_DESTROY_GB_SHADER\n");
{
const SVGA3dCmdDestroyGBShader *cmd = (const SVGA3dCmdDestroyGBShader *) body;
dump_SVGA3dCmdDestroyGBShader(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_BIND_SHADERCONSTS:
_debug_printf("\tSVGA_3D_CMD_BIND_SHADERCONSTS\n");
{
const SVGA3dCmdBindGBShaderConsts *cmd = (const SVGA3dCmdBindGBShaderConsts *) body;
dump_SVGA3dCmdBindGBShaderConsts(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_BIND_GB_SURFACE:
_debug_printf("\tSVGA_3D_CMD_BIND_GB_SURFACE\n");
{
const SVGA3dCmdBindGBSurface *cmd = (const SVGA3dCmdBindGBSurface *) body;
dump_SVGA3dCmdBindGBSurface(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_UPDATE_GB_SURFACE:
_debug_printf("\tSVGA_3D_CMD_UPDATE_GB_SURFACE\n");
{
const SVGA3dCmdUpdateGBSurface *cmd = (const SVGA3dCmdUpdateGBSurface *) body;
dump_SVGA3dCmdUpdateGBSurface(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_READBACK_GB_IMAGE:
_debug_printf("\tSVGA_3D_CMD_READBACK_GB_IMAGE:\n");
{
const SVGA3dCmdReadbackGBImage *cmd = (SVGA3dCmdReadbackGBImage *) body;
dump_SVGA3dCmdReadbackGBImage(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_UPDATE_GB_IMAGE:
_debug_printf("\tSVGA_3D_CMD_UPDATE_GB_IMAGE\n");
{
const SVGA3dCmdUpdateGBImage *cmd = (const SVGA3dCmdUpdateGBImage *) body;
dump_SVGA3dCmdUpdateGBImage(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_INVALIDATE_GB_IMAGE:
_debug_printf("\tSVGA_3D_CMD_INVALIDATE_GB_IMAGE\n");
{
const SVGA3dCmdInvalidateGBImage *cmd = (const SVGA3dCmdInvalidateGBImage *) body;
dump_SVGA3dCmdInvalidateGBImage(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_INVALIDATE_GB_IMAGE_PARTIAL:
_debug_printf("\tSVGA_3D_CMD_INVALIDATE_GB_IMAGE_PARTIAL\n");
{
const SVGA3dCmdInvalidateGBImagePartial *cmd = (const SVGA3dCmdInvalidateGBImagePartial *) body;
dump_SVGA3dCmdInvalidateGBImagePartial(cmd);
body = (const uint8_t *)&cmd[1];
}
break;
case SVGA_3D_CMD_SET_GB_SHADERCONSTS_INLINE:
_debug_printf("\tSVGA_3D_CMD_SET_GB_SHADERCONSTS_INLINE\n");
{
/* XXX Note: re-using the SVGA3dCmdSetShaderConst code here */
const SVGA3dCmdSetGBShaderConstInline *cmd = (const SVGA3dCmdSetGBShaderConstInline *)body;
uint32 numConsts = (size - sizeof *cmd) / (4 * sizeof(uint32));
dump_SVGA3dCmdSetGBShaderConstInline(cmd, numConsts);
body = next;
}
break;
default:
_debug_printf("\t0x%08x\n", cmd_id);
break;
}
while(body + sizeof(uint32_t) <= next) {
_debug_printf("\t\t0x%08x\n", *(const uint32_t *)body);
body += sizeof(uint32_t);
}
while(body + sizeof(uint32_t) <= next)
_debug_printf("\t\t0x%02x\n", *body++);
}
void
svga_dump_commands(const void *commands, uint32_t size)
{
const uint8_t *next = commands;
const uint8_t *last = next + size;
assert(size % sizeof(uint32_t) == 0);
while(next < last) {
const uint32_t cmd_id = *(const uint32_t *)next;
if(SVGA_3D_CMD_BASE <= cmd_id && cmd_id < SVGA_3D_CMD_MAX) {
const SVGA3dCmdHeader *header = (const SVGA3dCmdHeader *)next;
const uint8_t *body = (const uint8_t *)&header[1];
next = body + header->size;
if(next > last)
break;
svga_dump_command(cmd_id, body, header->size);
}
else if(cmd_id == SVGA_CMD_FENCE) {
_debug_printf("\tSVGA_CMD_FENCE\n");
_debug_printf("\t\t0x%08x\n", ((const uint32_t *)next)[1]);
next += 2*sizeof(uint32_t);
}
else {
_debug_printf("\t0x%08x\n", cmd_id);
next += sizeof(uint32_t);
}
}
}

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_dump.h
0,0 → 1,37
/**********************************************************
* Copyright 2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
#ifndef SVGA_DUMP_H_
#define SVGA_DUMP_H_
#include "pipe/p_compiler.h"
void
svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size);
void
svga_dump_commands(const void *commands, uint32_t size);
#endif /* SVGA_DUMP_H_ */

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_dump.py
0,0 → 1,340
#!/usr/bin/env python
'''
Generates dumper for the SVGA 3D command stream using pygccxml.
Jose Fonseca <jfonseca@vmware.com>
'''
copyright = '''
/**********************************************************
* Copyright 2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
'''
import os
import sys
from pygccxml import parser
from pygccxml import declarations
from pygccxml.declarations import algorithm
from pygccxml.declarations import decl_visitor
from pygccxml.declarations import type_traits
from pygccxml.declarations import type_visitor
enums = True
class decl_dumper_t(decl_visitor.decl_visitor_t):
def __init__(self, instance = '', decl = None):
decl_visitor.decl_visitor_t.__init__(self)
self._instance = instance
self.decl = decl
def clone(self):
return decl_dumper_t(self._instance, self.decl)
def visit_class(self):
class_ = self.decl
assert self.decl.class_type in ('struct', 'union')
for variable in class_.variables():
if variable.name != '':
#print 'variable = %r' % variable.name
dump_type(self._instance + '.' + variable.name, variable.type)
def visit_enumeration(self):
if enums:
print ' switch(%s) {' % ("(*cmd)" + self._instance,)
for name, value in self.decl.values:
print ' case %s:' % (name,)
print ' _debug_printf("\\t\\t%s = %s\\n");' % (self._instance, name)
print ' break;'
print ' default:'
print ' _debug_printf("\\t\\t%s = %%i\\n", %s);' % (self._instance, "(*cmd)" + self._instance)
print ' break;'
print ' }'
else:
print ' _debug_printf("\\t\\t%s = %%i\\n", %s);' % (self._instance, "(*cmd)" + self._instance)
def dump_decl(instance, decl):
dumper = decl_dumper_t(instance, decl)
algorithm.apply_visitor(dumper, decl)
class type_dumper_t(type_visitor.type_visitor_t):
def __init__(self, instance, type_):
type_visitor.type_visitor_t.__init__(self)
self.instance = instance
self.type = type_
def clone(self):
return type_dumper_t(self.instance, self.type)
def visit_char(self):
self.print_instance('%i')
def visit_unsigned_char(self):
self.print_instance('%u')
def visit_signed_char(self):
self.print_instance('%i')
def visit_wchar(self):
self.print_instance('%i')
def visit_short_int(self):
self.print_instance('%i')
def visit_short_unsigned_int(self):
self.print_instance('%u')
def visit_bool(self):
self.print_instance('%i')
def visit_int(self):
self.print_instance('%i')
def visit_unsigned_int(self):
self.print_instance('%u')
def visit_long_int(self):
self.print_instance('%li')
def visit_long_unsigned_int(self):
self.print_instance('%lu')
def visit_long_long_int(self):
self.print_instance('%lli')
def visit_long_long_unsigned_int(self):
self.print_instance('%llu')
def visit_float(self):
self.print_instance('%f')
def visit_double(self):
self.print_instance('%f')
def visit_array(self):
for i in range(type_traits.array_size(self.type)):
dump_type(self.instance + '[%i]' % i, type_traits.base_type(self.type))
def visit_pointer(self):
self.print_instance('%p')
def visit_declarated(self):
#print 'decl = %r' % self.type.decl_string
decl = type_traits.remove_declarated(self.type)
dump_decl(self.instance, decl)
def print_instance(self, format):
print ' _debug_printf("\\t\\t%s = %s\\n", %s);' % (self.instance, format, "(*cmd)" + self.instance)
def dump_type(instance, type_):
type_ = type_traits.remove_alias(type_)
visitor = type_dumper_t(instance, type_)
algorithm.apply_visitor(visitor, type_)
def dump_struct(decls, class_):
print 'static void'
print 'dump_%s(const %s *cmd)' % (class_.name, class_.name)
print '{'
dump_decl('', class_)
print '}'
print ''
cmds = [
('SVGA_3D_CMD_SURFACE_DEFINE', 'SVGA3dCmdDefineSurface', (), 'SVGA3dSize'),
('SVGA_3D_CMD_SURFACE_DESTROY', 'SVGA3dCmdDestroySurface', (), None),
('SVGA_3D_CMD_SURFACE_COPY', 'SVGA3dCmdSurfaceCopy', (), 'SVGA3dCopyBox'),
('SVGA_3D_CMD_SURFACE_STRETCHBLT', 'SVGA3dCmdSurfaceStretchBlt', (), None),
('SVGA_3D_CMD_SURFACE_DMA', 'SVGA3dCmdSurfaceDMA', (), 'SVGA3dCopyBox'),
('SVGA_3D_CMD_CONTEXT_DEFINE', 'SVGA3dCmdDefineContext', (), None),
('SVGA_3D_CMD_CONTEXT_DESTROY', 'SVGA3dCmdDestroyContext', (), None),
('SVGA_3D_CMD_SETTRANSFORM', 'SVGA3dCmdSetTransform', (), None),
('SVGA_3D_CMD_SETZRANGE', 'SVGA3dCmdSetZRange', (), None),
('SVGA_3D_CMD_SETRENDERSTATE', 'SVGA3dCmdSetRenderState', (), 'SVGA3dRenderState'),
('SVGA_3D_CMD_SETRENDERTARGET', 'SVGA3dCmdSetRenderTarget', (), None),
('SVGA_3D_CMD_SETTEXTURESTATE', 'SVGA3dCmdSetTextureState', (), 'SVGA3dTextureState'),
('SVGA_3D_CMD_SETMATERIAL', 'SVGA3dCmdSetMaterial', (), None),
('SVGA_3D_CMD_SETLIGHTDATA', 'SVGA3dCmdSetLightData', (), None),
('SVGA_3D_CMD_SETLIGHTENABLED', 'SVGA3dCmdSetLightEnabled', (), None),
('SVGA_3D_CMD_SETVIEWPORT', 'SVGA3dCmdSetViewport', (), None),
('SVGA_3D_CMD_SETCLIPPLANE', 'SVGA3dCmdSetClipPlane', (), None),
('SVGA_3D_CMD_CLEAR', 'SVGA3dCmdClear', (), 'SVGA3dRect'),
('SVGA_3D_CMD_PRESENT', 'SVGA3dCmdPresent', (), 'SVGA3dCopyRect'),
('SVGA_3D_CMD_SHADER_DEFINE', 'SVGA3dCmdDefineShader', (), None),
('SVGA_3D_CMD_SHADER_DESTROY', 'SVGA3dCmdDestroyShader', (), None),
('SVGA_3D_CMD_SET_SHADER', 'SVGA3dCmdSetShader', (), None),
('SVGA_3D_CMD_SET_SHADER_CONST', 'SVGA3dCmdSetShaderConst', (), None),
('SVGA_3D_CMD_DRAW_PRIMITIVES', 'SVGA3dCmdDrawPrimitives', (('SVGA3dVertexDecl', 'numVertexDecls'), ('SVGA3dPrimitiveRange', 'numRanges')), 'SVGA3dVertexDivisor'),
('SVGA_3D_CMD_SETSCISSORRECT', 'SVGA3dCmdSetScissorRect', (), None),
('SVGA_3D_CMD_BEGIN_QUERY', 'SVGA3dCmdBeginQuery', (), None),
('SVGA_3D_CMD_END_QUERY', 'SVGA3dCmdEndQuery', (), None),
('SVGA_3D_CMD_WAIT_FOR_QUERY', 'SVGA3dCmdWaitForQuery', (), None),
#('SVGA_3D_CMD_PRESENT_READBACK', None, (), None),
('SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN', 'SVGA3dCmdBlitSurfaceToScreen', (), 'SVGASignedRect'),
]
def dump_cmds():
print r'''
void
svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size)
{
const uint8_t *body = (const uint8_t *)data;
const uint8_t *next = body + size;
'''
print ' switch(cmd_id) {'
indexes = 'ijklmn'
for id, header, body, footer in cmds:
print ' case %s:' % id
print ' _debug_printf("\\t%s\\n");' % id
print ' {'
print ' const %s *cmd = (const %s *)body;' % (header, header)
if len(body):
print ' unsigned ' + ', '.join(indexes[:len(body)]) + ';'
print ' dump_%s(cmd);' % header
print ' body = (const uint8_t *)&cmd[1];'
for i in range(len(body)):
struct, count = body[i]
idx = indexes[i]
print ' for(%s = 0; %s < cmd->%s; ++%s) {' % (idx, idx, count, idx)
print ' dump_%s((const %s *)body);' % (struct, struct)
print ' body += sizeof(%s);' % struct
print ' }'
if footer is not None:
print ' while(body + sizeof(%s) <= next) {' % footer
print ' dump_%s((const %s *)body);' % (footer, footer)
print ' body += sizeof(%s);' % footer
print ' }'
if id == 'SVGA_3D_CMD_SHADER_DEFINE':
print ' svga_shader_dump((const uint32_t *)body,'
print ' (unsigned)(next - body)/sizeof(uint32_t),'
print ' FALSE);'
print ' body = next;'
print ' }'
print ' break;'
print ' default:'
print ' _debug_printf("\\t0x%08x\\n", cmd_id);'
print ' break;'
print ' }'
print r'''
while(body + sizeof(uint32_t) <= next) {
_debug_printf("\t\t0x%08x\n", *(const uint32_t *)body);
body += sizeof(uint32_t);
}
while(body + sizeof(uint32_t) <= next)
_debug_printf("\t\t0x%02x\n", *body++);
}
'''
print r'''
void
svga_dump_commands(const void *commands, uint32_t size)
{
const uint8_t *next = commands;
const uint8_t *last = next + size;
assert(size % sizeof(uint32_t) == 0);
while(next < last) {
const uint32_t cmd_id = *(const uint32_t *)next;
if(SVGA_3D_CMD_BASE <= cmd_id && cmd_id < SVGA_3D_CMD_MAX) {
const SVGA3dCmdHeader *header = (const SVGA3dCmdHeader *)next;
const uint8_t *body = (const uint8_t *)&header[1];
next = body + header->size;
if(next > last)
break;
svga_dump_command(cmd_id, body, header->size);
}
else if(cmd_id == SVGA_CMD_FENCE) {
_debug_printf("\tSVGA_CMD_FENCE\n");
_debug_printf("\t\t0x%08x\n", ((const uint32_t *)next)[1]);
next += 2*sizeof(uint32_t);
}
else {
_debug_printf("\t0x%08x\n", cmd_id);
next += sizeof(uint32_t);
}
}
}
'''
def main():
print copyright.strip()
print
print '/**'
print ' * @file'
print ' * Dump SVGA commands.'
print ' *'
print ' * Generated automatically from svga3d_reg.h by svga_dump.py.'
print ' */'
print
print '#include "svga_types.h"'
print '#include "svga_shader_dump.h"'
print '#include "svga3d_reg.h"'
print
print '#include "util/u_debug.h"'
print '#include "svga_dump.h"'
print
config = parser.config_t(
include_paths = ['../../../include', '../include'],
compiler = 'gcc',
)
headers = [
'svga_types.h',
'svga3d_reg.h',
]
decls = parser.parse(headers, config, parser.COMPILATION_MODE.ALL_AT_ONCE)
global_ns = declarations.get_global_namespace(decls)
names = set()
for id, header, body, footer in cmds:
names.add(header)
for struct, count in body:
names.add(struct)
if footer is not None:
names.add(footer)
for class_ in global_ns.classes(lambda decl: decl.name in names):
dump_struct(decls, class_)
dump_cmds()
if __name__ == '__main__':
main()

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_shader.h
0,0 → 1,227
/**********************************************************
* Copyright 2007-2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
/**
* @file
* SVGA Shader Token Definitions
*
* @author Michal Krol <michal@vmware.com>
*/
#ifndef ST_SHADER_SVGA_H
#define ST_SHADER_SVGA_H
#include "pipe/p_compiler.h"
struct sh_op
{
unsigned opcode:16;
unsigned control:8;
unsigned length:4;
unsigned predicated:1;
unsigned unused:1;
unsigned coissue:1;
unsigned is_reg:1;
};
struct sh_reg
{
unsigned number:11;
unsigned type_hi:2;
unsigned relative:1;
unsigned unused:14;
unsigned type_lo:3;
unsigned is_reg:1;
};
static INLINE unsigned
sh_reg_type( struct sh_reg reg )
{
return reg.type_lo | (reg.type_hi << 3);
}
struct sh_cdata
{
float xyzw[4];
};
struct sh_def
{
struct sh_op op;
struct sh_reg reg;
struct sh_cdata cdata;
};
struct sh_defb
{
struct sh_op op;
struct sh_reg reg;
uint data;
};
struct sh_idata
{
int xyzw[4];
};
struct sh_defi
{
struct sh_op op;
struct sh_reg reg;
struct sh_idata idata;
};
#define PS_TEXTURETYPE_UNKNOWN SVGA3DSAMP_UNKNOWN
#define PS_TEXTURETYPE_2D SVGA3DSAMP_2D
#define PS_TEXTURETYPE_CUBE SVGA3DSAMP_CUBE
#define PS_TEXTURETYPE_VOLUME SVGA3DSAMP_VOLUME
struct sh_sampleinfo
{
unsigned unused:27;
unsigned texture_type:4;
unsigned is_reg:1;
};
struct sh_semantic
{
unsigned usage:4;
unsigned unused1:12;
unsigned usage_index:4;
unsigned unused2:11;
unsigned is_reg:1;
};
#define SH_WRITEMASK_0 0x1
#define SH_WRITEMASK_1 0x2
#define SH_WRITEMASK_2 0x4
#define SH_WRITEMASK_3 0x8
#define SH_WRITEMASK_ALL 0xf
#define SH_DSTMOD_NONE 0x0
#define SH_DSTMOD_SATURATE 0x1
#define SH_DSTMOD_PARTIALPRECISION 0x2
#define SH_DSTMOD_MSAMPCENTROID 0x4
struct sh_dstreg
{
unsigned number:11;
unsigned type_hi:2;
unsigned relative:1;
unsigned unused:2;
unsigned write_mask:4;
unsigned modifier:4;
unsigned shift_scale:4;
unsigned type_lo:3;
unsigned is_reg:1;
};
static INLINE unsigned
sh_dstreg_type( struct sh_dstreg reg )
{
return reg.type_lo | (reg.type_hi << 3);
}
struct sh_dcl
{
struct sh_op op;
union {
struct sh_sampleinfo sampleinfo;
struct sh_semantic semantic;
} u;
struct sh_dstreg reg;
};
struct sh_srcreg
{
unsigned number:11;
unsigned type_hi:2;
unsigned relative:1;
unsigned unused:2;
unsigned swizzle_x:2;
unsigned swizzle_y:2;
unsigned swizzle_z:2;
unsigned swizzle_w:2;
unsigned modifier:4;
unsigned type_lo:3;
unsigned is_reg:1;
};
static INLINE unsigned
sh_srcreg_type( struct sh_srcreg reg )
{
return reg.type_lo | (reg.type_hi << 3);
}
struct sh_dstop
{
struct sh_op op;
struct sh_dstreg dst;
};
struct sh_srcop
{
struct sh_op op;
struct sh_srcreg src;
};
struct sh_src2op
{
struct sh_op op;
struct sh_srcreg src0;
struct sh_srcreg src1;
};
struct sh_unaryop
{
struct sh_op op;
struct sh_dstreg dst;
struct sh_srcreg src;
};
struct sh_binaryop
{
struct sh_op op;
struct sh_dstreg dst;
struct sh_srcreg src0;
struct sh_srcreg src1;
};
struct sh_trinaryop
{
struct sh_op op;
struct sh_dstreg dst;
struct sh_srcreg src0;
struct sh_srcreg src1;
struct sh_srcreg src2;
};
struct sh_comment
{
unsigned opcode:16;
unsigned size:16;
};
#endif /* ST_SHADER_SVGA_H */

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_shader_dump.c
0,0 → 1,722
/**********************************************************
* Copyright 2008-2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
/**
* @file
* SVGA Shader Dump Facilities
*
* @author Michal Krol <michal@vmware.com>
*/
#include "svga_shader.h"
#include "svga_shader_dump.h"
#include "svga_shader_op.h"
#include "util/u_debug.h"
#include "../svga_hw_reg.h"
#include "svga3d_shaderdefs.h"
struct dump_info
{
uint32 version;
boolean is_ps;
int indent;
};
#define DUMP_MAX_OP_SRC 4
struct dump_op
{
struct sh_op op;
struct sh_dstreg dst;
struct sh_srcreg dstind;
struct sh_srcreg src[DUMP_MAX_OP_SRC];
struct sh_srcreg srcind[DUMP_MAX_OP_SRC];
struct sh_srcreg p0;
};
static void
dump_indent(int indent)
{
int i;
for (i = 0; i < indent; ++i) {
_debug_printf(" ");
}
}
static void dump_op( struct sh_op op, const char *mnemonic )
{
assert( op.is_reg == 0 );
if (op.predicated) {
_debug_printf("(p0) ");
}
if (op.coissue)
_debug_printf( "+" );
_debug_printf( "%s", mnemonic );
switch (op.opcode) {
case SVGA3DOP_TEX:
switch (op.control) {
case 0:
break;
case 1 /* PROJECT */:
_debug_printf("p");
break;
case 2 /* BIAS */:
_debug_printf("b");
break;
default:
assert(0);
}
break;
case SVGA3DOP_IFC:
case SVGA3DOP_BREAKC:
case SVGA3DOP_SETP:
switch (op.control) {
case SVGA3DOPCOMP_GT:
_debug_printf("_gt");
break;
case SVGA3DOPCOMP_EQ:
_debug_printf("_eq");
break;
case SVGA3DOPCOMP_GE:
_debug_printf("_ge");
break;
case SVGA3DOPCOMP_LT:
_debug_printf("_lt");
break;
case SVGA3DOPCOMPC_NE:
_debug_printf("_ne");
break;
case SVGA3DOPCOMP_LE:
_debug_printf("_le");
break;
default:
assert(0);
}
break;
default:
assert(op.control == 0);
}
}
static void
format_reg(const char *name,
const struct sh_reg reg,
const struct sh_srcreg *indreg)
{
if (reg.relative) {
assert(indreg);
if (sh_srcreg_type(*indreg) == SVGA3DREG_LOOP) {
_debug_printf("%s[aL+%u]", name, reg.number);
} else {
_debug_printf("%s[a%u.x+%u]", name, indreg->number, reg.number);
}
} else {
_debug_printf("%s%u", name, reg.number);
}
}
static void dump_reg( struct sh_reg reg, struct sh_srcreg *indreg, const struct dump_info *di )
{
assert( reg.is_reg == 1 );
switch (sh_reg_type( reg )) {
case SVGA3DREG_TEMP:
format_reg("r", reg, NULL);
break;
case SVGA3DREG_INPUT:
format_reg("v", reg, indreg);
break;
case SVGA3DREG_CONST:
format_reg("c", reg, indreg);
break;
case SVGA3DREG_ADDR: /* VS */
/* SVGA3DREG_TEXTURE */ /* PS */
assert(!reg.relative);
if (di->is_ps) {
format_reg("t", reg, NULL);
} else {
format_reg("a", reg, NULL);
}
break;
case SVGA3DREG_RASTOUT:
assert(!reg.relative);
switch (reg.number) {
case 0 /*POSITION*/:
_debug_printf( "oPos" );
break;
case 1 /*FOG*/:
_debug_printf( "oFog" );
break;
case 2 /*POINT_SIZE*/:
_debug_printf( "oPts" );
break;
default:
assert( 0 );
_debug_printf( "???" );
}
break;
case SVGA3DREG_ATTROUT:
assert( reg.number < 2 );
format_reg("oD", reg, NULL);
break;
case SVGA3DREG_TEXCRDOUT: /* VS */
/* SVGA3DREG_OUTPUT */ /* VS3.0+ */
if (!di->is_ps && di->version >= SVGA3D_VS_30) {
format_reg("o", reg, indreg);
} else {
format_reg("oT", reg, NULL);
}
break;
case SVGA3DREG_COLOROUT:
format_reg("oC", reg, NULL);
break;
case SVGA3DREG_DEPTHOUT:
assert(!reg.relative);
assert(reg.number == 0);
_debug_printf("oDepth");
break;
case SVGA3DREG_SAMPLER:
format_reg("s", reg, NULL);
break;
case SVGA3DREG_CONSTBOOL:
format_reg("b", reg, NULL);
break;
case SVGA3DREG_CONSTINT:
format_reg("i", reg, NULL);
break;
case SVGA3DREG_LOOP:
assert(!reg.relative);
assert( reg.number == 0 );
_debug_printf( "aL" );
break;
case SVGA3DREG_MISCTYPE:
assert(!reg.relative);
switch (reg.number) {
case SVGA3DMISCREG_POSITION:
_debug_printf("vPos");
break;
case SVGA3DMISCREG_FACE:
_debug_printf("vFace");
break;
default:
assert(0);
_debug_printf("???");
}
break;
case SVGA3DREG_LABEL:
format_reg("l", reg, NULL);
break;
case SVGA3DREG_PREDICATE:
format_reg("p", reg, NULL);
break;
default:
assert( 0 );
_debug_printf( "???" );
}
}
static void dump_cdata( struct sh_cdata cdata )
{
_debug_printf( "%f, %f, %f, %f", cdata.xyzw[0], cdata.xyzw[1], cdata.xyzw[2], cdata.xyzw[3] );
}
static void dump_idata( struct sh_idata idata )
{
_debug_printf( "%d, %d, %d, %d", idata.xyzw[0], idata.xyzw[1], idata.xyzw[2], idata.xyzw[3] );
}
static void dump_bdata( boolean bdata )
{
_debug_printf( bdata ? "TRUE" : "FALSE" );
}
static void
dump_sampleinfo(struct sh_sampleinfo sampleinfo)
{
assert( sampleinfo.is_reg == 1 );
switch (sampleinfo.texture_type) {
case SVGA3DSAMP_2D:
_debug_printf( "_2d" );
break;
case SVGA3DSAMP_CUBE:
_debug_printf( "_cube" );
break;
case SVGA3DSAMP_VOLUME:
_debug_printf( "_volume" );
break;
default:
assert( 0 );
}
}
static void
dump_semantic(uint usage,
uint usage_index)
{
switch (usage) {
case SVGA3D_DECLUSAGE_POSITION:
_debug_printf("_position");
break;
case SVGA3D_DECLUSAGE_BLENDWEIGHT:
_debug_printf("_blendweight");
break;
case SVGA3D_DECLUSAGE_BLENDINDICES:
_debug_printf("_blendindices");
break;
case SVGA3D_DECLUSAGE_NORMAL:
_debug_printf("_normal");
break;
case SVGA3D_DECLUSAGE_PSIZE:
_debug_printf("_psize");
break;
case SVGA3D_DECLUSAGE_TEXCOORD:
_debug_printf("_texcoord");
break;
case SVGA3D_DECLUSAGE_TANGENT:
_debug_printf("_tangent");
break;
case SVGA3D_DECLUSAGE_BINORMAL:
_debug_printf("_binormal");
break;
case SVGA3D_DECLUSAGE_TESSFACTOR:
_debug_printf("_tessfactor");
break;
case SVGA3D_DECLUSAGE_POSITIONT:
_debug_printf("_positiont");
break;
case SVGA3D_DECLUSAGE_COLOR:
_debug_printf("_color");
break;
case SVGA3D_DECLUSAGE_FOG:
_debug_printf("_fog");
break;
case SVGA3D_DECLUSAGE_DEPTH:
_debug_printf("_depth");
break;
case SVGA3D_DECLUSAGE_SAMPLE:
_debug_printf("_sample");
break;
default:
assert(!"Unknown usage");
_debug_printf("_???");
}
if (usage_index) {
_debug_printf("%u", usage_index);
}
}
static void
dump_dstreg(struct sh_dstreg dstreg,
struct sh_srcreg *indreg,
const struct dump_info *di)
{
union {
struct sh_reg reg;
struct sh_dstreg dstreg;
} u;
memset(&u, 0, sizeof(u));
assert( (dstreg.modifier & (SVGA3DDSTMOD_SATURATE | SVGA3DDSTMOD_PARTIALPRECISION)) == dstreg.modifier );
if (dstreg.modifier & SVGA3DDSTMOD_SATURATE)
_debug_printf( "_sat" );
if (dstreg.modifier & SVGA3DDSTMOD_PARTIALPRECISION)
_debug_printf( "_pp" );
switch (dstreg.shift_scale) {
case 0:
break;
case 1:
_debug_printf( "_x2" );
break;
case 2:
_debug_printf( "_x4" );
break;
case 3:
_debug_printf( "_x8" );
break;
case 13:
_debug_printf( "_d8" );
break;
case 14:
_debug_printf( "_d4" );
break;
case 15:
_debug_printf( "_d2" );
break;
default:
assert( 0 );
}
_debug_printf( " " );
u.dstreg = dstreg;
dump_reg( u.reg, indreg, di);
if (dstreg.write_mask != SVGA3DWRITEMASK_ALL) {
_debug_printf( "." );
if (dstreg.write_mask & SVGA3DWRITEMASK_0)
_debug_printf( "x" );
if (dstreg.write_mask & SVGA3DWRITEMASK_1)
_debug_printf( "y" );
if (dstreg.write_mask & SVGA3DWRITEMASK_2)
_debug_printf( "z" );
if (dstreg.write_mask & SVGA3DWRITEMASK_3)
_debug_printf( "w" );
}
}
static void dump_srcreg( struct sh_srcreg srcreg, struct sh_srcreg *indreg, const struct dump_info *di )
{
switch (srcreg.modifier) {
case SVGA3DSRCMOD_NEG:
case SVGA3DSRCMOD_BIASNEG:
case SVGA3DSRCMOD_SIGNNEG:
case SVGA3DSRCMOD_X2NEG:
case SVGA3DSRCMOD_ABSNEG:
_debug_printf( "-" );
break;
case SVGA3DSRCMOD_COMP:
_debug_printf( "1-" );
break;
case SVGA3DSRCMOD_NOT:
_debug_printf( "!" );
}
dump_reg( *(struct sh_reg *) &srcreg, indreg, di );
switch (srcreg.modifier) {
case SVGA3DSRCMOD_NONE:
case SVGA3DSRCMOD_NEG:
case SVGA3DSRCMOD_COMP:
case SVGA3DSRCMOD_NOT:
break;
case SVGA3DSRCMOD_BIAS:
case SVGA3DSRCMOD_BIASNEG:
_debug_printf( "_bias" );
break;
case SVGA3DSRCMOD_SIGN:
case SVGA3DSRCMOD_SIGNNEG:
_debug_printf( "_bx2" );
break;
case SVGA3DSRCMOD_X2:
case SVGA3DSRCMOD_X2NEG:
_debug_printf( "_x2" );
break;
case SVGA3DSRCMOD_DZ:
_debug_printf( "_dz" );
break;
case SVGA3DSRCMOD_DW:
_debug_printf( "_dw" );
break;
case SVGA3DSRCMOD_ABS:
case SVGA3DSRCMOD_ABSNEG:
_debug_printf("_abs");
break;
default:
assert( 0 );
}
if (srcreg.swizzle_x != 0 || srcreg.swizzle_y != 1 || srcreg.swizzle_z != 2 || srcreg.swizzle_w != 3) {
_debug_printf( "." );
if (srcreg.swizzle_x == srcreg.swizzle_y && srcreg.swizzle_y == srcreg.swizzle_z && srcreg.swizzle_z == srcreg.swizzle_w) {
_debug_printf( "%c", "xyzw"[srcreg.swizzle_x] );
}
else {
_debug_printf( "%c", "xyzw"[srcreg.swizzle_x] );
_debug_printf( "%c", "xyzw"[srcreg.swizzle_y] );
_debug_printf( "%c", "xyzw"[srcreg.swizzle_z] );
_debug_printf( "%c", "xyzw"[srcreg.swizzle_w] );
}
}
}
static void
parse_op(struct dump_info *di,
const uint **token,
struct dump_op *op,
uint num_dst,
uint num_src)
{
uint i;
assert(num_dst <= 1);
assert(num_src <= DUMP_MAX_OP_SRC);
op->op = *(struct sh_op *)*token;
*token += sizeof(struct sh_op) / sizeof(uint);
if (num_dst >= 1) {
op->dst = *(struct sh_dstreg *)*token;
*token += sizeof(struct sh_dstreg) / sizeof(uint);
if (op->dst.relative &&
(!di->is_ps && di->version >= SVGA3D_VS_30)) {
op->dstind = *(struct sh_srcreg *)*token;
*token += sizeof(struct sh_srcreg) / sizeof(uint);
}
}
if (op->op.predicated) {
op->p0 = *(struct sh_srcreg *)*token;
*token += sizeof(struct sh_srcreg) / sizeof(uint);
}
for (i = 0; i < num_src; ++i) {
op->src[i] = *(struct sh_srcreg *)*token;
*token += sizeof(struct sh_srcreg) / sizeof(uint);
if (op->src[i].relative &&
((!di->is_ps && di->version >= SVGA3D_VS_20) ||
(di->is_ps && di->version >= SVGA3D_PS_30))) {
op->srcind[i] = *(struct sh_srcreg *)*token;
*token += sizeof(struct sh_srcreg) / sizeof(uint);
}
}
}
static void
dump_inst(struct dump_info *di,
const unsigned **assem,
struct sh_op op,
const struct sh_opcode_info *info)
{
struct dump_op dop;
boolean not_first_arg = FALSE;
uint i;
assert(info->num_dst <= 1);
di->indent -= info->pre_dedent;
dump_indent(di->indent);
di->indent += info->post_indent;
dump_op(op, info->mnemonic);
parse_op(di, assem, &dop, info->num_dst, info->num_src);
if (info->num_dst > 0) {
dump_dstreg(dop.dst, &dop.dstind, di);
not_first_arg = TRUE;
}
for (i = 0; i < info->num_src; i++) {
if (not_first_arg) {
_debug_printf(", ");
} else {
_debug_printf(" ");
}
dump_srcreg(dop.src[i], &dop.srcind[i], di);
not_first_arg = TRUE;
}
_debug_printf("\n");
}
void
svga_shader_dump(
const unsigned *assem,
unsigned dwords,
unsigned do_binary )
{
boolean finished = FALSE;
struct dump_info di;
di.version = *assem++;
di.is_ps = (di.version & 0xFFFF0000) == 0xFFFF0000;
di.indent = 0;
_debug_printf(
"%s_%u_%u\n",
di.is_ps ? "ps" : "vs",
(di.version >> 8) & 0xff,
di.version & 0xff );
while (!finished) {
struct sh_op op = *(struct sh_op *) assem;
switch (op.opcode) {
case SVGA3DOP_DCL:
{
struct sh_dcl dcl = *(struct sh_dcl *) assem;
_debug_printf( "dcl" );
switch (sh_dstreg_type(dcl.reg)) {
case SVGA3DREG_INPUT:
if ((di.is_ps && di.version >= SVGA3D_PS_30) ||
(!di.is_ps && di.version >= SVGA3D_VS_30)) {
dump_semantic(dcl.u.semantic.usage,
dcl.u.semantic.usage_index);
}
break;
case SVGA3DREG_TEXCRDOUT:
if (!di.is_ps && di.version >= SVGA3D_VS_30) {
dump_semantic(dcl.u.semantic.usage,
dcl.u.semantic.usage_index);
}
break;
case SVGA3DREG_SAMPLER:
dump_sampleinfo( dcl.u.sampleinfo );
break;
}
dump_dstreg(dcl.reg, NULL, &di);
_debug_printf( "\n" );
assem += sizeof( struct sh_dcl ) / sizeof( unsigned );
}
break;
case SVGA3DOP_DEFB:
{
struct sh_defb defb = *(struct sh_defb *) assem;
_debug_printf( "defb " );
dump_reg( defb.reg, NULL, &di );
_debug_printf( ", " );
dump_bdata( defb.data );
_debug_printf( "\n" );
assem += sizeof( struct sh_defb ) / sizeof( unsigned );
}
break;
case SVGA3DOP_DEFI:
{
struct sh_defi defi = *(struct sh_defi *) assem;
_debug_printf( "defi " );
dump_reg( defi.reg, NULL, &di );
_debug_printf( ", " );
dump_idata( defi.idata );
_debug_printf( "\n" );
assem += sizeof( struct sh_defi ) / sizeof( unsigned );
}
break;
case SVGA3DOP_TEXCOORD:
{
struct sh_opcode_info info = *svga_opcode_info(op.opcode);
assert(di.is_ps);
if (di.version > SVGA3D_PS_13) {
assert(info.num_src == 0);
info.num_src = 1;
}
dump_inst(&di, &assem, op, &info);
}
break;
case SVGA3DOP_TEX:
{
struct sh_opcode_info info = *svga_opcode_info(op.opcode);
assert(di.is_ps);
if (di.version > SVGA3D_PS_13) {
assert(info.num_src == 0);
if (di.version > SVGA3D_PS_14) {
info.num_src = 2;
info.mnemonic = "texld";
} else {
info.num_src = 1;
}
}
dump_inst(&di, &assem, op, &info);
}
break;
case SVGA3DOP_DEF:
{
struct sh_def def = *(struct sh_def *) assem;
_debug_printf( "def " );
dump_reg( def.reg, NULL, &di );
_debug_printf( ", " );
dump_cdata( def.cdata );
_debug_printf( "\n" );
assem += sizeof( struct sh_def ) / sizeof( unsigned );
}
break;
case SVGA3DOP_SINCOS:
{
struct sh_opcode_info info = *svga_opcode_info(op.opcode);
if ((di.is_ps && di.version >= SVGA3D_PS_30) ||
(!di.is_ps && di.version >= SVGA3D_VS_30)) {
assert(info.num_src == 3);
info.num_src = 1;
}
dump_inst(&di, &assem, op, &info);
}
break;
case SVGA3DOP_PHASE:
_debug_printf( "phase\n" );
assem += sizeof( struct sh_op ) / sizeof( unsigned );
break;
case SVGA3DOP_COMMENT:
{
struct sh_comment comment = *(struct sh_comment *)assem;
/* Ignore comment contents. */
assem += sizeof(struct sh_comment) / sizeof(unsigned) + comment.size;
}
break;
case SVGA3DOP_END:
finished = TRUE;
break;
default:
{
const struct sh_opcode_info *info = svga_opcode_info(op.opcode);
dump_inst(&di, &assem, op, info);
}
}
}
}

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_shader_dump.h
0,0 → 1,42
/**********************************************************
* Copyright 2008-2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
/**
* @file
* SVGA Shader Dump Facilities
*
* @author Michal Krol <michal@vmware.com>
*/
#ifndef SVGA_SHADER_DUMP_H
#define SVGA_SHADER_DUMP_H
void
svga_shader_dump(
const unsigned *assem,
unsigned dwords,
unsigned do_binary );
#endif /* SVGA_SHADER_DUMP_H */

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_shader_op.c
0,0 → 1,170
/**********************************************************
* Copyright 2008-2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
/**
* @file
* SVGA Shader Token Opcode Info
*
* @author Michal Krol <michal@vmware.com>
*/
#include "util/u_debug.h"
#include "svga_shader_op.h"
#include "../svga_hw_reg.h"
#include "svga3d_shaderdefs.h"
#define SVGA3DOP_INVALID SVGA3DOP_END
#define TGSI_OPCODE_INVALID TGSI_OPCODE_LAST
static struct sh_opcode_info opcode_info[] =
{
{ "nop", 0, 0, 0, 0, SVGA3DOP_NOP },
{ "mov", 1, 1, 0, 0, SVGA3DOP_MOV, },
{ "add", 1, 2, 0, 0, SVGA3DOP_ADD, },
{ "sub", 1, 2, 0, 0, SVGA3DOP_SUB, },
{ "mad", 1, 3, 0, 0, SVGA3DOP_MAD, },
{ "mul", 1, 2, 0, 0, SVGA3DOP_MUL, },
{ "rcp", 1, 1, 0, 0, SVGA3DOP_RCP, },
{ "rsq", 1, 1, 0, 0, SVGA3DOP_RSQ, },
{ "dp3", 1, 2, 0, 0, SVGA3DOP_DP3, },
{ "dp4", 1, 2, 0, 0, SVGA3DOP_DP4, },
{ "min", 1, 2, 0, 0, SVGA3DOP_MIN, },
{ "max", 1, 2, 0, 0, SVGA3DOP_MAX, },
{ "slt", 1, 2, 0, 0, SVGA3DOP_SLT, },
{ "sge", 1, 2, 0, 0, SVGA3DOP_SGE, },
{ "exp", 1, 1, 0, 0, SVGA3DOP_EXP, },
{ "log", 1, 1, 0, 0, SVGA3DOP_LOG, },
{ "lit", 1, 1, 0, 0, SVGA3DOP_LIT, },
{ "dst", 1, 2, 0, 0, SVGA3DOP_DST, },
{ "lrp", 1, 3, 0, 0, SVGA3DOP_LRP, },
{ "frc", 1, 1, 0, 0, SVGA3DOP_FRC, },
{ "m4x4", 1, 2, 0, 0, SVGA3DOP_M4x4, },
{ "m4x3", 1, 2, 0, 0, SVGA3DOP_M4x3, },
{ "m3x4", 1, 2, 0, 0, SVGA3DOP_M3x4, },
{ "m3x3", 1, 2, 0, 0, SVGA3DOP_M3x3, },
{ "m3x2", 1, 2, 0, 0, SVGA3DOP_M3x2, },
{ "call", 0, 1, 0, 0, SVGA3DOP_CALL, },
{ "callnz", 0, 2, 0, 0, SVGA3DOP_CALLNZ, },
{ "loop", 0, 2, 0, 1, SVGA3DOP_LOOP, },
{ "ret", 0, 0, 0, 0, SVGA3DOP_RET, },
{ "endloop", 0, 0, 1, 0, SVGA3DOP_ENDLOOP, },
{ "label", 0, 1, 0, 0, SVGA3DOP_LABEL, },
{ "dcl", 0, 0, 0, 0, SVGA3DOP_DCL, },
{ "pow", 1, 2, 0, 0, SVGA3DOP_POW, },
{ "crs", 1, 2, 0, 0, SVGA3DOP_CRS, },
{ "sgn", 1, 3, 0, 0, SVGA3DOP_SGN, },
{ "abs", 1, 1, 0, 0, SVGA3DOP_ABS, },
{ "nrm", 1, 1, 0, 0, SVGA3DOP_NRM, }, /* 3-componenet normalization */
{ "sincos", 1, 3, 0, 0, SVGA3DOP_SINCOS, },
{ "rep", 0, 1, 0, 1, SVGA3DOP_REP, },
{ "endrep", 0, 0, 1, 0, SVGA3DOP_ENDREP, },
{ "if", 0, 1, 0, 1, SVGA3DOP_IF, },
{ "ifc", 0, 2, 0, 1, SVGA3DOP_IFC, },
{ "else", 0, 0, 1, 1, SVGA3DOP_ELSE, },
{ "endif", 0, 0, 1, 0, SVGA3DOP_ENDIF, },
{ "break", 0, 0, 0, 0, SVGA3DOP_BREAK, },
{ "breakc", 0, 2, 0, 0, SVGA3DOP_BREAKC, },
{ "mova", 1, 1, 0, 0, SVGA3DOP_MOVA, },
{ "defb", 0, 0, 0, 0, SVGA3DOP_DEFB, },
{ "defi", 0, 0, 0, 0, SVGA3DOP_DEFI, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "???", 0, 0, 0, 0, SVGA3DOP_INVALID, },
{ "texcoord", 1, 0, 0, 0, SVGA3DOP_TEXCOORD, },
{ "texkill", 1, 0, 0, 0, SVGA3DOP_TEXKILL, },
{ "tex", 1, 0, 0, 0, SVGA3DOP_TEX, },
{ "texbem", 1, 1, 0, 0, SVGA3DOP_TEXBEM, },
{ "texbeml", 1, 1, 0, 0, SVGA3DOP_TEXBEML, },
{ "texreg2ar", 1, 1, 0, 0, SVGA3DOP_TEXREG2AR, },
{ "texreg2gb", 1, 1, 0, 0, SVGA3DOP_TEXREG2GB, },
{ "texm3x2pad", 1, 1, 0, 0, SVGA3DOP_TEXM3x2PAD, },
{ "texm3x2tex", 1, 1, 0, 0, SVGA3DOP_TEXM3x2TEX, },
{ "texm3x3pad", 1, 1, 0, 0, SVGA3DOP_TEXM3x3PAD, },
{ "texm3x3tex", 1, 1, 0, 0, SVGA3DOP_TEXM3x3TEX, },
{ "reserved0", 0, 0, 0, 0, SVGA3DOP_RESERVED0, },
{ "texm3x3spec", 1, 2, 0, 0, SVGA3DOP_TEXM3x3SPEC, },
{ "texm3x3vspec", 1, 1, 0, 0, SVGA3DOP_TEXM3x3VSPEC,},
{ "expp", 1, 1, 0, 0, SVGA3DOP_EXPP, },
{ "logp", 1, 1, 0, 0, SVGA3DOP_LOGP, },
{ "cnd", 1, 3, 0, 0, SVGA3DOP_CND, },
{ "def", 0, 0, 0, 0, SVGA3DOP_DEF, },
{ "texreg2rgb", 1, 1, 0, 0, SVGA3DOP_TEXREG2RGB, },
{ "texdp3tex", 1, 1, 0, 0, SVGA3DOP_TEXDP3TEX, },
{ "texm3x2depth", 1, 1, 0, 0, SVGA3DOP_TEXM3x2DEPTH,},
{ "texdp3", 1, 1, 0, 0, SVGA3DOP_TEXDP3, },
{ "texm3x3", 1, 1, 0, 0, SVGA3DOP_TEXM3x3, },
{ "texdepth", 1, 0, 0, 0, SVGA3DOP_TEXDEPTH, },
{ "cmp", 1, 3, 0, 0, SVGA3DOP_CMP, },
{ "bem", 1, 2, 0, 0, SVGA3DOP_BEM, },
{ "dp2add", 1, 3, 0, 0, SVGA3DOP_DP2ADD, },
{ "dsx", 1, 1, 0, 0, SVGA3DOP_INVALID, },
{ "dsy", 1, 1, 0, 0, SVGA3DOP_INVALID, },
{ "texldd", 1, 4, 0, 0, SVGA3DOP_INVALID, },
{ "setp", 1, 2, 0, 0, SVGA3DOP_SETP, },
{ "texldl", 1, 2, 0, 0, SVGA3DOP_TEXLDL, },
{ "breakp", 0, 1, 0, 0, SVGA3DOP_INVALID, },
};
const struct sh_opcode_info *svga_opcode_info( uint op )
{
struct sh_opcode_info *info;
if (op >= sizeof( opcode_info ) / sizeof( opcode_info[0] )) {
/* The opcode is either PHASE, COMMENT, END or out of range.
*/
assert( 0 );
return NULL;
}
info = &opcode_info[op];
if (info->svga_opcode == SVGA3DOP_INVALID) {
/* No valid information. Please provide number of dst/src registers.
*/
_debug_printf("Missing information for opcode %u, '%s'\n", op,
opcode_info[op].mnemonic);
assert( 0 );
return NULL;
}
/* Sanity check.
*/
assert( op == info->svga_opcode );
return info;
}

/contrib/sdk/sources/Mesa/mesa-10.6.0/src/gallium/drivers/svga/svgadump/svga_shader_op.h
0,0 → 1,48
/**********************************************************
* Copyright 2008-2009 VMware, Inc. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person
* obtaining a copy of this software and associated documentation
* files (the "Software"), to deal in the Software without
* restriction, including without limitation the rights to use, copy,
* modify, merge, publish, distribute, sublicense, and/or sell copies
* of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
**********************************************************/
/**
* @file
* SVGA Shader Token Opcode Info
*
* @author Michal Krol <michal@vmware.com>
*/
#ifndef SVGA_SHADER_OP_H
#define SVGA_SHADER_OP_H
struct sh_opcode_info
{
const char *mnemonic;
unsigned num_dst:8;
unsigned num_src:8;
unsigned pre_dedent:1;
unsigned post_indent:1;
unsigned svga_opcode:16;
};
const struct sh_opcode_info *svga_opcode_info( unsigned op );
#endif /* SVGA_SHADER_OP_H */