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