#include "nine_debug.h" #include "nine_pipe.h" #include <stdio.h> #include "util/u_memory.h" #include "util/u_math.h" #include "nine_dump.h" #ifdef DEBUG static char __thread tls[128]; const char *nine_D3DDEVTYPE_to_str(D3DDEVTYPE type) { switch (type) { case D3DDEVTYPE_HAL: return "HAL"; case D3DDEVTYPE_NULLREF: return "NULLREF"; case D3DDEVTYPE_REF: return "REF"; case D3DDEVTYPE_SW: return "SW"; default: return "(D3DDEVTYPE_?)"; } } const char *nine_D3DPOOL_to_str(D3DPOOL pool) { switch (pool) { case D3DPOOL_DEFAULT: return "DEFAULT"; case D3DPOOL_MANAGED: return "MANAGED"; case D3DPOOL_SYSTEMMEM: return "SYSTEMMEM"; case D3DPOOL_SCRATCH: return "SCRATCH"; default: return "(D3DPOOL_?)"; } } const char *nine_D3DSAMP_to_str(DWORD samp) { switch (samp) { case D3DSAMP_ADDRESSU: return "ADDRESSU"; case D3DSAMP_ADDRESSV: return "ADDRESSV"; case D3DSAMP_ADDRESSW: return "ADDRESSW"; case D3DSAMP_BORDERCOLOR: return "BORDERCOLOR"; case D3DSAMP_MAGFILTER: return "MAGFILTER"; case D3DSAMP_MINFILTER: return "MINFILTER"; case D3DSAMP_MIPFILTER: return "MIPFILTER"; case D3DSAMP_MIPMAPLODBIAS: return "MIPMAPLODBIAS"; case D3DSAMP_MAXMIPLEVEL: return "MAXMIPLEVEL"; case D3DSAMP_MAXANISOTROPY: return "MAXANISOTROPY"; case D3DSAMP_SRGBTEXTURE: return "SRGBTEXTURE"; case D3DSAMP_ELEMENTINDEX: return "ELEMENTINDEX"; case D3DSAMP_DMAPOFFSET: return "DMAPOFFSET"; default: return "(D3DSAMP_?)"; } } #define C2S(n,s) \ do { \ if (usage & D3DUSAGE_##n) p += snprintf(&tls[p], sizeof(tls) - p, s); \ } while(0) const char *nine_D3DUSAGE_to_str(DWORD usage) { int p = 0; tls[0] = 0; C2S(AUTOGENMIPMAP, "MIPGEN"); C2S(WRITEONLY, "WO"); C2S(DYNAMIC, "DYNAMIC"); C2S(DEPTHSTENCIL, "DS"); C2S(RENDERTARGET, "RT"); C2S(SOFTWAREPROCESSING, "SW"); C2S(DONOTCLIP, "NOCLIP"); C2S(POINTS, "POINTS"); C2S(DMAP, "DMAP"); C2S(NPATCHES, "NPATCHES"); C2S(RTPATCHES, "RTPATCHES"); C2S(TEXTAPI, "TEXTAPI"); C2S(NONSECURE, "NONSECURE"); C2S(RESTRICTED_CONTENT, "RESTRICTED_CONTENT"); C2S(RESTRICT_SHARED_RESOURCE, "RESTRICT_SHARED_RESOURCE"); C2S(RESTRICT_SHARED_RESOURCE_DRIVER, "RESTRICT_SHARED_RESOURCE_DRIVER"); return tls; } #undef C2S #define C2S(n) \ do { \ if (flags & D3DPRESENTFLAG_##n) \ p += snprintf(&tls[p], sizeof(tls) - p, #n); \ } while(0) const char *nine_D3DPRESENTFLAG_to_str(DWORD flags) { int p = 0; tls[0] = 0; C2S(DEVICECLIP); C2S(DISCARD_DEPTHSTENCIL); C2S(LOCKABLE_BACKBUFFER); C2S(NOAUTOROTATE); C2S(UNPRUNEDMODE); C2S(VIDEO); C2S(OVERLAY_LIMITEDRGB); C2S(OVERLAY_YCbCr_BT709); C2S(OVERLAY_YCbCr_xvYCC); C2S(RESTRICTED_CONTENT); C2S(RESTRICT_SHARED_RESOURCE_DRIVER); return tls; } #undef C2S #define C2S(n) \ do { \ if (lock & D3DLOCK_##n) p += snprintf(&tls[p], sizeof(tls) - p, #n"|"); \ } while(0) const char *nine_D3DLOCK_to_str(DWORD lock) { int p = 0; tls[0] = 0; C2S(DISCARD); C2S(DONOTWAIT); C2S(NO_DIRTY_UPDATE); C2S(NOOVERWRITE); C2S(NOSYSLOCK); C2S(READONLY); return tls; } #undef C2S const char *nine_D3DRTYPE_to_str(D3DRESOURCETYPE type) { switch (type) { case D3DRTYPE_SURFACE: return "SURFACE"; case D3DRTYPE_VOLUME: return "VOLUME"; case D3DRTYPE_TEXTURE: return "TEXTURE"; case D3DRTYPE_VOLUMETEXTURE: return "VOLUMETEXTURE"; case D3DRTYPE_CUBETEXTURE: return "CUBETEXTURE"; case D3DRTYPE_VERTEXBUFFER: return "VERTEXBUFFER"; case D3DRTYPE_INDEXBUFFER: return "INDEXBUFFER"; default: return "(D3DRTYPE_?)"; } } const char *nine_D3DQUERYTYPE_to_str(D3DQUERYTYPE type) { switch (type) { case D3DQUERYTYPE_VCACHE: return "VCACHE"; case D3DQUERYTYPE_RESOURCEMANAGER: return "RESOURCEMANAGER"; case D3DQUERYTYPE_VERTEXSTATS: return "VERTEXSTATS"; case D3DQUERYTYPE_EVENT: return "EVENT"; case D3DQUERYTYPE_OCCLUSION: return "OCCLUSION"; case D3DQUERYTYPE_TIMESTAMP: return "TIMESTAMP"; case D3DQUERYTYPE_TIMESTAMPDISJOINT: return "TIMESTAMPDISJOINT"; case D3DQUERYTYPE_TIMESTAMPFREQ: return "TIMESTAMPFREQ"; case D3DQUERYTYPE_PIPELINETIMINGS: return "PIPELINETIMINGS"; case D3DQUERYTYPE_INTERFACETIMINGS: return "INTERFACETIMINGS"; case D3DQUERYTYPE_VERTEXTIMINGS: return "VERTEXTIMINGS"; case D3DQUERYTYPE_PIXELTIMINGS: return "PIXELTIMINGS"; case D3DQUERYTYPE_BANDWIDTHTIMINGS: return "BANDWIDTHTIMINGS"; case D3DQUERYTYPE_CACHEUTILIZATION: return "CACHEUTILIZATION"; default: return "(D3DQUERYTYPE_?)"; } } const char *nine_D3DTSS_to_str(D3DTEXTURESTAGESTATETYPE type) { switch (type) { case D3DTSS_COLOROP: return "COLOROP"; case D3DTSS_ALPHAOP: return "ALPHAOP"; case D3DTSS_COLORARG0: return "COLORARG0"; case D3DTSS_COLORARG1: return "COLORARG1"; case D3DTSS_COLORARG2: return "COLORARG2"; case D3DTSS_ALPHAARG0: return "ALPHAARG0"; case D3DTSS_ALPHAARG1: return "ALPHAARG1"; case D3DTSS_ALPHAARG2: return "ALPHAARG2"; case D3DTSS_RESULTARG: return "RESULTARG"; case D3DTSS_BUMPENVMAT00: return "BUMPENVMAT00"; case D3DTSS_BUMPENVMAT01: return "BUMPENVMAT01"; case D3DTSS_BUMPENVMAT10: return "BUMPENVMAT10"; case D3DTSS_BUMPENVMAT11: return "BUMPENVMAT11"; case D3DTSS_BUMPENVLSCALE: return "BUMPENVLSCALE"; case D3DTSS_BUMPENVLOFFSET: return "BUMPENVLOFFSET"; case D3DTSS_TEXCOORDINDEX: return "TEXCOORDINDEX"; case D3DTSS_TEXTURETRANSFORMFLAGS: return "TEXTURETRANSFORMFLAGS"; case D3DTSS_CONSTANT: return "CONSTANT"; default: return "(D3DTSS_?)"; } } #define D3DTOP_TO_STR_CASE(n) case D3DTOP_##n: return #n const char *nine_D3DTOP_to_str(D3DTEXTUREOP top) { switch (top) { D3DTOP_TO_STR_CASE(DISABLE); D3DTOP_TO_STR_CASE(SELECTARG1); D3DTOP_TO_STR_CASE(SELECTARG2); D3DTOP_TO_STR_CASE(MODULATE); D3DTOP_TO_STR_CASE(MODULATE2X); D3DTOP_TO_STR_CASE(MODULATE4X); D3DTOP_TO_STR_CASE(ADD); D3DTOP_TO_STR_CASE(ADDSIGNED); D3DTOP_TO_STR_CASE(ADDSIGNED2X); D3DTOP_TO_STR_CASE(SUBTRACT); D3DTOP_TO_STR_CASE(ADDSMOOTH); D3DTOP_TO_STR_CASE(BLENDDIFFUSEALPHA); D3DTOP_TO_STR_CASE(BLENDTEXTUREALPHA); D3DTOP_TO_STR_CASE(BLENDFACTORALPHA); D3DTOP_TO_STR_CASE(BLENDTEXTUREALPHAPM); D3DTOP_TO_STR_CASE(BLENDCURRENTALPHA); D3DTOP_TO_STR_CASE(PREMODULATE); D3DTOP_TO_STR_CASE(MODULATEALPHA_ADDCOLOR); D3DTOP_TO_STR_CASE(MODULATECOLOR_ADDALPHA); D3DTOP_TO_STR_CASE(MODULATEINVALPHA_ADDCOLOR); D3DTOP_TO_STR_CASE(MODULATEINVCOLOR_ADDALPHA); D3DTOP_TO_STR_CASE(BUMPENVMAP); D3DTOP_TO_STR_CASE(BUMPENVMAPLUMINANCE); D3DTOP_TO_STR_CASE(DOTPRODUCT3); D3DTOP_TO_STR_CASE(MULTIPLYADD); D3DTOP_TO_STR_CASE(LERP); default: return "(D3DTOP_?)"; } } static const char * nine_D3DLIGHTTYPE_to_str(D3DLIGHTTYPE type) { switch (type) { case D3DLIGHT_POINT: return "POINT"; case D3DLIGHT_SPOT: return "SPOT"; case D3DLIGHT_DIRECTIONAL: return "DIRECTIONAL"; default: return "(D3DLIGHT_?)"; } } static const char * nine_D3DTA_to_str(DWORD value) { switch (value & D3DTA_SELECTMASK) { case D3DTA_DIFFUSE: return "DIFFUSE"; case D3DTA_CURRENT: return "CURRENT"; case D3DTA_TEXTURE: return "TEXTURE"; case D3DTA_TFACTOR: return "TFACTOR"; case D3DTA_SPECULAR: return "SPECULAR"; case D3DTA_TEMP: return "TEMP"; case D3DTA_CONSTANT: return "CONSTANT"; default: return "(D3DTA_?)"; } } static const char * nine_D3DTSS_TCI_to_str(DWORD value) { switch (value & 0xf0000) { case D3DTSS_TCI_PASSTHRU: return "PASSTHRU"; case D3DTSS_TCI_CAMERASPACENORMAL: return "CAMERASPACENORMAL"; case D3DTSS_TCI_CAMERASPACEPOSITION: return "CAMERASPACEPOSITION"; case D3DTSS_TCI_CAMERASPACEREFLECTIONVECTOR: return "CAMERASPACEREFLECTIONVECTOR"; case D3DTSS_TCI_SPHEREMAP: return "SPHEREMAP"; default: return "(D3DTSS_TCI_?)"; } } static const char * nine_D3DTTFF_to_str(DWORD value) { switch (value) { case D3DTTFF_DISABLE: return "DISABLE"; case D3DTTFF_COUNT1: return "COUNT1"; case D3DTTFF_COUNT2: return "COUNT2"; case D3DTTFF_COUNT3: return "COUNT3"; case D3DTTFF_COUNT4: return "COUNT4"; case D3DTTFF_PROJECTED: return "PROJECTED"; default: return "(D3DTTFF_?)"; } } void nine_dump_D3DLIGHT9(unsigned ch, const D3DLIGHT9 *lit) { DBG_FLAG(ch, "D3DLIGHT9(%p):\n" "Type: %s\n" "Diffuse: (%f %f %f %f)\n" "Specular: (%f %f %f %f)\n" "Ambient: (%f %f %f %f)\n" "Position: (%f %f %f)\n" "Direction: (%f %f %f)\n" "Range: %f\n" "Falloff: %f\n" "Attenuation: %f + %f * d + %f * d^2\n" "Theta: %f deg\n" "Phi: %f deg\n", lit, nine_D3DLIGHTTYPE_to_str(lit->Type), lit->Diffuse.r,lit->Diffuse.r,lit->Diffuse.g,lit->Diffuse.a, lit->Specular.r,lit->Specular.r,lit->Specular.g,lit->Specular.a, lit->Ambient.r,lit->Ambient.r,lit->Ambient.g,lit->Ambient.a, lit->Position.x,lit->Position.y,lit->Position.z, lit->Direction.x,lit->Direction.y,lit->Direction.z, lit->Range,lit->Falloff, lit->Attenuation0,lit->Attenuation1,lit->Attenuation2, lit->Theta * 360.0f / M_PI,lit->Phi * 360.0f / M_PI); } void nine_dump_D3DMATERIAL9(unsigned ch, const D3DMATERIAL9 *mat) { DBG_FLAG(ch, "D3DMATERIAL9(%p):\n" "Diffuse: (%f %f %f %f)\n" "Specular: (%f %f %f %f)\n" "Ambient: (%f %f %f %f)\n" "Emissive: (%f %f %f %f)\n" "Power: %f\n", mat, mat->Diffuse.r,mat->Diffuse.r,mat->Diffuse.g,mat->Diffuse.a, mat->Specular.r,mat->Specular.r,mat->Specular.g,mat->Specular.a, mat->Ambient.r,mat->Ambient.r,mat->Ambient.g,mat->Ambient.a, mat->Emissive.r,mat->Emissive.r,mat->Emissive.g,mat->Emissive.a, mat->Power); } void nine_dump_D3DTSS_value(unsigned ch, D3DTEXTURESTAGESTATETYPE type, DWORD value) { float rgba[4]; switch (type) { case D3DTSS_COLOROP: case D3DTSS_ALPHAOP: DBG_FLAG(ch, "D3DTSS_%s = %s\n", nine_D3DTSS_to_str(type), nine_D3DTOP_to_str(value)); break; case D3DTSS_COLORARG0: case D3DTSS_COLORARG1: case D3DTSS_COLORARG2: case D3DTSS_ALPHAARG0: case D3DTSS_ALPHAARG1: case D3DTSS_ALPHAARG2: case D3DTSS_RESULTARG: DBG_FLAG(ch, "D3DTSS_%s = %s%s%s\n", nine_D3DTSS_to_str(type), (value & D3DTA_COMPLEMENT) ? "COMPLEMENT " : "", (value & D3DTA_ALPHAREPLICATE) ? "ALPHAREPLICATE " : "", nine_D3DTA_to_str(value)); break; case D3DTSS_BUMPENVMAT00: case D3DTSS_BUMPENVMAT01: case D3DTSS_BUMPENVMAT10: case D3DTSS_BUMPENVMAT11: case D3DTSS_BUMPENVLSCALE: case D3DTSS_BUMPENVLOFFSET: DBG_FLAG(ch, "D3DTSS_%s = %f\n", nine_D3DTSS_to_str(type), asfloat(value)); break; case D3DTSS_TEXCOORDINDEX: DBG_FLAG(ch, "D3DTSS_TEXCOORDINDEX = %s %u\n", nine_D3DTSS_TCI_to_str(value), value & 0xffff); break; case D3DTSS_TEXTURETRANSFORMFLAGS: DBG_FLAG(ch, "D3DTSS_TEXTURETRANSFORMFLAGS = %s\n", nine_D3DTTFF_to_str(value)); break; case D3DTSS_CONSTANT: d3dcolor_to_rgba(rgba, value); DBG_FLAG(ch, "D3DTSS_CONSTANT = %f %f %f %F\n", rgba[0],rgba[1],rgba[2],rgba[3]); break; default: DBG_FLAG(ch, "D3DTSS_? = 0x%08x\n", value); break; } } void nine_dump_D3DADAPTER_IDENTIFIER9(unsigned ch, const D3DADAPTER_IDENTIFIER9 *id) { DBG_FLAG(ch, "D3DADAPTER_IDENTIFIER9(%p):\n" "Driver: %s\n" "Description: %s\n" "DeviceName: %s\n" "DriverVersion: %08x.%08x\n" "VendorId: %x\n" "DeviceId: %x\n" "SubSysId: %x\n" "Revision: %u\n" "GUID: %08x.%04x.%04x.%02x.%02x.%02x.%02x.%02x.%02x.%02x.%02x\n" "WHQLLevel: %u\n", id, id->Driver, id->Description, id->DeviceName, id->DriverVersionLowPart, id->DriverVersionHighPart, id->VendorId, id->DeviceId, id->SubSysId, id->Revision, id->DeviceIdentifier.Data1, id->DeviceIdentifier.Data2, id->DeviceIdentifier.Data3, id->DeviceIdentifier.Data4[0], id->DeviceIdentifier.Data4[1], id->DeviceIdentifier.Data4[2], id->DeviceIdentifier.Data4[3], id->DeviceIdentifier.Data4[4], id->DeviceIdentifier.Data4[5], id->DeviceIdentifier.Data4[6], id->DeviceIdentifier.Data4[7], id->WHQLLevel); } #define C2S(args...) p += snprintf(&s[p],c-p,args) #define CAP_CASE(m,p,n) \ do { \ if (caps->m & p##_##n) \ C2S(" "#n); \ else \ C2S(" ("#n")"); \ } while(0) void nine_dump_D3DCAPS9(unsigned ch, const D3DCAPS9 *caps) { const int c = 1 << 17; int p = 0; char *s = (char *)MALLOC(c); if (!s) { DBG_FLAG(ch, "D3DCAPS9(%p): (out of memory)\n", caps); return; } C2S("DeviceType: %s\n", nine_D3DDEVTYPE_to_str(caps->DeviceType)); C2S("AdapterOrdinal: %u\nCaps:", caps->AdapterOrdinal); if (caps->Caps & 0x20000) C2S(" READ_SCANLINE"); if (caps->Caps & ~0x20000) C2S(" %x", caps->Caps & ~0x20000); C2S("\nCaps2:"); CAP_CASE(Caps2, D3DCAPS2, CANAUTOGENMIPMAP); CAP_CASE(Caps2, D3DCAPS2, CANCALIBRATEGAMMA); CAP_CASE(Caps2, D3DCAPS2, CANSHARERESOURCE); CAP_CASE(Caps2, D3DCAPS2, CANMANAGERESOURCE); CAP_CASE(Caps2, D3DCAPS2, DYNAMICTEXTURES); CAP_CASE(Caps2, D3DCAPS2, FULLSCREENGAMMA); C2S("\nCaps3:"); CAP_CASE(Caps3, D3DCAPS3, ALPHA_FULLSCREEN_FLIP_OR_DISCARD); CAP_CASE(Caps3, D3DCAPS3, COPY_TO_VIDMEM); CAP_CASE(Caps3, D3DCAPS3, COPY_TO_SYSTEMMEM); CAP_CASE(Caps3, D3DCAPS3, DXVAHD); CAP_CASE(Caps3, D3DCAPS3, LINEAR_TO_SRGB_PRESENTATION); C2S("\nPresentationIntervals:"); CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, ONE); CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, TWO); CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, THREE); CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, FOUR); CAP_CASE(PresentationIntervals, D3DPRESENT_INTERVAL, IMMEDIATE); C2S("\nCursorCaps:"); CAP_CASE(CursorCaps, D3DCURSORCAPS, COLOR); CAP_CASE(CursorCaps, D3DCURSORCAPS, LOWRES); C2S("\nDevCaps:"); CAP_CASE(DevCaps, D3DDEVCAPS, CANBLTSYSTONONLOCAL); CAP_CASE(DevCaps, D3DDEVCAPS, CANRENDERAFTERFLIP); CAP_CASE(DevCaps, D3DDEVCAPS, DRAWPRIMITIVES2); CAP_CASE(DevCaps, D3DDEVCAPS, DRAWPRIMITIVES2EX); CAP_CASE(DevCaps, D3DDEVCAPS, DRAWPRIMTLVERTEX); CAP_CASE(DevCaps, D3DDEVCAPS, EXECUTESYSTEMMEMORY); CAP_CASE(DevCaps, D3DDEVCAPS, EXECUTEVIDEOMEMORY); CAP_CASE(DevCaps, D3DDEVCAPS, HWRASTERIZATION); CAP_CASE(DevCaps, D3DDEVCAPS, HWTRANSFORMANDLIGHT); CAP_CASE(DevCaps, D3DDEVCAPS, NPATCHES); CAP_CASE(DevCaps, D3DDEVCAPS, PUREDEVICE); CAP_CASE(DevCaps, D3DDEVCAPS, QUINTICRTPATCHES); CAP_CASE(DevCaps, D3DDEVCAPS, RTPATCHES); CAP_CASE(DevCaps, D3DDEVCAPS, RTPATCHHANDLEZERO); CAP_CASE(DevCaps, D3DDEVCAPS, SEPARATETEXTUREMEMORIES); CAP_CASE(DevCaps, D3DDEVCAPS, TEXTURENONLOCALVIDMEM); CAP_CASE(DevCaps, D3DDEVCAPS, TEXTURESYSTEMMEMORY); CAP_CASE(DevCaps, D3DDEVCAPS, TEXTUREVIDEOMEMORY); CAP_CASE(DevCaps, D3DDEVCAPS, TLVERTEXSYSTEMMEMORY); CAP_CASE(DevCaps, D3DDEVCAPS, TLVERTEXVIDEOMEMORY); C2S("\nPrimitiveMiscCaps:"); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, MASKZ); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CULLNONE); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CULLCW); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CULLCCW); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, COLORWRITEENABLE); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CLIPPLANESCALEDPOINTS); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, CLIPTLVERTS); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, TSSARGTEMP); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, BLENDOP); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, NULLREFERENCE); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, INDEPENDENTWRITEMASKS); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, PERSTAGECONSTANT); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, POSTBLENDSRGBCONVERT); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, FOGANDSPECULARALPHA); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, SEPARATEALPHABLEND); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, MRTINDEPENDENTBITDEPTHS); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, MRTPOSTPIXELSHADERBLENDING); CAP_CASE(PrimitiveMiscCaps, D3DPMISCCAPS, FOGVERTEXCLAMPED); C2S("\nRasterCaps:"); CAP_CASE(RasterCaps, D3DPRASTERCAPS, ANISOTROPY); CAP_CASE(RasterCaps, D3DPRASTERCAPS, COLORPERSPECTIVE); CAP_CASE(RasterCaps, D3DPRASTERCAPS, DITHER); CAP_CASE(RasterCaps, D3DPRASTERCAPS, DEPTHBIAS); CAP_CASE(RasterCaps, D3DPRASTERCAPS, FOGRANGE); CAP_CASE(RasterCaps, D3DPRASTERCAPS, FOGTABLE); CAP_CASE(RasterCaps, D3DPRASTERCAPS, FOGVERTEX); CAP_CASE(RasterCaps, D3DPRASTERCAPS, MIPMAPLODBIAS); CAP_CASE(RasterCaps, D3DPRASTERCAPS, MULTISAMPLE_TOGGLE); CAP_CASE(RasterCaps, D3DPRASTERCAPS, SCISSORTEST); CAP_CASE(RasterCaps, D3DPRASTERCAPS, SLOPESCALEDEPTHBIAS); CAP_CASE(RasterCaps, D3DPRASTERCAPS, WBUFFER); CAP_CASE(RasterCaps, D3DPRASTERCAPS, WFOG); CAP_CASE(RasterCaps, D3DPRASTERCAPS, ZBUFFERLESSHSR); CAP_CASE(RasterCaps, D3DPRASTERCAPS, ZFOG); CAP_CASE(RasterCaps, D3DPRASTERCAPS, ZTEST); C2S("\nZCmpCaps:"); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, ALWAYS); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, EQUAL); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, GREATER); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, GREATEREQUAL); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, LESS); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, LESSEQUAL); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, NEVER); CAP_CASE(ZCmpCaps, D3DPCMPCAPS, NOTEQUAL); C2S("\nSrcBlendCaps"); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, BLENDFACTOR); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, BOTHINVSRCALPHA); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, BOTHSRCALPHA); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, DESTALPHA); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, DESTCOLOR); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVDESTALPHA); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVDESTCOLOR); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVSRCALPHA); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR2); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, ONE); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCALPHA); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCALPHASAT); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCCOLOR); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, SRCCOLOR2); CAP_CASE(SrcBlendCaps, D3DPBLENDCAPS, ZERO); C2S("\nDestBlendCaps"); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, BLENDFACTOR); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, BOTHINVSRCALPHA); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, BOTHSRCALPHA); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, DESTALPHA); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, DESTCOLOR); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVDESTALPHA); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVDESTCOLOR); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVSRCALPHA); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, INVSRCCOLOR2); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, ONE); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCALPHA); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCALPHASAT); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCCOLOR); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, SRCCOLOR2); CAP_CASE(DestBlendCaps, D3DPBLENDCAPS, ZERO); C2S("\nAlphaCmpCaps:"); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, ALWAYS); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, EQUAL); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, GREATER); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, GREATEREQUAL); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, LESS); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, LESSEQUAL); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, NEVER); CAP_CASE(AlphaCmpCaps, D3DPCMPCAPS, NOTEQUAL); C2S("\nShadeCaps:"); CAP_CASE(ShadeCaps, D3DPSHADECAPS, ALPHAGOURAUDBLEND); CAP_CASE(ShadeCaps, D3DPSHADECAPS, COLORGOURAUDRGB); CAP_CASE(ShadeCaps, D3DPSHADECAPS, FOGGOURAUD); CAP_CASE(ShadeCaps, D3DPSHADECAPS, SPECULARGOURAUDRGB); C2S("\nTextureCaps:"); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, ALPHA); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, ALPHAPALETTE); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, CUBEMAP); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, CUBEMAP_POW2); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, MIPCUBEMAP); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, MIPMAP); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, MIPVOLUMEMAP); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, NONPOW2CONDITIONAL); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, NOPROJECTEDBUMPENV); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, PERSPECTIVE); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, POW2); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, PROJECTED); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, SQUAREONLY); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, TEXREPEATNOTSCALEDBYSIZE); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, VOLUMEMAP); CAP_CASE(TextureCaps, D3DPTEXTURECAPS, VOLUMEMAP_POW2); C2S("\nTextureFilterCaps:"); /* CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */ CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT); CAP_CASE(TextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR); C2S("\nCubeTextureFilterCaps:"); /* CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */ CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT); CAP_CASE(CubeTextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR); C2S("\nVolumeTextureFilterCaps:"); /* CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */ CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT); CAP_CASE(VolumeTextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR); C2S("\nTextureAddressCaps:"); CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, BORDER); CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, CLAMP); CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, INDEPENDENTUV); CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, MIRROR); CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, MIRRORONCE); CAP_CASE(TextureAddressCaps, D3DPTADDRESSCAPS, WRAP); C2S("\nVolumeTextureAddressCaps:"); CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, BORDER); CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, CLAMP); CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, INDEPENDENTUV); CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, MIRROR); CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, MIRRORONCE); CAP_CASE(VolumeTextureAddressCaps, D3DPTADDRESSCAPS, WRAP); C2S("\nLineCaps:"); CAP_CASE(LineCaps, D3DLINECAPS, ALPHACMP); CAP_CASE(LineCaps, D3DLINECAPS, ANTIALIAS); CAP_CASE(LineCaps, D3DLINECAPS, BLEND); CAP_CASE(LineCaps, D3DLINECAPS, FOG); CAP_CASE(LineCaps, D3DLINECAPS, TEXTURE); CAP_CASE(LineCaps, D3DLINECAPS, ZTEST); C2S("\nMaxTextureWidth: %u", caps->MaxTextureWidth); C2S("\nMaxTextureHeight: %u", caps->MaxTextureHeight); C2S("\nMaxVolumeExtent: %u", caps->MaxVolumeExtent); C2S("\nMaxTextureRepeat: %u", caps->MaxTextureRepeat); C2S("\nMaxTextureAspectRatio: %u", caps->MaxTextureAspectRatio); C2S("\nMaxAnisotropy: %u", caps->MaxAnisotropy); C2S("\nMaxVertexW: %f", caps->MaxVertexW); C2S("\nGuardBandLef,Top,Right,Bottom: %f %f %f %f", caps->GuardBandLeft, caps->GuardBandTop, caps->GuardBandRight, caps->GuardBandBottom); C2S("\nExtentsAdjust: %f", caps->ExtentsAdjust); C2S("\nStencilCaps:"); CAP_CASE(StencilCaps, D3DSTENCILCAPS, KEEP); CAP_CASE(StencilCaps, D3DSTENCILCAPS, ZERO); CAP_CASE(StencilCaps, D3DSTENCILCAPS, REPLACE); CAP_CASE(StencilCaps, D3DSTENCILCAPS, INCRSAT); CAP_CASE(StencilCaps, D3DSTENCILCAPS, DECRSAT); CAP_CASE(StencilCaps, D3DSTENCILCAPS, INVERT); CAP_CASE(StencilCaps, D3DSTENCILCAPS, INCR); CAP_CASE(StencilCaps, D3DSTENCILCAPS, DECR); CAP_CASE(StencilCaps, D3DSTENCILCAPS, TWOSIDED); C2S("\nFVFCaps:"); CAP_CASE(FVFCaps, D3DFVFCAPS, DONOTSTRIPELEMENTS); CAP_CASE(FVFCaps, D3DFVFCAPS, PSIZE); CAP_CASE(FVFCaps, D3DFVFCAPS, TEXCOORDCOUNTMASK); C2S("\nTextureOpCaps:"); CAP_CASE(TextureOpCaps, D3DTEXOPCAPS, ADD); CAP_CASE(TextureOpCaps, D3DTEXOPCAPS, ADDSIGNED); C2S(" ..."); C2S("\nMaxTextureBlendStages: %u", caps->MaxTextureBlendStages); C2S("\nMaxSimultaneousTextures: %u", caps->MaxTextureBlendStages); C2S("\nVertexProcessingCaps:"); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, DIRECTIONALLIGHTS); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, LOCALVIEWER); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, MATERIALSOURCE7); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, NO_TEXGEN_NONLOCALVIEWER); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, POSITIONALLIGHTS); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, TEXGEN); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, TEXGEN_SPHEREMAP); CAP_CASE(VertexProcessingCaps, D3DVTXPCAPS, TWEENING); C2S("\nMaxActiveLights: %u", caps->MaxActiveLights); C2S("\nMaxUserClipPlanes: %u", caps->MaxUserClipPlanes); C2S("\nMaxVertexBlendMatrices: %u", caps->MaxVertexBlendMatrices); C2S("\nMaxVertexBlendMatrixIndex: %u", caps->MaxVertexBlendMatrixIndex); C2S("\nMaxPointSize: %f", caps->MaxPointSize); C2S("\nMaxPrimitiveCount: 0x%x", caps->MaxPrimitiveCount); C2S("\nMaxVertexIndex: 0x%x", caps->MaxVertexIndex); C2S("\nMaxStreams: %u", caps->MaxStreams); C2S("\nMaxStreamStride: 0x%x", caps->MaxStreamStride); C2S("\nVertexShaderVersion: %08x", caps->VertexShaderVersion); C2S("\nMaxVertexShaderConst: %u", caps->MaxVertexShaderConst); C2S("\nPixelShaderVersion: %08x", caps->PixelShaderVersion); C2S("\nPixelShader1xMaxValue: %f", caps->PixelShader1xMaxValue); DBG_FLAG(ch, "D3DCAPS9(%p) part 1:\n%s\n", caps, s); p = 0; C2S("DevCaps2:"); CAP_CASE(DevCaps2, D3DDEVCAPS2, ADAPTIVETESSRTPATCH); CAP_CASE(DevCaps2, D3DDEVCAPS2, ADAPTIVETESSNPATCH); CAP_CASE(DevCaps2, D3DDEVCAPS2, CAN_STRETCHRECT_FROM_TEXTURES); CAP_CASE(DevCaps2, D3DDEVCAPS2, DMAPNPATCH); CAP_CASE(DevCaps2, D3DDEVCAPS2, PRESAMPLEDDMAPNPATCH); CAP_CASE(DevCaps2, D3DDEVCAPS2, STREAMOFFSET); CAP_CASE(DevCaps2, D3DDEVCAPS2, VERTEXELEMENTSCANSHARESTREAMOFFSET); C2S("\nMasterAdapterOrdinal: %u", caps->MasterAdapterOrdinal); C2S("\nAdapterOrdinalInGroup: %u", caps->AdapterOrdinalInGroup); C2S("\nNumberOfAdaptersInGroup: %u", caps->NumberOfAdaptersInGroup); C2S("\nDeclTypes:"); CAP_CASE(DeclTypes, D3DDTCAPS, UBYTE4); CAP_CASE(DeclTypes, D3DDTCAPS, UBYTE4N); CAP_CASE(DeclTypes, D3DDTCAPS, SHORT2N); CAP_CASE(DeclTypes, D3DDTCAPS, SHORT4N); CAP_CASE(DeclTypes, D3DDTCAPS, USHORT2N); CAP_CASE(DeclTypes, D3DDTCAPS, USHORT4N); CAP_CASE(DeclTypes, D3DDTCAPS, UDEC3); CAP_CASE(DeclTypes, D3DDTCAPS, DEC3N); CAP_CASE(DeclTypes, D3DDTCAPS, FLOAT16_2); CAP_CASE(DeclTypes, D3DDTCAPS, FLOAT16_4); C2S("\nNumSimultaneousRTs: %u", caps->NumSimultaneousRTs); C2S("\nStretchRectFilterCaps:"); CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MINFPOINT); CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MINFLINEAR); CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MAGFPOINT); CAP_CASE(StretchRectFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR); C2S("\nVS20Caps.Caps: Predication=%s", caps->VS20Caps.Caps ? "yes" : "no"); C2S("\nVS20Caps.DynamicFlowControlDepth: %u", caps->VS20Caps.DynamicFlowControlDepth); C2S("\nVS20Caps.NumTemps: %u", caps->VS20Caps.NumTemps); C2S("\nVS20Caps.StaticFlowControlDepth: %u", caps->VS20Caps.StaticFlowControlDepth); C2S("\nPS20Caps.Caps: Predication=%s", caps->VS20Caps.Caps ? "yes" : "no"); C2S("\nPS20Caps.DynamicFlowControlDepth: %u", caps->PS20Caps.DynamicFlowControlDepth); C2S("\nPS20Caps.NumTemps: %u", caps->PS20Caps.NumTemps); C2S("\nPS20Caps.StaticFlowControlDepth: %u", caps->PS20Caps.StaticFlowControlDepth); C2S("\nPS20Caps.NumInstructionSlots: %u", caps->PS20Caps.NumInstructionSlots); C2S("\nVertexTextureFilterCaps"); /* CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, CONVOLUTIONMONO); */ CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFPOINT); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFLINEAR); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFANISOTROPIC); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFPYRAMIDALQUAD); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MAGFGAUSSIANQUAD); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFPOINT); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFLINEAR); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFANISOTROPIC); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFPYRAMIDALQUAD); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MINFGAUSSIANQUAD); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MIPFPOINT); CAP_CASE(VertexTextureFilterCaps, D3DPTFILTERCAPS, MIPFLINEAR); C2S("\nMaxVShaderInstructionsExecuted: %u", caps->MaxVShaderInstructionsExecuted); C2S("\nMaxPShaderInstructionsExecuted: %u", caps->MaxPShaderInstructionsExecuted); C2S("\nMaxVertexShader30InstructionSlots: %u >= 512", caps->MaxVertexShader30InstructionSlots); C2S("\nMaxPixelShader30InstructionSlots: %u >= 512", caps->MaxPixelShader30InstructionSlots); DBG_FLAG(ch, "D3DCAPS9(%p) part 2:\n%s\n", caps, s); FREE(s); } #endif /* DEBUG */