summaryrefslogtreecommitdiffstats
path: root/src/VBox/Devices/Graphics/svgadump
diff options
context:
space:
mode:
Diffstat (limited to 'src/VBox/Devices/Graphics/svgadump')
-rw-r--r--src/VBox/Devices/Graphics/svgadump/Makefile.kup0
-rw-r--r--src/VBox/Devices/Graphics/svgadump/svga_dump.c2815
-rw-r--r--src/VBox/Devices/Graphics/svgadump/svga_dump.h39
3 files changed, 2854 insertions, 0 deletions
diff --git a/src/VBox/Devices/Graphics/svgadump/Makefile.kup b/src/VBox/Devices/Graphics/svgadump/Makefile.kup
new file mode 100644
index 00000000..e69de29b
--- /dev/null
+++ b/src/VBox/Devices/Graphics/svgadump/Makefile.kup
diff --git a/src/VBox/Devices/Graphics/svgadump/svga_dump.c b/src/VBox/Devices/Graphics/svgadump/svga_dump.c
new file mode 100644
index 00000000..6985ce75
--- /dev/null
+++ b/src/VBox/Devices/Graphics/svgadump/svga_dump.c
@@ -0,0 +1,2815 @@
+/**********************************************************
+ * 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.
+ *
+ * Modified for VirtualBox.
+ */
+
+#include "svga_types.h"
+#include "vmsvga_headers_begin.h"
+#pragma pack(1) /* VMSVGA structures are '__packed'. */
+#include "svga3d_reg.h"
+#pragma pack()
+#include "vmsvga_headers_end.h"
+
+#include "svga_dump.h"
+
+#define LOG_GROUP LOG_GROUP_DEV_VMSVGA
+#include <VBox/log.h>
+
+#define _debug_printf(...) Log7((__VA_ARGS__));
+
+#ifdef LOG_ENABLED
+struct SVGAFormatName
+{
+ SVGA3dSurfaceFormat f;
+ const char *pszName;
+};
+
+static struct SVGAFormatName g_formats[] =
+{
+ { SVGA3D_FORMAT_INVALID , "INVALID" },
+ { SVGA3D_X8R8G8B8 , "X8R8G8B8" },
+ { SVGA3D_A8R8G8B8 , "A8R8G8B8" },
+ { SVGA3D_R5G6B5 , "R5G6B5" },
+ { SVGA3D_X1R5G5B5 , "X1R5G5B5" },
+ { SVGA3D_A1R5G5B5 , "A1R5G5B5" },
+ { SVGA3D_A4R4G4B4 , "A4R4G4B4" },
+ { SVGA3D_Z_D32 , "Z_D32" },
+ { SVGA3D_Z_D16 , "Z_D16" },
+ { SVGA3D_Z_D24S8 , "Z_D24S8" },
+ { SVGA3D_Z_D15S1 , "Z_D15S1" },
+ { SVGA3D_LUMINANCE8 , "LUMINANCE8" },
+ { SVGA3D_LUMINANCE4_ALPHA4 , "LUMINANCE4_ALPHA4" },
+ { SVGA3D_LUMINANCE16 , "LUMINANCE16" },
+ { SVGA3D_LUMINANCE8_ALPHA8 , "LUMINANCE8_ALPHA8" },
+ { SVGA3D_DXT1 , "DXT1" },
+ { SVGA3D_DXT2 , "DXT2" },
+ { SVGA3D_DXT3 , "DXT3" },
+ { SVGA3D_DXT4 , "DXT4" },
+ { SVGA3D_DXT5 , "DXT5" },
+ { SVGA3D_BUMPU8V8 , "BUMPU8V8" },
+ { SVGA3D_BUMPL6V5U5 , "BUMPL6V5U5" },
+ { SVGA3D_BUMPX8L8V8U8 , "BUMPX8L8V8U8" },
+ { SVGA3D_FORMAT_DEAD1 , "FORMAT_DEAD1" },
+ { SVGA3D_ARGB_S10E5 , "ARGB_S10E5" },
+ { SVGA3D_ARGB_S23E8 , "ARGB_S23E8" },
+ { SVGA3D_A2R10G10B10 , "A2R10G10B10" },
+ { SVGA3D_V8U8 , "V8U8" },
+ { SVGA3D_Q8W8V8U8 , "Q8W8V8U8" },
+ { SVGA3D_CxV8U8 , "CxV8U8" },
+ { SVGA3D_X8L8V8U8 , "X8L8V8U8" },
+ { SVGA3D_A2W10V10U10 , "A2W10V10U10" },
+ { SVGA3D_ALPHA8 , "ALPHA8" },
+ { SVGA3D_R_S10E5 , "R_S10E5" },
+ { SVGA3D_R_S23E8 , "R_S23E8" },
+ { SVGA3D_RG_S10E5 , "RG_S10E5" },
+ { SVGA3D_RG_S23E8 , "RG_S23E8" },
+ { SVGA3D_BUFFER , "BUFFER" },
+ { SVGA3D_Z_D24X8 , "Z_D24X8" },
+ { SVGA3D_V16U16 , "V16U16" },
+ { SVGA3D_G16R16 , "G16R16" },
+ { SVGA3D_A16B16G16R16 , "A16B16G16R16" },
+ { SVGA3D_UYVY , "UYVY" },
+ { SVGA3D_YUY2 , "YUY2" },
+ { SVGA3D_NV12 , "NV12" },
+ { SVGA3D_FORMAT_DEAD2 , "FORMAT_DEAD2" },
+ { SVGA3D_R32G32B32A32_TYPELESS , "R32G32B32A32_TYPELESS" },
+ { SVGA3D_R32G32B32A32_UINT , "R32G32B32A32_UINT" },
+ { SVGA3D_R32G32B32A32_SINT , "R32G32B32A32_SINT" },
+ { SVGA3D_R32G32B32_TYPELESS , "R32G32B32_TYPELESS" },
+ { SVGA3D_R32G32B32_FLOAT , "R32G32B32_FLOAT" },
+ { SVGA3D_R32G32B32_UINT , "R32G32B32_UINT" },
+ { SVGA3D_R32G32B32_SINT , "R32G32B32_SINT" },
+ { SVGA3D_R16G16B16A16_TYPELESS , "R16G16B16A16_TYPELESS" },
+ { SVGA3D_R16G16B16A16_UINT , "R16G16B16A16_UINT" },
+ { SVGA3D_R16G16B16A16_SNORM , "R16G16B16A16_SNORM" },
+ { SVGA3D_R16G16B16A16_SINT , "R16G16B16A16_SINT" },
+ { SVGA3D_R32G32_TYPELESS , "R32G32_TYPELESS" },
+ { SVGA3D_R32G32_UINT , "R32G32_UINT" },
+ { SVGA3D_R32G32_SINT , "R32G32_SINT" },
+ { SVGA3D_R32G8X24_TYPELESS , "R32G8X24_TYPELESS" },
+ { SVGA3D_D32_FLOAT_S8X24_UINT , "D32_FLOAT_S8X24_UINT" },
+ { SVGA3D_R32_FLOAT_X8X24 , "R32_FLOAT_X8X24" },
+ { SVGA3D_X32_G8X24_UINT , "X32_G8X24_UINT" },
+ { SVGA3D_R10G10B10A2_TYPELESS , "R10G10B10A2_TYPELESS" },
+ { SVGA3D_R10G10B10A2_UINT , "R10G10B10A2_UINT" },
+ { SVGA3D_R11G11B10_FLOAT , "R11G11B10_FLOAT" },
+ { SVGA3D_R8G8B8A8_TYPELESS , "R8G8B8A8_TYPELESS" },
+ { SVGA3D_R8G8B8A8_UNORM , "R8G8B8A8_UNORM" },
+ { SVGA3D_R8G8B8A8_UNORM_SRGB , "R8G8B8A8_UNORM_SRGB" },
+ { SVGA3D_R8G8B8A8_UINT , "R8G8B8A8_UINT" },
+ { SVGA3D_R8G8B8A8_SINT , "R8G8B8A8_SINT" },
+ { SVGA3D_R16G16_TYPELESS , "R16G16_TYPELESS" },
+ { SVGA3D_R16G16_UINT , "R16G16_UINT" },
+ { SVGA3D_R16G16_SINT , "R16G16_SINT" },
+ { SVGA3D_R32_TYPELESS , "R32_TYPELESS" },
+ { SVGA3D_D32_FLOAT , "D32_FLOAT" },
+ { SVGA3D_R32_UINT , "R32_UINT" },
+ { SVGA3D_R32_SINT , "R32_SINT" },
+ { SVGA3D_R24G8_TYPELESS , "R24G8_TYPELESS" },
+ { SVGA3D_D24_UNORM_S8_UINT , "D24_UNORM_S8_UINT" },
+ { SVGA3D_R24_UNORM_X8 , "R24_UNORM_X8" },
+ { SVGA3D_X24_G8_UINT , "X24_G8_UINT" },
+ { SVGA3D_R8G8_TYPELESS , "R8G8_TYPELESS" },
+ { SVGA3D_R8G8_UNORM , "R8G8_UNORM" },
+ { SVGA3D_R8G8_UINT , "R8G8_UINT" },
+ { SVGA3D_R8G8_SINT , "R8G8_SINT" },
+ { SVGA3D_R16_TYPELESS , "R16_TYPELESS" },
+ { SVGA3D_R16_UNORM , "R16_UNORM" },
+ { SVGA3D_R16_UINT , "R16_UINT" },
+ { SVGA3D_R16_SNORM , "R16_SNORM" },
+ { SVGA3D_R16_SINT , "R16_SINT" },
+ { SVGA3D_R8_TYPELESS , "R8_TYPELESS" },
+ { SVGA3D_R8_UNORM , "R8_UNORM" },
+ { SVGA3D_R8_UINT , "R8_UINT" },
+ { SVGA3D_R8_SNORM , "R8_SNORM" },
+ { SVGA3D_R8_SINT , "R8_SINT" },
+ { SVGA3D_P8 , "P8" },
+ { SVGA3D_R9G9B9E5_SHAREDEXP , "R9G9B9E5_SHAREDEXP" },
+ { SVGA3D_R8G8_B8G8_UNORM , "R8G8_B8G8_UNORM" },
+ { SVGA3D_G8R8_G8B8_UNORM , "G8R8_G8B8_UNORM" },
+ { SVGA3D_BC1_TYPELESS , "BC1_TYPELESS" },
+ { SVGA3D_BC1_UNORM_SRGB , "BC1_UNORM_SRGB" },
+ { SVGA3D_BC2_TYPELESS , "BC2_TYPELESS" },
+ { SVGA3D_BC2_UNORM_SRGB , "BC2_UNORM_SRGB" },
+ { SVGA3D_BC3_TYPELESS , "BC3_TYPELESS" },
+ { SVGA3D_BC3_UNORM_SRGB , "BC3_UNORM_SRGB" },
+ { SVGA3D_BC4_TYPELESS , "BC4_TYPELESS" },
+ { SVGA3D_ATI1 , "ATI1" },
+ { SVGA3D_BC4_SNORM , "BC4_SNORM" },
+ { SVGA3D_BC5_TYPELESS , "BC5_TYPELESS" },
+ { SVGA3D_ATI2 , "ATI2" },
+ { SVGA3D_BC5_SNORM , "BC5_SNORM" },
+ { SVGA3D_R10G10B10_XR_BIAS_A2_UNORM , "R10G10B10_XR_BIAS_A2_UNORM" },
+ { SVGA3D_B8G8R8A8_TYPELESS , "B8G8R8A8_TYPELESS" },
+ { SVGA3D_B8G8R8A8_UNORM_SRGB , "B8G8R8A8_UNORM_SRGB" },
+ { SVGA3D_B8G8R8X8_TYPELESS , "B8G8R8X8_TYPELESS" },
+ { SVGA3D_B8G8R8X8_UNORM_SRGB , "B8G8R8X8_UNORM_SRGB" },
+ { SVGA3D_Z_DF16 , "Z_DF16" },
+ { SVGA3D_Z_DF24 , "Z_DF24" },
+ { SVGA3D_Z_D24S8_INT , "Z_D24S8_INT" },
+ { SVGA3D_YV12 , "YV12" },
+ { SVGA3D_R32G32B32A32_FLOAT , "R32G32B32A32_FLOAT" },
+ { SVGA3D_R16G16B16A16_FLOAT , "R16G16B16A16_FLOAT" },
+ { SVGA3D_R16G16B16A16_UNORM , "R16G16B16A16_UNORM" },
+ { SVGA3D_R32G32_FLOAT , "R32G32_FLOAT" },
+ { SVGA3D_R10G10B10A2_UNORM , "R10G10B10A2_UNORM" },
+ { SVGA3D_R8G8B8A8_SNORM , "R8G8B8A8_SNORM" },
+ { SVGA3D_R16G16_FLOAT , "R16G16_FLOAT" },
+ { SVGA3D_R16G16_UNORM , "R16G16_UNORM" },
+ { SVGA3D_R16G16_SNORM , "R16G16_SNORM" },
+ { SVGA3D_R32_FLOAT , "R32_FLOAT" },
+ { SVGA3D_R8G8_SNORM , "R8G8_SNORM" },
+ { SVGA3D_R16_FLOAT , "R16_FLOAT" },
+ { SVGA3D_D16_UNORM , "D16_UNORM" },
+ { SVGA3D_A8_UNORM , "A8_UNORM" },
+ { SVGA3D_BC1_UNORM , "BC1_UNORM" },
+ { SVGA3D_BC2_UNORM , "BC2_UNORM" },
+ { SVGA3D_BC3_UNORM , "BC3_UNORM" },
+ { SVGA3D_B5G6R5_UNORM , "B5G6R5_UNORM" },
+ { SVGA3D_B5G5R5A1_UNORM , "B5G5R5A1_UNORM" },
+ { SVGA3D_B8G8R8A8_UNORM , "B8G8R8A8_UNORM" },
+ { SVGA3D_B8G8R8X8_UNORM , "B8G8R8X8_UNORM" },
+ { SVGA3D_BC4_UNORM , "BC4_UNORM" },
+ { SVGA3D_BC5_UNORM , "BC5_UNORM" },
+ { SVGA3D_B4G4R4A4_UNORM , "B4G4R4A4_UNORM" },
+ { SVGA3D_BC6H_TYPELESS , "BC6H_TYPELESS" },
+ { SVGA3D_BC6H_UF16 , "BC6H_UF16" },
+ { SVGA3D_BC6H_SF16 , "BC6H_SF16" },
+ { SVGA3D_BC7_TYPELESS , "BC7_TYPELESS" },
+ { SVGA3D_BC7_UNORM , "BC7_UNORM" },
+ { SVGA3D_BC7_UNORM_SRGB , "BC7_UNORM_SRGB" },
+ { SVGA3D_AYUV , "AYUV" },
+};
+
+
+static const char *
+svga_format_name(SVGA3dSurfaceFormat format)
+{
+ if (format < RT_ELEMENTS(g_formats))
+ return g_formats[format].pszName;
+ return "???";
+}
+
+
+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";
+ case SVGA3D_SHADERTYPE_HS:
+ return "SVGA3D_SHADERTYPE_HS";
+ case SVGA3D_SHADERTYPE_DS:
+ return "SVGA3D_SHADERTYPE_DS";
+ case SVGA3D_SHADERTYPE_CS:
+ return "SVGA3D_SHADERTYPE_CS";
+ 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 = %R[float]\n", (*cmd).floatValue);
+}
+
+static void
+dump_SVGA3dViewport(const SVGA3dViewport *cmd)
+{
+ _debug_printf("\t\t.x = %R[float]\n", (*cmd).x);
+ _debug_printf("\t\t.y = %R[float]\n", (*cmd).y);
+ _debug_printf("\t\t.width = %R[float]\n", (*cmd).width);
+ _debug_printf("\t\t.height = %R[float]\n", (*cmd).height);
+ _debug_printf("\t\t.minDepth = %R[float]\n", (*cmd).minDepth);
+ _debug_printf("\t\t.maxDepth = %R[float]\n", (*cmd).maxDepth);
+}
+
+static void
+dump_SVGA3dSamplerId(const SVGA3dSamplerId *cmd)
+{
+ _debug_printf("\t\t.id = %u\n", *cmd);
+}
+
+static void
+dump_SVGA3dSoTarget(const SVGA3dSoTarget *cmd)
+{
+ _debug_printf("\t\t.sid = %u\n", (*cmd).sid);
+ _debug_printf("\t\t.offset = %u\n", (*cmd).offset);
+}
+
+static void
+dump_SVGA3dInputElementDesc(const SVGA3dInputElementDesc *cmd)
+{
+ _debug_printf("\t\t.inputSlot = %u\n", (*cmd).inputSlot);
+ _debug_printf("\t\t.alignedByteOffset = %u\n", (*cmd).alignedByteOffset);
+ _debug_printf("\t\t.format = %s\n", svga_format_name((*cmd).format));
+ _debug_printf("\t\t.inputSlotClass = %u\n", (*cmd).inputSlotClass);
+ _debug_printf("\t\t.instanceDataStepRate = %u\n", (*cmd).instanceDataStepRate);
+ _debug_printf("\t\t.inputRegister = %u\n", (*cmd).inputRegister);
+}
+
+static void
+dump_SVGA3dVertexBuffer(const SVGA3dVertexBuffer *cmd)
+{
+ _debug_printf("\t\t.sid = %u\n", (*cmd).sid);
+ _debug_printf("\t\t.stride = %u\n", (*cmd).stride);
+ _debug_printf("\t\t.offset = %u\n", (*cmd).offset);
+}
+
+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_SVGA3dShaderResourceViewId(const SVGA3dShaderResourceViewId *id)
+{
+ _debug_printf("\t\t.id = %u\n", *id);
+}
+
+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] = %R[float]\n", (*cmd).plane[0]);
+ _debug_printf("\t\t.plane[1] = %R[float]\n", (*cmd).plane[1]);
+ _debug_printf("\t\t.plane[2] = %R[float]\n", (*cmd).plane[2]);
+ _debug_printf("\t\t.plane[3] = %R[float]\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] = %R[float]\n", (*cmd).material.diffuse[0]);
+ _debug_printf("\t\t.material.diffuse[1] = %R[float]\n", (*cmd).material.diffuse[1]);
+ _debug_printf("\t\t.material.diffuse[2] = %R[float]\n", (*cmd).material.diffuse[2]);
+ _debug_printf("\t\t.material.diffuse[3] = %R[float]\n", (*cmd).material.diffuse[3]);
+ _debug_printf("\t\t.material.ambient[0] = %R[float]\n", (*cmd).material.ambient[0]);
+ _debug_printf("\t\t.material.ambient[1] = %R[float]\n", (*cmd).material.ambient[1]);
+ _debug_printf("\t\t.material.ambient[2] = %R[float]\n", (*cmd).material.ambient[2]);
+ _debug_printf("\t\t.material.ambient[3] = %R[float]\n", (*cmd).material.ambient[3]);
+ _debug_printf("\t\t.material.specular[0] = %R[float]\n", (*cmd).material.specular[0]);
+ _debug_printf("\t\t.material.specular[1] = %R[float]\n", (*cmd).material.specular[1]);
+ _debug_printf("\t\t.material.specular[2] = %R[float]\n", (*cmd).material.specular[2]);
+ _debug_printf("\t\t.material.specular[3] = %R[float]\n", (*cmd).material.specular[3]);
+ _debug_printf("\t\t.material.emissive[0] = %R[float]\n", (*cmd).material.emissive[0]);
+ _debug_printf("\t\t.material.emissive[1] = %R[float]\n", (*cmd).material.emissive[1]);
+ _debug_printf("\t\t.material.emissive[2] = %R[float]\n", (*cmd).material.emissive[2]);
+ _debug_printf("\t\t.material.emissive[3] = %R[float]\n", (*cmd).material.emissive[3]);
+ _debug_printf("\t\t.material.shininess = %R[float]\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] = %R[float]\n", (*cmd).data.diffuse[0]);
+ _debug_printf("\t\t.data.diffuse[1] = %R[float]\n", (*cmd).data.diffuse[1]);
+ _debug_printf("\t\t.data.diffuse[2] = %R[float]\n", (*cmd).data.diffuse[2]);
+ _debug_printf("\t\t.data.diffuse[3] = %R[float]\n", (*cmd).data.diffuse[3]);
+ _debug_printf("\t\t.data.specular[0] = %R[float]\n", (*cmd).data.specular[0]);
+ _debug_printf("\t\t.data.specular[1] = %R[float]\n", (*cmd).data.specular[1]);
+ _debug_printf("\t\t.data.specular[2] = %R[float]\n", (*cmd).data.specular[2]);
+ _debug_printf("\t\t.data.specular[3] = %R[float]\n", (*cmd).data.specular[3]);
+ _debug_printf("\t\t.data.ambient[0] = %R[float]\n", (*cmd).data.ambient[0]);
+ _debug_printf("\t\t.data.ambient[1] = %R[float]\n", (*cmd).data.ambient[1]);
+ _debug_printf("\t\t.data.ambient[2] = %R[float]\n", (*cmd).data.ambient[2]);
+ _debug_printf("\t\t.data.ambient[3] = %R[float]\n", (*cmd).data.ambient[3]);
+ _debug_printf("\t\t.data.position[0] = %R[float]\n", (*cmd).data.position[0]);
+ _debug_printf("\t\t.data.position[1] = %R[float]\n", (*cmd).data.position[1]);
+ _debug_printf("\t\t.data.position[2] = %R[float]\n", (*cmd).data.position[2]);
+ _debug_printf("\t\t.data.position[3] = %R[float]\n", (*cmd).data.position[3]);
+ _debug_printf("\t\t.data.direction[0] = %R[float]\n", (*cmd).data.direction[0]);
+ _debug_printf("\t\t.data.direction[1] = %R[float]\n", (*cmd).data.direction[1]);
+ _debug_printf("\t\t.data.direction[2] = %R[float]\n", (*cmd).data.direction[2]);
+ _debug_printf("\t\t.data.direction[3] = %R[float]\n", (*cmd).data.direction[3]);
+ _debug_printf("\t\t.data.range = %R[float]\n", (*cmd).data.range);
+ _debug_printf("\t\t.data.falloff = %R[float]\n", (*cmd).data.falloff);
+ _debug_printf("\t\t.data.attenuation0 = %R[float]\n", (*cmd).data.attenuation0);
+ _debug_printf("\t\t.data.attenuation1 = %R[float]\n", (*cmd).data.attenuation1);
+ _debug_printf("\t\t.data.attenuation2 = %R[float]\n", (*cmd).data.attenuation2);
+ _debug_printf("\t\t.data.theta = %R[float]\n", (*cmd).data.theta);
+ _debug_printf("\t\t.data.phi = %R[float]\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 = %R[float]\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;
+ 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] = {%R[float], %R[float], %R[float], %R[float]}\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 = %R[float]\n", (*cmd).zRange.min);
+ _debug_printf("\t\t.zRange.max = %R[float]\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] = %R[float]\n", (*cmd).matrix[0]);
+ _debug_printf("\t\t.matrix[1] = %R[float]\n", (*cmd).matrix[1]);
+ _debug_printf("\t\t.matrix[2] = %R[float]\n", (*cmd).matrix[2]);
+ _debug_printf("\t\t.matrix[3] = %R[float]\n", (*cmd).matrix[3]);
+ _debug_printf("\t\t.matrix[4] = %R[float]\n", (*cmd).matrix[4]);
+ _debug_printf("\t\t.matrix[5] = %R[float]\n", (*cmd).matrix[5]);
+ _debug_printf("\t\t.matrix[6] = %R[float]\n", (*cmd).matrix[6]);
+ _debug_printf("\t\t.matrix[7] = %R[float]\n", (*cmd).matrix[7]);
+ _debug_printf("\t\t.matrix[8] = %R[float]\n", (*cmd).matrix[8]);
+ _debug_printf("\t\t.matrix[9] = %R[float]\n", (*cmd).matrix[9]);
+ _debug_printf("\t\t.matrix[10] = %R[float]\n", (*cmd).matrix[10]);
+ _debug_printf("\t\t.matrix[11] = %R[float]\n", (*cmd).matrix[11]);
+ _debug_printf("\t\t.matrix[12] = %R[float]\n", (*cmd).matrix[12]);
+ _debug_printf("\t\t.matrix[13] = %R[float]\n", (*cmd).matrix[13]);
+ _debug_printf("\t\t.matrix[14] = %R[float]\n", (*cmd).matrix[14]);
+ _debug_printf("\t\t.matrix[15] = %R[float]\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;
+ 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 = %R[float]\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;
+ }
+ _debug_printf("\t\t.format = %s\n", svga_format_name((*cmd).format));
+ _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_SVGA3dBox(const SVGA3dBox *box)
+{
+ _debug_printf("\t\t.box = %u, %u, %u %u x %u x %u\n",
+ box->x, box->y, box->z,
+ box->w, box->h, box->d);
+}
+
+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_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);
+ dump_SVGA3dBox(&cmd->box);
+}
+
+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);
+ dump_SVGA3dBox(&cmd->box);
+ _debug_printf("\t\t.invertBox = %u\n", cmd->invertBox);
+}
+
+/// SVGA_3D_CMD_DX
+
+#define __SVGA3D_DUMP_STRINGIFY(a) #a
+#define SVGA3D_DUMP_STRINGIFY(a) __SVGA3D_DUMP_STRINGIFY(a)
+
+#define SVGA3D_DUMP_HEADER(CommandName) \
+static void \
+dump_SVGA3dCmdDX##CommandName(const SVGA3dCmdDX##CommandName *cmd)
+
+#define SVGA3D_DUMP_PARAMETER(ParameterName, ParameterType) \
+_debug_printf(SVGA3D_DUMP_STRINGIFY(\t\t.ParameterName = %ParameterType\n), cmd->ParameterName)
+
+#define SVGA3D_DUMP_TYPE_CASE(TypeVariableName, CaseName) \
+case CaseName: \
+ _debug_printf(SVGA3D_DUMP_STRINGIFY(\t\t.TypeVariableName = CaseName) "\n"); \
+ break;
+
+#define SVGA3D_DUMP_TYPE_DEFAULT(TypeVariableName) \
+default: \
+ _debug_printf(SVGA3D_DUMP_STRINGIFY(\t\t.TypeVariableName = %i\n), (*cmd).TypeVariableName); \
+ break;
+
+SVGA3D_DUMP_HEADER(SetShader)
+{
+ SVGA3D_DUMP_PARAMETER(shaderId, u);
+ _debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
+}
+
+SVGA3D_DUMP_HEADER(SetSamplers)
+{
+ SVGA3D_DUMP_PARAMETER(startSampler, u);
+ _debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
+ /* XXX: note we're not printing the sampler IDs at this time */
+}
+
+SVGA3D_DUMP_HEADER(Draw)
+{
+ SVGA3D_DUMP_PARAMETER(vertexCount, u);
+ SVGA3D_DUMP_PARAMETER(startVertexLocation, u);
+}
+
+SVGA3D_DUMP_HEADER(DrawIndexed)
+{
+ SVGA3D_DUMP_PARAMETER(indexCount, u);
+ SVGA3D_DUMP_PARAMETER(startIndexLocation, u);
+ SVGA3D_DUMP_PARAMETER(baseVertexLocation, i);
+}
+
+SVGA3D_DUMP_HEADER(DrawInstanced)
+{
+ SVGA3D_DUMP_PARAMETER(vertexCountPerInstance, u);
+ SVGA3D_DUMP_PARAMETER(instanceCount, u);
+ SVGA3D_DUMP_PARAMETER(startVertexLocation, u);
+ SVGA3D_DUMP_PARAMETER(startInstanceLocation, u);
+}
+
+SVGA3D_DUMP_HEADER(DrawIndexedInstanced)
+{
+ SVGA3D_DUMP_PARAMETER(indexCountPerInstance, u);
+ SVGA3D_DUMP_PARAMETER(instanceCount, u);
+ SVGA3D_DUMP_PARAMETER(startIndexLocation, u);
+ SVGA3D_DUMP_PARAMETER(baseVertexLocation, i);
+ SVGA3D_DUMP_PARAMETER(startInstanceLocation, u);
+}
+
+SVGA3D_DUMP_HEADER(DrawAuto)
+{
+ (void)cmd;
+}
+
+SVGA3D_DUMP_HEADER(SetBlendState)
+{
+ SVGA3D_DUMP_PARAMETER(blendId, u);
+ _debug_printf("\t\t.blendFactor[4] = %R[float] %R[float] %R[float] %R[float]\n", cmd->blendFactor[0],
+ cmd->blendFactor[1],
+ cmd->blendFactor[2],
+ cmd->blendFactor[3]);
+ SVGA3D_DUMP_PARAMETER(sampleMask, u);
+}
+
+SVGA3D_DUMP_HEADER(SetDepthStencilState)
+{
+ SVGA3D_DUMP_PARAMETER(depthStencilId, u);
+ SVGA3D_DUMP_PARAMETER(stencilRef, u);
+}
+
+SVGA3D_DUMP_HEADER(SetRasterizerState)
+{
+ SVGA3D_DUMP_PARAMETER(rasterizerId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineQuery)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+ switch (cmd->type)
+ {
+ SVGA3D_DUMP_TYPE_CASE(type, SVGA3D_QUERYTYPE_OCCLUSION);
+ SVGA3D_DUMP_TYPE_CASE(type, SVGA3D_QUERYTYPE_MAX);
+ SVGA3D_DUMP_TYPE_DEFAULT(type);
+ }
+ switch (cmd->flags)
+ {
+ SVGA3D_DUMP_TYPE_CASE(flags, SVGA3D_DXQUERY_FLAG_PREDICATEHINT);
+ SVGA3D_DUMP_TYPE_DEFAULT(flags);
+ }
+}
+
+SVGA3D_DUMP_HEADER(DestroyQuery)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+}
+
+SVGA3D_DUMP_HEADER(BindAllQuery)
+{
+ SVGA3D_DUMP_PARAMETER(cid, u);
+ SVGA3D_DUMP_PARAMETER(mobid, u);
+}
+
+SVGA3D_DUMP_HEADER(BindQuery)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+ SVGA3D_DUMP_PARAMETER(mobid, u);
+}
+
+SVGA3D_DUMP_HEADER(MoveQuery)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+ SVGA3D_DUMP_PARAMETER(mobid, u);
+ SVGA3D_DUMP_PARAMETER(mobOffset, u);
+}
+
+SVGA3D_DUMP_HEADER(ReadbackAllQuery)
+{
+ SVGA3D_DUMP_PARAMETER(cid, u);
+}
+
+SVGA3D_DUMP_HEADER(SetQueryOffset)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+ SVGA3D_DUMP_PARAMETER(mobOffset, u);
+}
+
+SVGA3D_DUMP_HEADER(BeginQuery)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+}
+
+SVGA3D_DUMP_HEADER(EndQuery)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+}
+
+SVGA3D_DUMP_HEADER(SetPredication)
+{
+ SVGA3D_DUMP_PARAMETER(queryId, u);
+ SVGA3D_DUMP_PARAMETER(predicateValue, u);
+}
+
+SVGA3D_DUMP_HEADER(SetSOTargets)
+{
+ (void)cmd;
+}
+
+
+SVGA3D_DUMP_HEADER(BindContext)
+{
+ SVGA3D_DUMP_PARAMETER(mobid, u);
+ SVGA3D_DUMP_PARAMETER(validContents, u);
+}
+
+SVGA3D_DUMP_HEADER(SetViewports)
+{
+ (void)cmd;
+ /* XXX: note we're not printing the SVGA3dViewport list at this time */
+}
+
+SVGA3D_DUMP_HEADER(SetScissorRects)
+{
+ (void)cmd;
+ /* XXX: note we're not printing the SVGASignedRect list at this time */
+}
+
+SVGA3D_DUMP_HEADER(ClearRenderTargetView)
+{
+ SVGA3D_DUMP_PARAMETER(renderTargetViewId, u);
+ SVGA3D_DUMP_PARAMETER(rgba.r, R[float]);
+ SVGA3D_DUMP_PARAMETER(rgba.g, R[float]);
+ SVGA3D_DUMP_PARAMETER(rgba.b, R[float]);
+ SVGA3D_DUMP_PARAMETER(rgba.a, R[float]);
+}
+
+SVGA3D_DUMP_HEADER(ClearDepthStencilView)
+{
+ SVGA3D_DUMP_PARAMETER(flags, u);
+ SVGA3D_DUMP_PARAMETER(stencil, u);
+ SVGA3D_DUMP_PARAMETER(depthStencilViewId, u);
+ SVGA3D_DUMP_PARAMETER(depth, R[float]);
+}
+
+SVGA3D_DUMP_HEADER(DefineShaderResourceView)
+{
+ SVGA3D_DUMP_PARAMETER(shaderResourceViewId, u);
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ _debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
+ switch (cmd->resourceDimension)
+ {
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_BUFFER);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE1D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE2D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE3D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURECUBE);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TYPE_MAX);
+ SVGA3D_DUMP_TYPE_DEFAULT(resourceDimension);
+ }
+ if (cmd->resourceDimension == SVGA3D_RESOURCE_BUFFER) {
+ SVGA3D_DUMP_PARAMETER(desc.buffer.firstElement, u);
+ SVGA3D_DUMP_PARAMETER(desc.buffer.numElements, u);
+ }
+ else {
+ SVGA3D_DUMP_PARAMETER(desc.tex.mostDetailedMip, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex.firstArraySlice, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex.mipLevels, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex.arraySize, u);
+ }
+}
+
+SVGA3D_DUMP_HEADER(SetShaderResources)
+{
+ SVGA3D_DUMP_PARAMETER(startView, u);
+ _debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
+}
+
+
+SVGA3D_DUMP_HEADER(DestroyShaderResourceView)
+{
+ SVGA3D_DUMP_PARAMETER(shaderResourceViewId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineRenderTargetView)
+{
+ SVGA3D_DUMP_PARAMETER(renderTargetViewId, u);
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ _debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
+ switch (cmd->resourceDimension)
+ {
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_BUFFER);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE1D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE2D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE3D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURECUBE);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TYPE_MAX);
+ SVGA3D_DUMP_TYPE_DEFAULT(resourceDimension);
+ }
+ SVGA3D_DUMP_PARAMETER(desc.buffer.firstElement, u);
+ SVGA3D_DUMP_PARAMETER(desc.buffer.numElements, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex.mipSlice, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex.firstArraySlice, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex.arraySize, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex3D.mipSlice, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex3D.firstW, u);
+ SVGA3D_DUMP_PARAMETER(desc.tex3D.wSize, u);
+}
+
+SVGA3D_DUMP_HEADER(DestroyRenderTargetView)
+{
+ SVGA3D_DUMP_PARAMETER(renderTargetViewId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineDepthStencilView)
+{
+ SVGA3D_DUMP_PARAMETER(depthStencilViewId, u);
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ _debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
+ switch (cmd->resourceDimension)
+ {
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_BUFFER);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE1D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE2D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURE3D);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TEXTURECUBE);
+ SVGA3D_DUMP_TYPE_CASE(resourceDimension, SVGA3D_RESOURCE_TYPE_MAX);
+ SVGA3D_DUMP_TYPE_DEFAULT(resourceDimension);
+ }
+ SVGA3D_DUMP_PARAMETER(mipSlice, u);
+ SVGA3D_DUMP_PARAMETER(firstArraySlice, u);
+ SVGA3D_DUMP_PARAMETER(arraySize, u);
+}
+
+SVGA3D_DUMP_HEADER(DestroyDepthStencilView)
+{
+ SVGA3D_DUMP_PARAMETER(depthStencilViewId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineElementLayout)
+{
+ SVGA3D_DUMP_PARAMETER(elementLayoutId, u);
+}
+
+SVGA3D_DUMP_HEADER(DestroyElementLayout)
+{
+ SVGA3D_DUMP_PARAMETER(elementLayoutId, u);
+}
+
+static void
+dump_SVGA3dCmdDXDefineBlendState(const SVGA3dCmdDXDefineBlendState *cmd)
+{
+ unsigned i;
+
+ SVGA3D_DUMP_PARAMETER(blendId, u);
+ SVGA3D_DUMP_PARAMETER(alphaToCoverageEnable, u);
+ SVGA3D_DUMP_PARAMETER(independentBlendEnable, u);
+ for (i = 0; i < SVGA3D_DX_MAX_RENDER_TARGETS; i++) {
+ const SVGA3dDXBlendStatePerRT *rt = cmd->perRT + i;
+ _debug_printf("\t\t.perRT[%u].blendEnable = %u\n", i, rt->blendEnable);
+ if (rt->blendEnable) {
+ _debug_printf("\t\t.perRT[%u].srcBlend = %u\n", i, rt->srcBlend);
+ _debug_printf("\t\t.perRT[%u].destBlend = %u\n", i, rt->destBlend);
+ _debug_printf("\t\t.perRT[%u].blendOp = %u\n", i, rt->blendOp);
+ _debug_printf("\t\t.perRT[%u].srcBlendAlpha = %u\n", i, rt->srcBlendAlpha);
+ _debug_printf("\t\t.perRT[%u].destBlendAlpha = %u\n", i, rt->destBlendAlpha);
+ _debug_printf("\t\t.perRT[%u].blendOpAlpha = %u\n", i, rt->blendOpAlpha);
+ }
+ _debug_printf("\t\t.perRT[%u].renderTargetWriteMask = %u\n", i, rt->renderTargetWriteMask);
+ _debug_printf("\t\t.perRT[%u].logicOpEnable = %u\n", i, rt->logicOpEnable);
+ if (rt->logicOpEnable) {
+ _debug_printf("\t\t.perRT[%u].logicOp = %u\n", i, rt->logicOp);
+ }
+ }
+}
+
+SVGA3D_DUMP_HEADER(DestroyBlendState)
+{
+ SVGA3D_DUMP_PARAMETER(blendId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineDepthStencilState)
+{
+ SVGA3D_DUMP_PARAMETER(depthStencilId, u);
+ SVGA3D_DUMP_PARAMETER(depthEnable, u);
+ SVGA3D_DUMP_PARAMETER(depthWriteMask, u);
+ SVGA3D_DUMP_PARAMETER(depthFunc, u);
+ SVGA3D_DUMP_PARAMETER(stencilEnable, u);
+ SVGA3D_DUMP_PARAMETER(frontEnable, u);
+ SVGA3D_DUMP_PARAMETER(backEnable, u);
+ SVGA3D_DUMP_PARAMETER(stencilReadMask, u);
+ SVGA3D_DUMP_PARAMETER(stencilWriteMask, u);
+ SVGA3D_DUMP_PARAMETER(frontStencilFailOp, u);
+ SVGA3D_DUMP_PARAMETER(frontStencilDepthFailOp, u);
+ SVGA3D_DUMP_PARAMETER(frontStencilPassOp, u);
+ SVGA3D_DUMP_PARAMETER(frontStencilFunc, u);
+ SVGA3D_DUMP_PARAMETER(backStencilFailOp, u);
+ SVGA3D_DUMP_PARAMETER(backStencilDepthFailOp, u);
+ SVGA3D_DUMP_PARAMETER(backStencilPassOp, u);
+ SVGA3D_DUMP_PARAMETER(backStencilFunc, u);
+}
+
+SVGA3D_DUMP_HEADER(DestroyDepthStencilState)
+{
+ SVGA3D_DUMP_PARAMETER(depthStencilId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineRasterizerState)
+{
+ SVGA3D_DUMP_PARAMETER(rasterizerId, u);
+ SVGA3D_DUMP_PARAMETER(fillMode, u);
+ SVGA3D_DUMP_PARAMETER(cullMode, u);
+ SVGA3D_DUMP_PARAMETER(frontCounterClockwise, u);
+ SVGA3D_DUMP_PARAMETER(depthBias, u);
+ SVGA3D_DUMP_PARAMETER(depthBiasClamp, R[float]);
+ SVGA3D_DUMP_PARAMETER(slopeScaledDepthBias, R[float]);
+ SVGA3D_DUMP_PARAMETER(depthClipEnable, u);
+ SVGA3D_DUMP_PARAMETER(scissorEnable, u);
+ SVGA3D_DUMP_PARAMETER(multisampleEnable, u);
+ SVGA3D_DUMP_PARAMETER(antialiasedLineEnable, u);
+ SVGA3D_DUMP_PARAMETER(lineWidth, R[float]);
+ SVGA3D_DUMP_PARAMETER(lineStippleEnable, u);
+ SVGA3D_DUMP_PARAMETER(lineStippleFactor, u);
+ SVGA3D_DUMP_PARAMETER(lineStipplePattern, u);
+ SVGA3D_DUMP_PARAMETER(provokingVertexLast, u);
+}
+
+SVGA3D_DUMP_HEADER(DestroyRasterizerState)
+{
+ SVGA3D_DUMP_PARAMETER(rasterizerId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineSamplerState)
+{
+ SVGA3D_DUMP_PARAMETER(samplerId, u);
+ SVGA3D_DUMP_PARAMETER(filter, u);
+ SVGA3D_DUMP_PARAMETER(addressU, u);
+ SVGA3D_DUMP_PARAMETER(addressV, u);
+ SVGA3D_DUMP_PARAMETER(addressW, u);
+ SVGA3D_DUMP_PARAMETER(mipLODBias, R[float]);
+ SVGA3D_DUMP_PARAMETER(maxAnisotropy, u);
+ SVGA3D_DUMP_PARAMETER(comparisonFunc, u);
+ SVGA3D_DUMP_PARAMETER(borderColor.r, R[float]);
+ SVGA3D_DUMP_PARAMETER(borderColor.g, R[float]);
+ SVGA3D_DUMP_PARAMETER(borderColor.b, R[float]);
+ SVGA3D_DUMP_PARAMETER(borderColor.a, R[float]);
+ SVGA3D_DUMP_PARAMETER(minLOD, R[float]);
+ SVGA3D_DUMP_PARAMETER(maxLOD, R[float]);
+}
+
+SVGA3D_DUMP_HEADER(DestroySamplerState)
+{
+ SVGA3D_DUMP_PARAMETER(samplerId, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineShader)
+{
+ SVGA3D_DUMP_PARAMETER(shaderId, u);
+ _debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
+ SVGA3D_DUMP_PARAMETER(sizeInBytes, u);
+}
+
+SVGA3D_DUMP_HEADER(DestroyShader)
+{
+ SVGA3D_DUMP_PARAMETER(shaderId, u);
+}
+
+SVGA3D_DUMP_HEADER(BindShader)
+{
+ SVGA3D_DUMP_PARAMETER(cid, u);
+ SVGA3D_DUMP_PARAMETER(shid, u);
+ SVGA3D_DUMP_PARAMETER(mobid, u);
+ SVGA3D_DUMP_PARAMETER(offsetInBytes, u);
+}
+
+SVGA3D_DUMP_HEADER(DefineStreamOutput)
+{
+ int i;
+ SVGA3D_DUMP_PARAMETER(soid, u);
+ SVGA3D_DUMP_PARAMETER(numOutputStreamEntries, u);
+ for (i = 0; i < SVGA3D_DX_MAX_SOTARGETS; i++) {
+ _debug_printf("\t\t.streamOutputStrideInBytes[%d] = %u\n",
+ i, cmd->streamOutputStrideInBytes[i]);
+ }
+ for (i = 0; i < 16; i++)
+ {
+ _debug_printf("\t\t.decl[%d].outputSlot = %u\n", i, cmd->decl[i].outputSlot);
+ _debug_printf("\t\t.decl[%d].registerIndex = %u\n", i, cmd->decl[i].registerIndex);
+ _debug_printf("\t\t.decl[%d].registerMask = %u\n", i, cmd->decl[i].registerMask);
+ }
+}
+
+SVGA3D_DUMP_HEADER(DestroyStreamOutput)
+{
+ SVGA3D_DUMP_PARAMETER(soid, u);
+}
+
+SVGA3D_DUMP_HEADER(SetStreamOutput)
+{
+ SVGA3D_DUMP_PARAMETER(soid, u);
+}
+
+SVGA3D_DUMP_HEADER(SetSingleConstantBuffer)
+{
+ SVGA3D_DUMP_PARAMETER(slot, u);
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ _debug_printf("\t\t.type = %s\n", shader_name(cmd->type));
+ SVGA3D_DUMP_PARAMETER(offsetInBytes, u);
+ SVGA3D_DUMP_PARAMETER(sizeInBytes, u);
+}
+
+SVGA3D_DUMP_HEADER(SetInputLayout)
+{
+ SVGA3D_DUMP_PARAMETER(elementLayoutId, u);
+}
+
+SVGA3D_DUMP_HEADER(SetVertexBuffers)
+{
+ SVGA3D_DUMP_PARAMETER(startBuffer, u);
+
+ /* XXX: note we're not printing the SVGA3dVertexBuffer list at this time */
+}
+
+SVGA3D_DUMP_HEADER(SetTopology)
+{
+ switch (cmd->topology)
+ {
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_INVALID);
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_TRIANGLELIST);
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_POINTLIST);
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_LINELIST);
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_LINESTRIP);
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_TRIANGLESTRIP);
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_TRIANGLEFAN);
+ SVGA3D_DUMP_TYPE_CASE(topology, SVGA3D_PRIMITIVE_MAX);
+ SVGA3D_DUMP_TYPE_DEFAULT(topology);
+ }
+}
+
+SVGA3D_DUMP_HEADER(SetIndexBuffer)
+{
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ _debug_printf("\t\t.format = %s\n", svga_format_name(cmd->format));
+ SVGA3D_DUMP_PARAMETER(offset, u);
+}
+
+SVGA3D_DUMP_HEADER(PredCopyRegion)
+{
+ SVGA3D_DUMP_PARAMETER(dstSid, u);
+ SVGA3D_DUMP_PARAMETER(dstSubResource, u);
+ SVGA3D_DUMP_PARAMETER(srcSid, u);
+ SVGA3D_DUMP_PARAMETER(srcSubResource, u);
+ dump_SVGA3dCopyBox(&cmd->box);
+}
+
+SVGA3D_DUMP_HEADER(PredCopy)
+{
+ SVGA3D_DUMP_PARAMETER(dstSid, u);
+ SVGA3D_DUMP_PARAMETER(srcSid, u);
+}
+
+static void
+dump_SVGA3dCmdDXUpdateSubResource(const SVGA3dCmdDXUpdateSubResource *cmd)
+{
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ SVGA3D_DUMP_PARAMETER(subResource, u);
+ dump_SVGA3dBox(&cmd->box);
+}
+
+static void
+dump_SVGA3dCmdDXReadbackSubResource(const SVGA3dCmdDXReadbackSubResource *cmd)
+{
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ SVGA3D_DUMP_PARAMETER(subResource, u);
+}
+
+SVGA3D_DUMP_HEADER(BufferCopy)
+{
+ SVGA3D_DUMP_PARAMETER(dest, u);
+ SVGA3D_DUMP_PARAMETER(src, u);
+ SVGA3D_DUMP_PARAMETER(destX, u);
+ SVGA3D_DUMP_PARAMETER(srcX, u);
+ SVGA3D_DUMP_PARAMETER(width, u);
+
+}
+
+SVGA3D_DUMP_HEADER(BufferUpdate)
+{
+ SVGA3D_DUMP_PARAMETER(sid, u);
+ SVGA3D_DUMP_PARAMETER(x, u);
+ SVGA3D_DUMP_PARAMETER(width, u);
+
+}
+
+SVGA3D_DUMP_HEADER(GenMips)
+{
+ SVGA3D_DUMP_PARAMETER(shaderResourceViewId, u);
+}
+
+SVGA3D_DUMP_HEADER(TransferFromBuffer)
+{
+ SVGA3D_DUMP_PARAMETER(srcSid, u);
+ SVGA3D_DUMP_PARAMETER(srcOffset, u);
+ SVGA3D_DUMP_PARAMETER(srcPitch, u);
+ SVGA3D_DUMP_PARAMETER(srcSlicePitch, u);
+ SVGA3D_DUMP_PARAMETER(destSid, u);
+ SVGA3D_DUMP_PARAMETER(destSubResource, u);
+ dump_SVGA3dBox(&cmd->destBox);
+}
+
+static void
+dump_SVGA3dCmdIntraSurfaceCopy(const SVGA3dCmdIntraSurfaceCopy *cmd)
+{
+ SVGA3D_DUMP_PARAMETER(surface.sid, u);
+ SVGA3D_DUMP_PARAMETER(surface.face, u);
+ SVGA3D_DUMP_PARAMETER(surface.mipmap, u);
+ dump_SVGA3dCopyBox(&cmd->box);
+}
+
+static void
+dump_SVGA3dCmdInvalidateGBSurface(const SVGA3dCmdInvalidateGBSurface *cmd)
+{
+ SVGA3D_DUMP_PARAMETER(sid, u);
+}
+
+#define SVGA3D_DUMP_CASE_BASIC(CommandName, CommandCode) \
+case SVGA_3D_CMD_DX_##CommandCode: \
+ _debug_printf(SVGA3D_DUMP_STRINGIFY(\tSVGA_3D_CMD_DX_##CommandCode) "\n"); \
+ { \
+ const SVGA3dCmdDX##CommandName *cmd = (const SVGA3dCmdDX##CommandName *)body; \
+ dump_SVGA3dCmdDX##CommandName(cmd); \
+ body = (const uint8_t *)&cmd[1]; \
+ } \
+ break
+
+#define SVGA3D_DUMP_CASE_LIST(CommandName, CommandCode, ElementType) \
+case SVGA_3D_CMD_DX_##CommandCode: \
+ _debug_printf(SVGA3D_DUMP_STRINGIFY(\tSVGA_3D_CMD_DX_##CommandCode) "\n"); \
+ { \
+ const SVGA3dCmdDX##CommandName *cmd = (const SVGA3dCmdDX##CommandName *)body; \
+ dump_SVGA3dCmdDX##CommandName(cmd); \
+ body = (const uint8_t *)&cmd[1]; \
+ while (body + sizeof(ElementType) <= next) \
+ { \
+ dump_##ElementType((const ElementType *)body); \
+ body += sizeof(ElementType); \
+ } \
+ } \
+ break
+
+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) {
+ SVGA3D_DUMP_CASE_BASIC(BindContext, BIND_CONTEXT);
+ SVGA3D_DUMP_CASE_LIST(SetViewports, SET_VIEWPORTS, SVGA3dViewport);
+ SVGA3D_DUMP_CASE_BASIC(SetShader, SET_SHADER);
+ SVGA3D_DUMP_CASE_LIST(SetSamplers, SET_SAMPLERS, SVGA3dSamplerId);
+ SVGA3D_DUMP_CASE_BASIC(SetBlendState, SET_BLEND_STATE);
+ SVGA3D_DUMP_CASE_BASIC(SetDepthStencilState, SET_DEPTHSTENCIL_STATE);
+ SVGA3D_DUMP_CASE_BASIC(SetRasterizerState, SET_RASTERIZER_STATE);
+ SVGA3D_DUMP_CASE_BASIC(SetPredication, SET_PREDICATION);
+ SVGA3D_DUMP_CASE_LIST(SetSOTargets, SET_SOTARGETS, SVGA3dSoTarget);
+ SVGA3D_DUMP_CASE_LIST(SetScissorRects, SET_SCISSORRECTS, SVGASignedRect);
+ SVGA3D_DUMP_CASE_BASIC(SetStreamOutput, SET_STREAMOUTPUT);
+ SVGA3D_DUMP_CASE_BASIC(SetSingleConstantBuffer, SET_SINGLE_CONSTANT_BUFFER);
+ SVGA3D_DUMP_CASE_BASIC(Draw, DRAW);
+ SVGA3D_DUMP_CASE_BASIC(DrawIndexed, DRAW_INDEXED);
+ SVGA3D_DUMP_CASE_BASIC(DrawInstanced, DRAW_INSTANCED);
+ SVGA3D_DUMP_CASE_BASIC(DrawIndexedInstanced, DRAW_INDEXED_INSTANCED);
+ SVGA3D_DUMP_CASE_BASIC(DrawAuto, DRAW_AUTO);
+ SVGA3D_DUMP_CASE_BASIC(DefineQuery, DEFINE_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(DestroyQuery, DESTROY_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(BindAllQuery, BIND_ALL_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(BindQuery, BIND_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(MoveQuery, MOVE_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(ReadbackAllQuery, READBACK_ALL_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(SetQueryOffset, SET_QUERY_OFFSET);
+ SVGA3D_DUMP_CASE_BASIC(BeginQuery, BEGIN_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(EndQuery, END_QUERY);
+ SVGA3D_DUMP_CASE_BASIC(ClearRenderTargetView, CLEAR_RENDERTARGET_VIEW);
+ SVGA3D_DUMP_CASE_BASIC(ClearDepthStencilView, CLEAR_DEPTHSTENCIL_VIEW);
+ SVGA3D_DUMP_CASE_BASIC(DefineShaderResourceView, DEFINE_SHADERRESOURCE_VIEW);
+ SVGA3D_DUMP_CASE_LIST(SetShaderResources, SET_SHADER_RESOURCES, SVGA3dShaderResourceViewId);
+ SVGA3D_DUMP_CASE_BASIC(DestroyShaderResourceView, DESTROY_SHADERRESOURCE_VIEW);
+ SVGA3D_DUMP_CASE_BASIC(DefineRenderTargetView, DEFINE_RENDERTARGET_VIEW);
+ SVGA3D_DUMP_CASE_BASIC(DestroyRenderTargetView, DESTROY_RENDERTARGET_VIEW);
+ SVGA3D_DUMP_CASE_BASIC(DefineDepthStencilView, DEFINE_DEPTHSTENCIL_VIEW);
+ SVGA3D_DUMP_CASE_BASIC(DestroyDepthStencilView, DESTROY_DEPTHSTENCIL_VIEW);
+ SVGA3D_DUMP_CASE_LIST(DefineElementLayout, DEFINE_ELEMENTLAYOUT, SVGA3dInputElementDesc);
+ SVGA3D_DUMP_CASE_BASIC(DestroyElementLayout, DESTROY_ELEMENTLAYOUT);
+ SVGA3D_DUMP_CASE_BASIC(DefineBlendState, DEFINE_BLEND_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DestroyBlendState, DESTROY_BLEND_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DefineDepthStencilState, DEFINE_DEPTHSTENCIL_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DestroyDepthStencilState, DESTROY_DEPTHSTENCIL_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DefineRasterizerState, DEFINE_RASTERIZER_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DestroyRasterizerState, DESTROY_RASTERIZER_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DefineSamplerState, DEFINE_SAMPLER_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DestroySamplerState, DESTROY_SAMPLER_STATE);
+ SVGA3D_DUMP_CASE_BASIC(DefineShader, DEFINE_SHADER);
+ SVGA3D_DUMP_CASE_BASIC(DestroyShader, DESTROY_SHADER);
+ SVGA3D_DUMP_CASE_BASIC(BindShader, BIND_SHADER);
+ SVGA3D_DUMP_CASE_BASIC(DefineStreamOutput, DEFINE_STREAMOUTPUT);
+ SVGA3D_DUMP_CASE_BASIC(DestroyStreamOutput, DESTROY_STREAMOUTPUT);
+ SVGA3D_DUMP_CASE_BASIC(SetInputLayout, SET_INPUT_LAYOUT);
+ SVGA3D_DUMP_CASE_LIST(SetVertexBuffers, SET_VERTEX_BUFFERS, SVGA3dVertexBuffer);
+ SVGA3D_DUMP_CASE_BASIC(SetTopology, SET_TOPOLOGY);
+ SVGA3D_DUMP_CASE_BASIC(SetIndexBuffer, SET_INDEX_BUFFER);
+
+ SVGA3D_DUMP_CASE_BASIC(PredCopy, PRED_COPY);
+ SVGA3D_DUMP_CASE_BASIC(UpdateSubResource, UPDATE_SUBRESOURCE);
+ SVGA3D_DUMP_CASE_BASIC(ReadbackSubResource, READBACK_SUBRESOURCE);
+ SVGA3D_DUMP_CASE_BASIC(PredCopyRegion, PRED_COPY_REGION);
+ SVGA3D_DUMP_CASE_BASIC(BufferCopy, BUFFER_COPY);
+ SVGA3D_DUMP_CASE_BASIC(BufferUpdate, BUFFER_UPDATE);
+ SVGA3D_DUMP_CASE_BASIC(GenMips, GENMIPS);
+ SVGA3D_DUMP_CASE_BASIC(TransferFromBuffer, TRANSFER_FROM_BUFFER);
+
+ case SVGA_3D_CMD_DX_SET_RENDERTARGETS:
+ _debug_printf("\tSVGA_3D_CMD_DX_SET_RENDERTARGETS\n");
+ {
+ const SVGA3dCmdDXSetRenderTargets *cmd =
+ (const SVGA3dCmdDXSetRenderTargets *) body;
+ _debug_printf("\t\t.depthStencilViewId = %u\n",
+ cmd->depthStencilViewId);
+ body = (const uint8_t *) &cmd[1];
+ while (body + sizeof(SVGA3dRenderTargetViewId) <= next) {
+ _debug_printf("\t\t.renderTargetViewId = %u\n",
+ *((SVGA3dRenderTargetViewId *) body));
+ body += sizeof(SVGA3dRenderTargetViewId);
+ }
+ }
+ break;
+
+ 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_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;
+ case SVGA_3D_CMD_INVALIDATE_GB_SURFACE:
+ _debug_printf("\tSVGA_3D_CMD_INVALIDATE_GB_SURFACE\n");
+ {
+ const SVGA3dCmdInvalidateGBSurface *cmd = (const SVGA3dCmdInvalidateGBSurface *)body;
+ dump_SVGA3dCmdInvalidateGBSurface(cmd);
+ body = (const uint8_t *)&cmd[1];
+ }
+ break;
+ case SVGA_3D_CMD_INTRA_SURFACE_COPY:
+ _debug_printf("\tSVGA_3D_CMD_INTRA_SURFACE_COPY\n");
+ {
+ const SVGA3dCmdIntraSurfaceCopy *cmd = (const SVGA3dCmdIntraSurfaceCopy *)body;
+ dump_SVGA3dCmdIntraSurfaceCopy(cmd);
+ body = (const uint8_t *)&cmd[1];
+ }
+ 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);
+ }
+ }
+}
+#endif /* LOG_ENABLED */
diff --git a/src/VBox/Devices/Graphics/svgadump/svga_dump.h b/src/VBox/Devices/Graphics/svgadump/svga_dump.h
new file mode 100644
index 00000000..c252ac74
--- /dev/null
+++ b/src/VBox/Devices/Graphics/svgadump/svga_dump.h
@@ -0,0 +1,39 @@
+/**********************************************************
+ * 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 <iprt/types.h>
+
+RT_C_DECLS_BEGIN
+void
+svga_dump_command(uint32_t cmd_id, const void *data, uint32_t size);
+
+void
+svga_dump_commands(const void *commands, uint32_t size);
+RT_C_DECLS_END
+
+#endif /* SVGA_DUMP_H_ */
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-23 12:13:56 +0000