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#ifdef DEBUG
12
13static char __thread tls[128];
14
15const 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
27const 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
39const 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)
64const 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)
93const 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)
116const 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
130const 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
145const 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
167const 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
194const 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
228static const char *
229nine_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
240static const char *
241nine_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
256static const char *
257nine_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
271static const char *
272nine_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
286void
287nine_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
312void
313nine_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
328void
329nine_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
381void
382nine_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
423void
424nine_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 */
814