src/gallium/frontends/nine/nine_dump.c

   1
   2 #include "nine_debug.h"
   3 #include "nine_pipe.h"
   4
   5 #include <stdio.h>
   6 #include "util/u_memory.h"
   7 #include "util/u_math.h"
   8
   9 #include "nine_dump.h"
  10
  11 #if defined(DEBUG) || !defined(NDEBUG)
  12
  13 static char __thread tls[128];
  14
  15 const char *nine_D3DDEVTYPE_to_str(D3DDEVTYPE type)
  16 {
  17     switch (type) {
  18     case D3DDEVTYPE_HAL: return "HAL";
  19     case D3DDEVTYPE_NULLREF: return "NULLREF";
  20     case D3DDEVTYPE_REF: return "REF";
  21     case D3DDEVTYPE_SW: return "SW";
  22     default:
  23        return "(D3DDEVTYPE_?)";
  24     }
  25 }
  26
  27 const char *nine_D3DPOOL_to_str(D3DPOOL pool)
  28 {
  29     switch (pool) {
  30     case D3DPOOL_DEFAULT: return "DEFAULT";
  31     case D3DPOOL_MANAGED: return "MANAGED";
  32     case D3DPOOL_SYSTEMMEM: return "SYSTEMMEM";
  33     case D3DPOOL_SCRATCH: return "SCRATCH";
  34     default:
  35         return "(D3DPOOL_?)";
  36     }
  37 }
  38
  39 const char *nine_D3DSAMP_to_str(DWORD samp)
  40 {
  41     switch (samp) {
  42     case D3DSAMP_ADDRESSU: return "ADDRESSU";
  43     case D3DSAMP_ADDRESSV: return "ADDRESSV";
  44     case D3DSAMP_ADDRESSW: return "ADDRESSW";
  45     case D3DSAMP_BORDERCOLOR: return "BORDERCOLOR";
  46     case D3DSAMP_MAGFILTER: return "MAGFILTER";
  47     case D3DSAMP_MINFILTER: return "MINFILTER";
  48     case D3DSAMP_MIPFILTER: return "MIPFILTER";
  49     case D3DSAMP_MIPMAPLODBIAS: return "MIPMAPLODBIAS";
  50     case D3DSAMP_MAXMIPLEVEL: return "MAXMIPLEVEL";
  51     case D3DSAMP_MAXANISOTROPY: return "MAXANISOTROPY";
  52     case D3DSAMP_SRGBTEXTURE: return "SRGBTEXTURE";
  53     case D3DSAMP_ELEMENTINDEX: return "ELEMENTINDEX";
  54     case D3DSAMP_DMAPOFFSET: return "DMAPOFFSET";
  55     default:
  56         return "(D3DSAMP_?)";
  57     }
  58 }
  59
  60 #define C2S(n,s) \
  61     do { \
  62         if (usage & D3DUSAGE_##n) p += snprintf(&tls[p], sizeof(tls) - p, s); \
  63     } while(0)
  64 const char *nine_D3DUSAGE_to_str(DWORD usage)
  65 {
  66     int p = 0;
  67     tls[0] = 0;
  68     C2S(AUTOGENMIPMAP, "MIPGEN");
  69     C2S(WRITEONLY, "WO");
  70     C2S(DYNAMIC, "DYNAMIC");
  71     C2S(DEPTHSTENCIL, "DS");
  72     C2S(RENDERTARGET, "RT");
  73     C2S(SOFTWAREPROCESSING, "SW");
  74     C2S(DONOTCLIP, "NOCLIP");
  75     C2S(POINTS, "POINTS");
  76     C2S(DMAP, "DMAP");
  77     C2S(NPATCHES, "NPATCHES");
  78     C2S(RTPATCHES, "RTPATCHES");
  79     C2S(TEXTAPI, "TEXTAPI");
  80     C2S(NONSECURE, "NONSECURE");
  81     C2S(RESTRICTED_CONTENT, "RESTRICTED_CONTENT");
  82     C2S(RESTRICT_SHARED_RESOURCE, "RESTRICT_SHARED_RESOURCE");
  83     C2S(RESTRICT_SHARED_RESOURCE_DRIVER, "RESTRICT_SHARED_RESOURCE_DRIVER");
  84     return tls;
  85 }
  86 #undef C2S
  87
  88 #define C2S(n) \
  89     do { \
  90         if (flags & D3DPRESENTFLAG_##n) \
  91             p += snprintf(&tls[p], sizeof(tls) - p, #n); \
  92     } while(0)
  93 const char *nine_D3DPRESENTFLAG_to_str(DWORD flags)
  94 {
  95     int p = 0;
  96     tls[0] = 0;
  97     C2S(DEVICECLIP);
  98     C2S(DISCARD_DEPTHSTENCIL);
  99     C2S(LOCKABLE_BACKBUFFER);
 100     C2S(NOAUTOROTATE);
 101     C2S(UNPRUNEDMODE);
 102     C2S(VIDEO);
 103     C2S(OVERLAY_LIMITEDRGB);
 104     C2S(OVERLAY_YCbCr_BT709);
 105     C2S(OVERLAY_YCbCr_xvYCC);
 106     C2S(RESTRICTED_CONTENT);
 107     C2S(RESTRICT_SHARED_RESOURCE_DRIVER);
 108     return tls;
 109 }
 110 #undef C2S
 111
 112 #define C2S(n) \
 113     do { \
 114         if (lock & D3DLOCK_##n) p += snprintf(&tls[p], sizeof(tls) - p, #n"|"); \
 115     } while(0)
 116 const char *nine_D3DLOCK_to_str(DWORD lock)
 117 {
 118     int p = 0;
 119     tls[0] = 0;
 120     C2S(DISCARD);
 121     C2S(DONOTWAIT);
 122     C2S(NO_DIRTY_UPDATE);
 123     C2S(NOOVERWRITE);
 124     C2S(NOSYSLOCK);
 125     C2S(READONLY);
 126     return tls;
 127 }
 128 #undef C2S
 129
 130 const char *nine_D3DRTYPE_to_str(D3DRESOURCETYPE type)
 131 {
 132     switch (type) {
 133     case D3DRTYPE_SURFACE: return "SURFACE";
 134     case D3DRTYPE_VOLUME: return "VOLUME";
 135     case D3DRTYPE_TEXTURE: return "TEXTURE";
 136     case D3DRTYPE_VOLUMETEXTURE: return "VOLUMETEXTURE";
 137     case D3DRTYPE_CUBETEXTURE: return "CUBETEXTURE";
 138     case D3DRTYPE_VERTEXBUFFER: return "VERTEXBUFFER";
 139     case D3DRTYPE_INDEXBUFFER: return "INDEXBUFFER";
 140     default:
 141         return "(D3DRTYPE_?)";
 142     }
 143 }
 144
 145 const char *nine_D3DQUERYTYPE_to_str(D3DQUERYTYPE type)
 146 {
 147     switch (type) {
 148     case D3DQUERYTYPE_VCACHE: return "VCACHE";
 149     case D3DQUERYTYPE_RESOURCEMANAGER: return "RESOURCEMANAGER";
 150     case D3DQUERYTYPE_VERTEXSTATS: return "VERTEXSTATS";
 151     case D3DQUERYTYPE_EVENT: return "EVENT";
 152     case D3DQUERYTYPE_OCCLUSION: return "OCCLUSION";
 153     case D3DQUERYTYPE_TIMESTAMP: return "TIMESTAMP";
 154     case D3DQUERYTYPE_TIMESTAMPDISJOINT: return "TIMESTAMPDISJOINT";
 155     case D3DQUERYTYPE_TIMESTAMPFREQ: return "TIMESTAMPFREQ";
 156     case D3DQUERYTYPE_PIPELINETIMINGS: return "PIPELINETIMINGS";
 157     case D3DQUERYTYPE_INTERFACETIMINGS: return "INTERFACETIMINGS";
 158     case D3DQUERYTYPE_VERTEXTIMINGS: return "VERTEXTIMINGS";
 159     case D3DQUERYTYPE_PIXELTIMINGS: return "PIXELTIMINGS";
 160     case D3DQUERYTYPE_BANDWIDTHTIMINGS: return "BANDWIDTHTIMINGS";
 161     case D3DQUERYTYPE_CACHEUTILIZATION: return "CACHEUTILIZATION";
 162     default:
 163         return "(D3DQUERYTYPE_?)";
 164     }
 165 }
 166
 167 const char *nine_D3DTSS_to_str(D3DTEXTURESTAGESTATETYPE type)
 168 {
 169     switch (type) {
 170     case D3DTSS_COLOROP: return "COLOROP";
 171     case D3DTSS_ALPHAOP: return "ALPHAOP";
 172     case D3DTSS_COLORARG0: return "COLORARG0";
 173     case D3DTSS_COLORARG1: return "COLORARG1";
 174     case D3DTSS_COLORARG2: return "COLORARG2";
 175     case D3DTSS_ALPHAARG0: return "ALPHAARG0";
 176     case D3DTSS_ALPHAARG1: return "ALPHAARG1";
 177     case D3DTSS_ALPHAARG2: return "ALPHAARG2";
 178     case D3DTSS_RESULTARG: return "RESULTARG";
 179     case D3DTSS_BUMPENVMAT00: return "BUMPENVMAT00";
 180     case D3DTSS_BUMPENVMAT01: return "BUMPENVMAT01";
 181     case D3DTSS_BUMPENVMAT10: return "BUMPENVMAT10";
 182     case D3DTSS_BUMPENVMAT11: return "BUMPENVMAT11";
 183     case D3DTSS_BUMPENVLSCALE: return "BUMPENVLSCALE";
 184     case D3DTSS_BUMPENVLOFFSET: return "BUMPENVLOFFSET";
 185     case D3DTSS_TEXCOORDINDEX: return "TEXCOORDINDEX";
 186     case D3DTSS_TEXTURETRANSFORMFLAGS: return "TEXTURETRANSFORMFLAGS";
 187     case D3DTSS_CONSTANT: return "CONSTANT";
 188     default:
 189         return "(D3DTSS_?)";
 190     }
 191 }
 192
 193 #define D3DTOP_TO_STR_CASE(n) case D3DTOP_##n: return #n
 194 const char *nine_D3DTOP_to_str(D3DTEXTUREOP top)
 195 {
 196     switch (top) {
 197     D3DTOP_TO_STR_CASE(DISABLE);
 198     D3DTOP_TO_STR_CASE(SELECTARG1);
 199     D3DTOP_TO_STR_CASE(SELECTARG2);
 200     D3DTOP_TO_STR_CASE(MODULATE);
 201     D3DTOP_TO_STR_CASE(MODULATE2X);
 202     D3DTOP_TO_STR_CASE(MODULATE4X);
 203     D3DTOP_TO_STR_CASE(ADD);
 204     D3DTOP_TO_STR_CASE(ADDSIGNED);
 205     D3DTOP_TO_STR_CASE(ADDSIGNED2X);
 206     D3DTOP_TO_STR_CASE(SUBTRACT);
 207     D3DTOP_TO_STR_CASE(ADDSMOOTH);
 208     D3DTOP_TO_STR_CASE(BLENDDIFFUSEALPHA);
 209     D3DTOP_TO_STR_CASE(BLENDTEXTUREALPHA);
 210     D3DTOP_TO_STR_CASE(BLENDFACTORALPHA);
 211     D3DTOP_TO_STR_CASE(BLENDTEXTUREALPHAPM);
 212     D3DTOP_TO_STR_CASE(BLENDCURRENTALPHA);
 213     D3DTOP_TO_STR_CASE(PREMODULATE);
 214     D3DTOP_TO_STR_CASE(MODULATEALPHA_ADDCOLOR);
 215     D3DTOP_TO_STR_CASE(MODULATECOLOR_ADDALPHA);
 216     D3DTOP_TO_STR_CASE(MODULATEINVALPHA_ADDCOLOR);
 217     D3DTOP_TO_STR_CASE(MODULATEINVCOLOR_ADDALPHA);
 218     D3DTOP_TO_STR_CASE(BUMPENVMAP);
 219     D3DTOP_TO_STR_CASE(BUMPENVMAPLUMINANCE);
 220     D3DTOP_TO_STR_CASE(DOTPRODUCT3);
 221     D3DTOP_TO_STR_CASE(MULTIPLYADD);
 222     D3DTOP_TO_STR_CASE(LERP);
 223     default:
 224         return "(D3DTOP_?)";
 225     }
 226 }
 227
 228 static const char *
 229 nine_D3DLIGHTTYPE_to_str(D3DLIGHTTYPE type)
 230 {
 231     switch (type) {
 232     case D3DLIGHT_POINT: return "POINT";
 233     case D3DLIGHT_SPOT: return "SPOT";
 234     case D3DLIGHT_DIRECTIONAL: return "DIRECTIONAL";
 235     default:
 236         return "(D3DLIGHT_?)";
 237     }
 238 }
 239
 240 static const char *
 241 nine_D3DTA_to_str(DWORD value)
 242 {
 243     switch (value & D3DTA_SELECTMASK) {
 244     case D3DTA_DIFFUSE: return "DIFFUSE";
 245     case D3DTA_CURRENT: return "CURRENT";
 246     case D3DTA_TEXTURE: return "TEXTURE";
 247     case D3DTA_TFACTOR: return "TFACTOR";
 248     case D3DTA_SPECULAR: return "SPECULAR";
 249     case D3DTA_TEMP: return "TEMP";
 250     case D3DTA_CONSTANT: return "CONSTANT";
 251     default:
 252         return "(D3DTA_?)";
 253     }
 254 }
 255
 256 static const char *
 257 nine_D3DTSS_TCI_to_str(DWORD value)
 258 {
 259     switch (value & 0xf0000) {
 260     case D3DTSS_TCI_PASSTHRU: return "PASSTHRU";
 261     case D3DTSS_TCI_CAMERASPACENORMAL: return "CAMERASPACENORMAL";
 262     case D3DTSS_TCI_CAMERASPACEPOSITION: return "CAMERASPACEPOSITION";
 263     case D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR:
 264         return "CAMERASPACEREFLECTIONVECTOR";
 265     case D3DTSS_TCI_SPHEREMAP: return "SPHEREMAP";
 266     default:
 267         return "(D3DTSS_TCI_?)";
 268     }
 269 }
 270
 271 static const char *
 272 nine_D3DTTFF_to_str(DWORD value)
 273 {
 274     switch (value) {
 275     case D3DTTFF_DISABLE: return "DISABLE";
 276     case D3DTTFF_COUNT1: return "COUNT1";
 277     case D3DTTFF_COUNT2: return "COUNT2";
 278     case D3DTTFF_COUNT3: return "COUNT3";
 279     case D3DTTFF_COUNT4: return "COUNT4";
 280     case D3DTTFF_PROJECTED: return "PROJECTED";
 281     default:
 282         return "(D3DTTFF_?)";
 283     }
 284 }
 285
 286 void
 287 nine_dump_D3DLIGHT9(unsigned ch, const D3DLIGHT9 *lit)
 288 {
 289     DBG_FLAG(ch, "D3DLIGHT9(%p):\n"
 290              "Type: %s\n"
 291              "Diffuse: (%f %f %f %f)\n"
 292              "Specular: (%f %f %f %f)\n"
 293              "Ambient: (%f %f %f %f)\n"
 294              "Position: (%f %f %f)\n"
 295              "Direction: (%f %f %f)\n"
 296              "Range: %f\n"
 297              "Falloff: %f\n"
 298              "Attenuation: %f + %f * d + %f * d^2\n"
 299              "Theta: %f deg\n"
 300              "Phi: %f deg\n", lit,
 301              nine_D3DLIGHTTYPE_to_str(lit->Type),
 302              lit->Diffuse.r,lit->Diffuse.r,lit->Diffuse.g,lit->Diffuse.a,
 303              lit->Specular.r,lit->Specular.r,lit->Specular.g,lit->Specular.a,
 304              lit->Ambient.r,lit->Ambient.r,lit->Ambient.g,lit->Ambient.a,
 305              lit->Position.x,lit->Position.y,lit->Position.z,
 306              lit->Direction.x,lit->Direction.y,lit->Direction.z,
 307              lit->Range,lit->Falloff,
 308              lit->Attenuation0,lit->Attenuation1,lit->Attenuation2,
 309              lit->Theta * 360.0f / M_PI,lit->Phi * 360.0f / M_PI);
 310 }
 311
 312 void
 313 nine_dump_D3DMATERIAL9(unsigned ch, const D3DMATERIAL9 *mat)
 314 {
 315     DBG_FLAG(ch, "D3DMATERIAL9(%p):\n"
 316              "Diffuse: (%f %f %f %f)\n"
 317              "Specular: (%f %f %f %f)\n"
 318              "Ambient: (%f %f %f %f)\n"
 319              "Emissive: (%f %f %f %f)\n"
 320              "Power: %f\n", mat,
 321              mat->Diffuse.r,mat->Diffuse.r,mat->Diffuse.g,mat->Diffuse.a,
 322              mat->Specular.r,mat->Specular.r,mat->Specular.g,mat->Specular.a,
 323              mat->Ambient.r,mat->Ambient.r,mat->Ambient.g,mat->Ambient.a,
 324              mat->Emissive.r,mat->Emissive.r,mat->Emissive.g,mat->Emissive.a,
 325              mat->Power);
 326 }
 327
 328 void
 329 nine_dump_D3DTSS_value(unsigned ch, D3DTEXTURESTAGESTATETYPE type, DWORD value)
 330 {
 331     float rgba[4];
 332
 333     switch (type) {
 334     case D3DTSS_COLOROP:
 335     case D3DTSS_ALPHAOP:
 336         DBG_FLAG(ch, "D3DTSS_%s = %s\n",
 337                  nine_D3DTSS_to_str(type), nine_D3DTOP_to_str(value));
 338         break;
 339     case D3DTSS_COLORARG0:
 340     case D3DTSS_COLORARG1:
 341     case D3DTSS_COLORARG2:
 342     case D3DTSS_ALPHAARG0:
 343     case D3DTSS_ALPHAARG1:
 344     case D3DTSS_ALPHAARG2:
 345     case D3DTSS_RESULTARG:
 346         DBG_FLAG(ch, "D3DTSS_%s = %s%s%s\n",
 347                  nine_D3DTSS_to_str(type),
 348                  (value & D3DTA_COMPLEMENT) ? "COMPLEMENT " : "",
 349                  (value & D3DTA_ALPHAREPLICATE) ? "ALPHAREPLICATE " : "",
 350                  nine_D3DTA_to_str(value));
 351         break;
 352     case D3DTSS_BUMPENVMAT00:
 353     case D3DTSS_BUMPENVMAT01:
 354     case D3DTSS_BUMPENVMAT10:
 355     case D3DTSS_BUMPENVMAT11:
 356     case D3DTSS_BUMPENVLSCALE:
 357     case D3DTSS_BUMPENVLOFFSET:
 358         DBG_FLAG(ch, "D3DTSS_%s = %f\n",
 359                  nine_D3DTSS_to_str(type), asfloat(value));
 360         break;
 361     case D3DTSS_TEXCOORDINDEX:
 362         DBG_FLAG(ch, "D3DTSS_TEXCOORDINDEX = %s %u\n",
 363                  nine_D3DTSS_TCI_to_str(value),
 364                  value & 0xffff);
 365         break;
 366     case D3DTSS_TEXTURETRANSFORMFLAGS:
 367         DBG_FLAG(ch, "D3DTSS_TEXTURETRANSFORMFLAGS = %s\n",
 368                  nine_D3DTTFF_to_str(value));
 369         break;
 370     case D3DTSS_CONSTANT:
 371         d3dcolor_to_rgba(rgba, value);
 372         DBG_FLAG(ch, "D3DTSS_CONSTANT = %f %f %f %F\n",
 373                  rgba[0],rgba[1],rgba[2],rgba[3]);
 374         break;
 375     default:
 376         DBG_FLAG(ch, "D3DTSS_? = 0x%08x\n", value);
 377         break;
 378     }
 379 }
 380
 381 void
 382 nine_dump_D3DADAPTER_IDENTIFIER9(unsigned ch, const D3DADAPTER_IDENTIFIER9 *id)
 383 {
 384     DBG_FLAG(ch, "D3DADAPTER_IDENTIFIER9(%p):\n"
 385              "Driver: %s\n"
 386              "Description: %s\n"
 387              "DeviceName: %s\n"
 388              "DriverVersion: %08x.%08x\n"
 389              "VendorId: %x\n"
 390              "DeviceId: %x\n"
 391              "SubSysId: %x\n"
 392              "Revision: %u\n"
 393              "GUID: %08x.%04x.%04x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x\n"
 394              "WHQLLevel: %u\n", id, id->Driver, id->Description,
 395              id->DeviceName,
 396              id->DriverVersionLowPart, id->DriverVersionHighPart,
 397              id->VendorId, id->DeviceId, id->SubSysId,
 398              id->Revision,
 399              id->DeviceIdentifier.Data1,
 400              id->DeviceIdentifier.Data2,
 401              id->DeviceIdentifier.Data3,
 402              id->DeviceIdentifier.Data4[0],
 403              id->DeviceIdentifier.Data4[1],
 404              id->DeviceIdentifier.Data4[2],
 405              id->DeviceIdentifier.Data4[3],
 406              id->DeviceIdentifier.Data4[4],
 407              id->DeviceIdentifier.Data4[5],
 408              id->DeviceIdentifier.Data4[6],
 409              id->DeviceIdentifier.Data4[7],
 410              id->WHQLLevel);
 411 }
 412
 413 #define C2S(args...) p += snprintf(&s[p],c-p,args)
 414
 415 #define CAP_CASE(m,p,n) \
 416     do {                     \
 417         if (caps->m & p##_##n) \
 418             C2S(" "#n); \
 419         else \
 420             C2S(" ("#n")"); \
 421     } while(0)
 422
 423 void
 424 nine_dump_D3DCAPS9(unsigned ch, const D3DCAPS9 *caps)
 425 {
 426     const int c = 1 << 17;
 427     int p = 0;
 428     char *s = (char *)MALLOC(c);
 429
 430     if (!s) {
 431         DBG_FLAG(ch, "D3DCAPS9(%p): (out of memory)\n", caps);
 432         return;
 433     }
 434
 435     C2S("DeviceType: %s\n", nine_D3DDEVTYPE_to_str(caps->DeviceType));
 436
 437     C2S("AdapterOrdinal: %u\nCaps:", caps->AdapterOrdinal);
 438     if (caps->Caps & 0x20000)
 439         C2S(" READ_SCANLINE");
 440     if (caps->Caps & ~0x20000)
 441         C2S(" %x", caps->Caps & ~0x20000);
 442
 443     C2S("\nCaps2:");
 444     CAP_CASE(Caps2, D3DCAPS2, CANAUTOGENMIPMAP);
 445     CAP_CASE(Caps2, D3DCAPS2, CANCALIBRATEGAMMA);
 446     CAP_CASE(Caps2, D3DCAPS2, CANSHARERESOURCE);
 447     CAP_CASE(Caps2, D3DCAPS2, CANMANAGERESOURCE);
 448     CAP_CASE(Caps2, D3DCAPS2, DYNAMICTEXTURES);
 449     CAP_CASE(Caps2, D3DCAPS2, FULLSCREENGAMMA);
 450
 451     C2S("\nCaps3:");
 452     CAP_CASE(Caps3, D3DCAPS3, ALPHA_FULLSCREEN_FLIP_OR_DISCARD);
 453     CAP_CASE(Caps3, D3DCAPS3, COPY_TO_VIDMEM);
 454     CAP_CASE(Caps3, D3DCAPS3, COPY_TO_SYSTEMMEM);
 455     CAP_CASE(Caps3, D3DCAPS3, DXVAHD);
 456     CAP_CASE(Caps3, D3DCAPS3, LINEAR_TO_SRGB_PRESENTATION);
 457
 458     C2S("\nPresentationIntervals:");
 459     CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, ONE);
 460     CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, TWO);
 461     CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, THREE);
 462     CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, FOUR);
 463     CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, IMMEDIATE);
 464
 465     C2S("\nCursorCaps:");
 466     CAP_CASE(CursorCaps, D3DCURSORCAPS, COLOR);
 467     CAP_CASE(CursorCaps, D3DCURSORCAPS, LOWRES);
 468
 469     C2S("\nDevCaps:");
 470     CAP_CASE(DevCaps, D3DDEVCAPS, CANBLTSYSTONONLOCAL);
 471     CAP_CASE(DevCaps, D3DDEVCAPS, CANRENDERAFTERFLIP);
 472     CAP_CASE(DevCaps, D3DDEVCAPS, DRAWPRIMITIVES2);
 473     CAP_CASE(DevCaps, D3DDEVCAPS, DRAWPRIMITIVES2EX);
 474     CAP_CASE(DevCaps, D3DDEVCAPS, DRAWPRIMTLVERTEX);
 475     CAP_CASE(DevCaps, D3DDEVCAPS, EXECUTESYSTEMMEMORY);
 476     CAP_CASE(DevCaps, D3DDEVCAPS, EXECUTEVIDEOMEMORY);
 477     CAP_CASE(DevCaps, D3DDEVCAPS, HWRASTERIZATION);
 478     CAP_CASE(DevCaps, D3DDEVCAPS, HWTRANSFORMANDLIGHT);
 479     CAP_CASE(DevCaps, D3DDEVCAPS, NPATCHES);
 480     CAP_CASE(DevCaps, D3DDEVCAPS, PUREDEVICE);
 481     CAP_CASE(DevCaps, D3DDEVCAPS, QUINTICRTPATCHES);
 482     CAP_CASE(DevCaps, D3DDEVCAPS, RTPATCHES);
 483     CAP_CASE(DevCaps, D3DDEVCAPS, RTPATCHHANDLEZERO);
 484     CAP_CASE(DevCaps, D3DDEVCAPS, SEPARATETEXTUREMEMORIES);
 485     CAP_CASE(DevCaps, D3DDEVCAPS, TEXTURENONLOCALVIDMEM);
 486     CAP_CASE(DevCaps, D3DDEVCAPS, TEXTURESYSTEMMEMORY);
 487     CAP_CASE(DevCaps, D3DDEVCAPS, TEXTUREVIDEOMEMORY);
 488     CAP_CASE(DevCaps, D3DDEVCAPS, TLVERTEXSYSTEMMEMORY);
 489     CAP_CASE(DevCaps, D3DDEVCAPS, TLVERTEXVIDEOMEMORY);
 490
 491     C2S("\nPrimitiveMiscCaps:");
 492     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, MASKZ);
 493     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CULLNONE);
 494     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CULLCW);
 495     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CULLCCW);
 496     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, COLORWRITEENABLE);
 497     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CLIPPLANESCALEDPOINTS);
 498     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CLIPTLVERTS);
 499     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, TSSARGTEMP);
 500     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, BLENDOP);
 501     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, NULLREFERENCE);
 502     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, INDEPENDENTWRITEMASKS);
 503     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, PERSTAGECONSTANT);
 504     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, POSTBLENDSRGBCONVERT);
 505     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, FOGANDSPECULARALPHA);
 506     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, SEPARATEALPHABLEND);
 507     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, MRTINDEPENDENTBITDEPTHS);
 508     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, MRTPOSTPIXELSHADERBLENDING);
 509     CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, FOGVERTEXCLAMPED);
 510
 511     C2S("\nRasterCaps:");
 512     CAP_CASE(RasterCaps, D3DPRASTERCAPS, ANISOTROPY);
 513     CAP_CASE(RasterCaps, D3DPRASTERCAPS, COLORPERSPECTIVE);
 514     CAP_CASE(RasterCaps, D3DPRASTERCAPS, DITHER);
 515     CAP_CASE(RasterCaps, D3DPRASTERCAPS, DEPTHBIAS);
 516     CAP_CASE(RasterCaps, D3DPRASTERCAPS, FOGRANGE);
 517     CAP_CASE(RasterCaps, D3DPRASTERCAPS, FOGTABLE);
 518     CAP_CASE(RasterCaps, D3DPRASTERCAPS, FOGVERTEX);
 519     CAP_CASE(RasterCaps, D3DPRASTERCAPS, MIPMAPLODBIAS);
 520     CAP_CASE(RasterCaps, D3DPRASTERCAPS, MULTISAMPLE_TOGGLE);
 521     CAP_CASE(RasterCaps, D3DPRASTERCAPS, SCISSORTEST);
 522     CAP_CASE(RasterCaps, D3DPRASTERCAPS, SLOPESCALEDEPTHBIAS);
 523     CAP_CASE(RasterCaps, D3DPRASTERCAPS, WBUFFER);
 524     CAP_CASE(RasterCaps, D3DPRASTERCAPS, WFOG);
 525     CAP_CASE(RasterCaps, D3DPRASTERCAPS, ZBUFFERLESSHSR);
 526     CAP_CASE(RasterCaps, D3DPRASTERCAPS, ZFOG);
 527     CAP_CASE(RasterCaps, D3DPRASTERCAPS, ZTEST);
 528
 529     C2S("\nZCmpCaps:");
 530     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, ALWAYS);
 531     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, EQUAL);
 532     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, GREATER);
 533     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, GREATEREQUAL);
 534     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, LESS);
 535     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, LESSEQUAL);
 536     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, NEVER);
 537     CAP_CASE(ZCmpCaps, D3DPCMPCAPS, NOTEQUAL);
 538
 539     C2S("\nSrcBlendCaps");
 540     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, BLENDFACTOR);
 541     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, BOTHINVSRCALPHA);
 542     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, BOTHSRCALPHA);
 543     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, DESTALPHA);
 544     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, DESTCOLOR);
 545     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVDESTALPHA);
 546     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVDESTCOLOR);
 547     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVSRCALPHA);
 548     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR);
 549     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR2);
 550     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, ONE);
 551     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCALPHA);
 552     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCALPHASAT);
 553     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCCOLOR);
 554     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCCOLOR2);
 555     CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, ZERO);
 556
 557     C2S("\nDestBlendCaps");
 558     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, BLENDFACTOR);
 559     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, BOTHINVSRCALPHA);
 560     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, BOTHSRCALPHA);
 561     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, DESTALPHA);
 562     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, DESTCOLOR);
 563     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVDESTALPHA);
 564     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVDESTCOLOR);
 565     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVSRCALPHA);
 566     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR);
 567     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR2);
 568     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, ONE);
 569     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCALPHA);
 570     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCALPHASAT);
 571     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCCOLOR);
 572     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCCOLOR2);
 573     CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, ZERO);
 574
 575     C2S("\nAlphaCmpCaps:");
 576     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, ALWAYS);
 577     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, EQUAL);
 578     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, GREATER);
 579     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, GREATEREQUAL);
 580     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, LESS);
 581     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, LESSEQUAL);
 582     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, NEVER);
 583     CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, NOTEQUAL);
 584
 585     C2S("\nShadeCaps:");
 586     CAP_CASE(ShadeCaps, D3DPSHADECAPS, ALPHAGOURAUDBLEND);
 587     CAP_CASE(ShadeCaps, D3DPSHADECAPS, COLORGOURAUDRGB);
 588     CAP_CASE(ShadeCaps, D3DPSHADECAPS, FOGGOURAUD);
 589     CAP_CASE(ShadeCaps, D3DPSHADECAPS, SPECULARGOURAUDRGB);
 590
 591     C2S("\nTextureCaps:");
 592     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, ALPHA);
 593     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, ALPHAPALETTE);
 594     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, CUBEMAP);
 595     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, CUBEMAP_POW2);
 596     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, MIPCUBEMAP);
 597     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, MIPMAP);
 598     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, MIPVOLUMEMAP);
 599     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, NONPOW2CONDITIONAL);
 600     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, NOPROJECTEDBUMPENV);
 601     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, PERSPECTIVE);
 602     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, POW2);
 603     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, PROJECTED);
 604     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, SQUAREONLY);
 605     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, TEXREPEATNOTSCALEDBYSIZE);
 606     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, VOLUMEMAP);
 607     CAP_CASE(TextureCaps, D3DPTEXTURECAPS, VOLUMEMAP_POW2);
 608
 609     C2S("\nTextureFilterCaps:");
 610  /* CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */
 611     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT);
 612     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR);
 613     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC);
 614     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD);
 615     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD);
 616     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT);
 617     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR);
 618     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC);
 619     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD);
 620     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD);
 621     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT);
 622     CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR);
 623
 624     C2S("\nCubeTextureFilterCaps:");
 625  /* CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */
 626     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT);
 627     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR);
 628     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC);
 629     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD);
 630     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD);
 631     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT);
 632     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR);
 633     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC);
 634     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD);
 635     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD);
 636     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT);
 637     CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR);
 638
 639     C2S("\nVolumeTextureFilterCaps:");
 640  /* CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */
 641     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT);
 642     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR);
 643     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC);
 644     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD);
 645     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD);
 646     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT);
 647     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR);
 648     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC);
 649     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD);
 650     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD);
 651     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT);
 652     CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR);
 653
 654     C2S("\nTextureAddressCaps:");
 655     CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, BORDER);
 656     CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, CLAMP);
 657     CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, INDEPENDENTUV);
 658     CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, MIRROR);
 659     CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, MIRRORONCE);
 660     CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, WRAP);
 661
 662     C2S("\nVolumeTextureAddressCaps:");
 663     CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, BORDER);
 664     CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, CLAMP);
 665     CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, INDEPENDENTUV);
 666     CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, MIRROR);
 667     CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, MIRRORONCE);
 668     CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, WRAP);
 669
 670     C2S("\nLineCaps:");
 671     CAP_CASE(LineCaps, D3DLINECAPS, ALPHACMP);
 672     CAP_CASE(LineCaps, D3DLINECAPS, ANTIALIAS);
 673     CAP_CASE(LineCaps, D3DLINECAPS, BLEND);
 674     CAP_CASE(LineCaps, D3DLINECAPS, FOG);
 675     CAP_CASE(LineCaps, D3DLINECAPS, TEXTURE);
 676     CAP_CASE(LineCaps, D3DLINECAPS, ZTEST);
 677
 678     C2S("\nMaxTextureWidth: %u", caps->MaxTextureWidth);
 679     C2S("\nMaxTextureHeight: %u", caps->MaxTextureHeight);
 680     C2S("\nMaxVolumeExtent: %u", caps->MaxVolumeExtent);
 681     C2S("\nMaxTextureRepeat: %u", caps->MaxTextureRepeat);
 682     C2S("\nMaxTextureAspectRatio: %u", caps->MaxTextureAspectRatio);
 683     C2S("\nMaxAnisotropy: %u", caps->MaxAnisotropy);
 684     C2S("\nMaxVertexW: %f", caps->MaxVertexW);
 685
 686     C2S("\nGuardBandLef,Top,Right,Bottom: %f %f %f %f",
 687         caps->GuardBandLeft, caps->GuardBandTop,
 688         caps->GuardBandRight, caps->GuardBandBottom);
 689
 690     C2S("\nExtentsAdjust: %f", caps->ExtentsAdjust);
 691
 692     C2S("\nStencilCaps:");
 693     CAP_CASE(StencilCaps, D3DSTENCILCAPS, KEEP);
 694     CAP_CASE(StencilCaps, D3DSTENCILCAPS, ZERO);
 695     CAP_CASE(StencilCaps, D3DSTENCILCAPS, REPLACE);
 696     CAP_CASE(StencilCaps, D3DSTENCILCAPS, INCRSAT);
 697     CAP_CASE(StencilCaps, D3DSTENCILCAPS, DECRSAT);
 698     CAP_CASE(StencilCaps, D3DSTENCILCAPS, INVERT);
 699     CAP_CASE(StencilCaps, D3DSTENCILCAPS, INCR);
 700     CAP_CASE(StencilCaps, D3DSTENCILCAPS, DECR);
 701     CAP_CASE(StencilCaps, D3DSTENCILCAPS, TWOSIDED);
 702
 703     C2S("\nFVFCaps:");
 704     CAP_CASE(FVFCaps, D3DFVFCAPS, DONOTSTRIPELEMENTS);
 705     CAP_CASE(FVFCaps, D3DFVFCAPS, PSIZE);
 706     CAP_CASE(FVFCaps, D3DFVFCAPS, TEXCOORDCOUNTMASK);
 707
 708     C2S("\nTextureOpCaps:");
 709     CAP_CASE(TextureOpCaps, D3DTEXOPCAPS, ADD);
 710     CAP_CASE(TextureOpCaps, D3DTEXOPCAPS, ADDSIGNED);
 711     C2S(" ...");
 712
 713     C2S("\nMaxTextureBlendStages: %u", caps->MaxTextureBlendStages);
 714     C2S("\nMaxSimultaneousTextures: %u", caps->MaxTextureBlendStages);
 715
 716     C2S("\nVertexProcessingCaps:");
 717     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, DIRECTIONALLIGHTS);
 718     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, LOCALVIEWER);
 719     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, MATERIALSOURCE7);
 720     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, NO_TEXGEN_NONLOCALVIEWER);
 721     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, POSITIONALLIGHTS);
 722     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, TEXGEN);
 723     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, TEXGEN_SPHEREMAP);
 724     CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, TWEENING);
 725
 726     C2S("\nMaxActiveLights: %u", caps->MaxActiveLights);
 727     C2S("\nMaxUserClipPlanes: %u", caps->MaxUserClipPlanes);
 728     C2S("\nMaxVertexBlendMatrices: %u", caps->MaxVertexBlendMatrices);
 729     C2S("\nMaxVertexBlendMatrixIndex: %u", caps->MaxVertexBlendMatrixIndex);
 730     C2S("\nMaxPointSize: %f", caps->MaxPointSize);
 731     C2S("\nMaxPrimitiveCount: 0x%x", caps->MaxPrimitiveCount);
 732     C2S("\nMaxVertexIndex: 0x%x", caps->MaxVertexIndex);
 733     C2S("\nMaxStreams: %u", caps->MaxStreams);
 734     C2S("\nMaxStreamStride: 0x%x", caps->MaxStreamStride);
 735
 736     C2S("\nVertexShaderVersion: %08x", caps->VertexShaderVersion);
 737     C2S("\nMaxVertexShaderConst: %u", caps->MaxVertexShaderConst);
 738     C2S("\nPixelShaderVersion: %08x", caps->PixelShaderVersion);
 739     C2S("\nPixelShader1xMaxValue: %f", caps->PixelShader1xMaxValue);
 740
 741     DBG_FLAG(ch, "D3DCAPS9(%p) part 1:\n%s\n", caps, s);
 742     p = 0;
 743
 744     C2S("DevCaps2:");
 745     CAP_CASE(DevCaps2, D3DDEVCAPS2, ADAPTIVETESSRTPATCH);
 746     CAP_CASE(DevCaps2, D3DDEVCAPS2, ADAPTIVETESSNPATCH);
 747     CAP_CASE(DevCaps2, D3DDEVCAPS2, CAN_STRETCHRECT_FROM_TEXTURES);
 748     CAP_CASE(DevCaps2, D3DDEVCAPS2, DMAPNPATCH);
 749     CAP_CASE(DevCaps2, D3DDEVCAPS2, PRESAMPLEDDMAPNPATCH);
 750     CAP_CASE(DevCaps2, D3DDEVCAPS2, STREAMOFFSET);
 751     CAP_CASE(DevCaps2, D3DDEVCAPS2, VERTEXELEMENTSCANSHARESTREAMOFFSET);
 752
 753     C2S("\nMasterAdapterOrdinal: %u", caps->MasterAdapterOrdinal);
 754     C2S("\nAdapterOrdinalInGroup: %u", caps->AdapterOrdinalInGroup);
 755     C2S("\nNumberOfAdaptersInGroup: %u", caps->NumberOfAdaptersInGroup);
 756
 757     C2S("\nDeclTypes:");
 758     CAP_CASE(DeclTypes, D3DDTCAPS, UBYTE4);
 759     CAP_CASE(DeclTypes, D3DDTCAPS, UBYTE4N);
 760     CAP_CASE(DeclTypes, D3DDTCAPS, SHORT2N);
 761     CAP_CASE(DeclTypes, D3DDTCAPS, SHORT4N);
 762     CAP_CASE(DeclTypes, D3DDTCAPS, USHORT2N);
 763     CAP_CASE(DeclTypes, D3DDTCAPS, USHORT4N);
 764     CAP_CASE(DeclTypes, D3DDTCAPS, UDEC3);
 765     CAP_CASE(DeclTypes, D3DDTCAPS, DEC3N);
 766     CAP_CASE(DeclTypes, D3DDTCAPS, FLOAT16_2);
 767     CAP_CASE(DeclTypes, D3DDTCAPS, FLOAT16_4);
 768
 769     C2S("\nNumSimultaneousRTs: %u", caps->NumSimultaneousRTs);
 770
 771     C2S("\nStretchRectFilterCaps:");
 772     CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MINFPOINT);
 773     CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MINFLINEAR);
 774     CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MAGFPOINT);
 775     CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR);
 776
 777     C2S("\nVS20Caps.Caps: Predication=%s", caps->VS20Caps.Caps ? "yes" : "no");
 778     C2S("\nVS20Caps.DynamicFlowControlDepth: %u", caps->VS20Caps.DynamicFlowControlDepth);
 779     C2S("\nVS20Caps.NumTemps: %u", caps->VS20Caps.NumTemps);
 780     C2S("\nVS20Caps.StaticFlowControlDepth: %u", caps->VS20Caps.StaticFlowControlDepth);
 781
 782     C2S("\nPS20Caps.Caps: Predication=%s", caps->VS20Caps.Caps ? "yes" : "no");
 783     C2S("\nPS20Caps.DynamicFlowControlDepth: %u", caps->PS20Caps.DynamicFlowControlDepth);
 784     C2S("\nPS20Caps.NumTemps: %u", caps->PS20Caps.NumTemps);
 785     C2S("\nPS20Caps.StaticFlowControlDepth: %u", caps->PS20Caps.StaticFlowControlDepth);
 786     C2S("\nPS20Caps.NumInstructionSlots: %u", caps->PS20Caps.NumInstructionSlots);
 787
 788     C2S("\nVertexTextureFilterCaps");
 789  /* CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */
 790     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT);
 791     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR);
 792     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC);
 793     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD);
 794     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD);
 795     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT);
 796     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR);
 797     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC);
 798     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD);
 799     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD);
 800     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT);
 801     CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR);
 802
 803     C2S("\nMaxVShaderInstructionsExecuted: %u", caps->MaxVShaderInstructionsExecuted);
 804     C2S("\nMaxPShaderInstructionsExecuted: %u", caps->MaxPShaderInstructionsExecuted);
 805     C2S("\nMaxVertexShader30InstructionSlots: %u >= 512", caps->MaxVertexShader30InstructionSlots);
 806     C2S("\nMaxPixelShader30InstructionSlots: %u >= 512", caps->MaxPixelShader30InstructionSlots);
 807
 808     DBG_FLAG(ch, "D3DCAPS9(%p) part 2:\n%s\n", caps, s);
 809
 810     FREE(s);
 811 }
 812
 813 #endif /* DEBUG || !NDEBUG */