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