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