HRESULT WINAPI
NineAdapter9_CreateDeviceEx( struct NineAdapter9 *This,
UINT RealAdapter,
D3DDEVTYPE DeviceType,
HWND hFocusWindow,
DWORD BehaviorFlags,
D3DPRESENT_PARAMETERS *pPresentationParameters,
D3DDISPLAYMODEEX *pFullscreenDisplayMode,
IDirect3D9Ex *pD3D9Ex,
ID3DPresentGroup *pPresentationGroup,
IDirect3DDevice9Ex **ppReturnedDeviceInterface )
{
struct pipe_screen *screen;
D3DDEVICE_CREATION_PARAMETERS params;
D3DCAPS9 caps;
int major, minor;
HRESULT hr;
DBG("This=%p RealAdapter=%u DeviceType=%s hFocusWindow=%p "
"BehaviourFlags=%x " "pD3D9Ex=%p pPresentationGroup=%p "
"ppReturnedDeviceInterface=%p\n", This,
RealAdapter, nine_D3DDEVTYPE_to_str(DeviceType), hFocusWindow,
BehaviorFlags, pD3D9Ex, pPresentationGroup, ppReturnedDeviceInterface);
ID3DPresentGroup_GetVersion(pPresentationGroup, &major, &minor);
if (major != 1) {
ERR("Doesn't support the ID3DPresentGroup version %d %d. Expected 1\n",
major, minor);
return D3DERR_NOTAVAILABLE;
}
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr)) {
DBG("Failed to get pipe_screen.\n");
return hr;
}
hr = NineAdapter9_GetDeviceCaps(This, DeviceType, &caps);
if (FAILED(hr)) {
DBG("Failed to get device caps.\n");
return hr;
}
params.AdapterOrdinal = RealAdapter;
params.DeviceType = DeviceType;
params.hFocusWindow = hFocusWindow;
params.BehaviorFlags = BehaviorFlags;
hr = NineDevice9Ex_new(screen, ¶ms, &caps, pPresentationParameters,
pFullscreenDisplayMode,
pD3D9Ex, pPresentationGroup, This->ctx,
(struct NineDevice9Ex **)ppReturnedDeviceInterface);
if (FAILED(hr)) {
DBG("Failed to create device.\n");
return hr;
}
DBG("NineDevice9Ex created successfully.\n");
return D3D_OK;
}
HRESULT NINE_WINAPI
NineAdapter9_CheckDepthStencilMatch( struct NineAdapter9 *This,
D3DDEVTYPE DeviceType,
D3DFORMAT AdapterFormat,
D3DFORMAT RenderTargetFormat,
D3DFORMAT DepthStencilFormat )
{
struct pipe_screen *screen;
enum pipe_format dfmt, bfmt, zsfmt;
HRESULT hr;
DBG("This=%p DeviceType=%s AdapterFormat=%s "
"RenderTargetFormat=%s DepthStencilFormat=%s\n", This,
nine_D3DDEVTYPE_to_str(DeviceType), d3dformat_to_string(AdapterFormat),
d3dformat_to_string(RenderTargetFormat),
d3dformat_to_string(DepthStencilFormat));
user_assert(display_format(AdapterFormat, FALSE), D3DERR_NOTAVAILABLE);
user_assert(depth_stencil_format(DepthStencilFormat), D3DERR_NOTAVAILABLE);
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr)) { return hr; }
dfmt = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D, 0,
PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SHARED, FALSE, FALSE);
bfmt = d3d9_to_pipe_format_checked(screen, RenderTargetFormat,
PIPE_TEXTURE_2D, 0,
PIPE_BIND_RENDER_TARGET, FALSE, FALSE);
if (RenderTargetFormat == D3DFMT_NULL)
bfmt = dfmt;
zsfmt = d3d9_to_pipe_format_checked(screen, DepthStencilFormat,
PIPE_TEXTURE_2D, 0,
d3d9_get_pipe_depth_format_bindings(DepthStencilFormat),
FALSE, FALSE);
if (dfmt == PIPE_FORMAT_NONE ||
bfmt == PIPE_FORMAT_NONE ||
zsfmt == PIPE_FORMAT_NONE) {
return D3DERR_NOTAVAILABLE;
}
return D3D_OK;
}
HRESULT WINAPI
NineAdapter9_CheckDeviceMultiSampleType( struct NineAdapter9 *This,
D3DDEVTYPE DeviceType,
D3DFORMAT SurfaceFormat,
BOOL Windowed,
D3DMULTISAMPLE_TYPE MultiSampleType,
DWORD *pQualityLevels )
{
struct pipe_screen *screen;
HRESULT hr;
enum pipe_format pf;
unsigned bind;
DBG("This=%p DeviceType=%s SurfaceFormat=%s Windowed=%i MultiSampleType=%u "
"pQualityLevels=%p\n", This, nine_D3DDEVTYPE_to_str(DeviceType),
d3dformat_to_string(SurfaceFormat), Windowed, MultiSampleType,
pQualityLevels);
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr))
return hr;
if (depth_stencil_format(SurfaceFormat))
bind = d3d9_get_pipe_depth_format_bindings(SurfaceFormat);
else /* render-target */
bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_TRANSFER_READ |
PIPE_BIND_TRANSFER_WRITE | PIPE_BIND_RENDER_TARGET;
pf = d3d9_to_pipe_format_checked(screen, SurfaceFormat, PIPE_TEXTURE_2D,
MultiSampleType, bind, FALSE);
if (pf == PIPE_FORMAT_NONE) {
DBG("%s with %u samples not available.\n",
d3dformat_to_string(SurfaceFormat), MultiSampleType);
return D3DERR_NOTAVAILABLE;
}
if (pQualityLevels)
*pQualityLevels = 1; /* gallium doesn't have quality levels */
return D3D_OK;
}
HRESULT NINE_WINAPI
NineAdapter9_CheckDeviceType( struct NineAdapter9 *This,
D3DDEVTYPE DevType,
D3DFORMAT AdapterFormat,
D3DFORMAT BackBufferFormat,
BOOL bWindowed )
{
struct pipe_screen *screen;
enum pipe_format dfmt, bfmt;
HRESULT hr;
DBG("This=%p DevType=%s AdapterFormat=%s BackBufferFormat=%s "
"bWindowed=%i\n", This, nine_D3DDEVTYPE_to_str(DevType),
d3dformat_to_string(AdapterFormat),
d3dformat_to_string(BackBufferFormat), bWindowed);
user_assert(backbuffer_format(AdapterFormat, BackBufferFormat, bWindowed),
D3DERR_NOTAVAILABLE);
hr = NineAdapter9_GetScreen(This, DevType, &screen);
if (FAILED(hr)) { return hr; }
/* The display format is not handled in Nine. We always present an XRGB8888
* buffer (and the display server will eventually do the conversion). We probably
* don't need to check for anything for the adapter format support, since if the
* display server advertise support, it will likely be able to do the conversion.
* We do the approximation that a format is available in the display server if
* the format passes with NINE_BIND_BACKBUFFER_FLAGS */
dfmt = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D,
1,
NINE_BIND_BACKBUFFER_FLAGS, FALSE, FALSE);
bfmt = d3d9_to_pipe_format_checked(screen, BackBufferFormat, PIPE_TEXTURE_2D,
1,
NINE_BIND_BACKBUFFER_FLAGS, FALSE, FALSE);
if (dfmt == PIPE_FORMAT_NONE || bfmt == PIPE_FORMAT_NONE) {
DBG("Unsupported Adapter/BackBufferFormat.\n");
return D3DERR_NOTAVAILABLE;
}
return D3D_OK;
}
HRESULT NINE_WINAPI
NineAdapter9_CheckDeviceFormatConversion( struct NineAdapter9 *This,
D3DDEVTYPE DeviceType,
D3DFORMAT SourceFormat,
D3DFORMAT TargetFormat )
{
/* MSDN says this tests whether a certain backbuffer format can be used in
* conjunction with a certain front buffer format. It's a little confusing
* but some one wiser might be able to figure this one out. XXX */
struct pipe_screen *screen;
enum pipe_format dfmt, bfmt;
HRESULT hr;
DBG("This=%p DeviceType=%s SourceFormat=%s TargetFormat=%s\n", This,
nine_D3DDEVTYPE_to_str(DeviceType),
d3dformat_to_string(SourceFormat), d3dformat_to_string(TargetFormat));
user_assert(backbuffer_format(TargetFormat, SourceFormat, FALSE),
D3DERR_NOTAVAILABLE);
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr)) { return hr; }
dfmt = d3d9_to_pipe_format_checked(screen, TargetFormat, PIPE_TEXTURE_2D, 1,
PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SHARED, FALSE, FALSE);
bfmt = d3d9_to_pipe_format_checked(screen, SourceFormat, PIPE_TEXTURE_2D, 1,
PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SHARED, FALSE, FALSE);
if (dfmt == PIPE_FORMAT_NONE || bfmt == PIPE_FORMAT_NONE) {
DBG("%s to %s not supported.\n",
d3dformat_to_string(SourceFormat),
d3dformat_to_string(TargetFormat));
return D3DERR_NOTAVAILABLE;
}
return D3D_OK;
}
HRESULT NINE_WINAPI
NineAdapter9_CheckDeviceType( struct NineAdapter9 *This,
D3DDEVTYPE DevType,
D3DFORMAT AdapterFormat,
D3DFORMAT BackBufferFormat,
BOOL bWindowed )
{
struct pipe_screen *screen;
enum pipe_format dfmt, bfmt;
HRESULT hr;
DBG("This=%p DevType=%s AdapterFormat=%s BackBufferFormat=%s "
"bWindowed=%i\n", This, nine_D3DDEVTYPE_to_str(DevType),
d3dformat_to_string(AdapterFormat),
d3dformat_to_string(BackBufferFormat), bWindowed);
user_assert(backbuffer_format(AdapterFormat, BackBufferFormat, bWindowed),
D3DERR_NOTAVAILABLE);
hr = NineAdapter9_GetScreen(This, DevType, &screen);
if (FAILED(hr)) { return hr; }
dfmt = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D,
1,
PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SHARED, FALSE, FALSE);
bfmt = d3d9_to_pipe_format_checked(screen, BackBufferFormat, PIPE_TEXTURE_2D,
1,
PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SHARED, FALSE, FALSE);
if (dfmt == PIPE_FORMAT_NONE || bfmt == PIPE_FORMAT_NONE) {
DBG("Unsupported Adapter/BackBufferFormat.\n");
return D3DERR_NOTAVAILABLE;
}
return D3D_OK;
}
HRESULT NINE_WINAPI
NineAdapter9_GetDeviceCaps( struct NineAdapter9 *This,
D3DDEVTYPE DeviceType,
D3DCAPS9 *pCaps )
{
struct pipe_screen *screen;
HRESULT hr;
DBG("This=%p DeviceType=%s pCaps=%p\n", This,
nine_D3DDEVTYPE_to_str(DeviceType), pCaps);
user_assert(pCaps, D3DERR_INVALIDCALL);
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr)) {
DBG("Failed to get pipe_screen.\n");
return hr;
}
#define D3DPIPECAP(pcap, d3dcap) \
(screen->get_param(screen, PIPE_CAP_##pcap) ? (d3dcap) : 0)
#define D3DNPIPECAP(pcap, d3dcap) \
(screen->get_param(screen, PIPE_CAP_##pcap) ? 0 : (d3dcap))
pCaps->DeviceType = DeviceType;
pCaps->AdapterOrdinal = 0;
pCaps->Caps = D3DCAPS_READ_SCANLINE;
pCaps->Caps2 = /* D3DCAPS2_CANMANAGERESOURCE | */
/* D3DCAPS2_CANSHARERESOURCE | */
/* D3DCAPS2_CANCALIBRATEGAMMA | */
D3DCAPS2_DYNAMICTEXTURES |
D3DCAPS2_FULLSCREENGAMMA |
D3DCAPS2_CANAUTOGENMIPMAP;
/* Note: D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD just means the
* backbuffer can be ARGB (instead of only XRGB) when we are fullscreen
* and in discard mode. */
pCaps->Caps3 = D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
D3DCAPS3_COPY_TO_VIDMEM |
D3DCAPS3_COPY_TO_SYSTEMMEM |
D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION;
pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_DEFAULT |
D3DPRESENT_INTERVAL_ONE |
D3DPRESENT_INTERVAL_TWO |
D3DPRESENT_INTERVAL_THREE |
D3DPRESENT_INTERVAL_FOUR |
D3DPRESENT_INTERVAL_IMMEDIATE;
pCaps->CursorCaps = D3DCURSORCAPS_COLOR /* | D3DCURSORCAPS_LOWRES*/;
pCaps->DevCaps = D3DDEVCAPS_CANBLTSYSTONONLOCAL |
D3DDEVCAPS_CANRENDERAFTERFLIP |
D3DDEVCAPS_DRAWPRIMITIVES2 |
D3DDEVCAPS_DRAWPRIMITIVES2EX |
D3DDEVCAPS_DRAWPRIMTLVERTEX |
D3DDEVCAPS_EXECUTESYSTEMMEMORY |
D3DDEVCAPS_EXECUTEVIDEOMEMORY |
D3DDEVCAPS_HWRASTERIZATION |
D3DDEVCAPS_HWTRANSFORMANDLIGHT |
/*D3DDEVCAPS_NPATCHES |*/
D3DDEVCAPS_PUREDEVICE |
/*D3DDEVCAPS_QUINTICRTPATCHES |*/
/*D3DDEVCAPS_RTPATCHES |*/
/*D3DDEVCAPS_RTPATCHHANDLEZERO |*/
/*D3DDEVCAPS_SEPARATETEXTUREMEMORIES |*/
D3DDEVCAPS_TEXTURENONLOCALVIDMEM |
/* D3DDEVCAPS_TEXTURESYSTEMMEMORY |*/
D3DDEVCAPS_TEXTUREVIDEOMEMORY |
D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
D3DDEVCAPS_TLVERTEXVIDEOMEMORY;
pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_MASKZ |
D3DPMISCCAPS_CULLNONE | /* XXX */
D3DPMISCCAPS_CULLCW |
D3DPMISCCAPS_CULLCCW |
D3DPMISCCAPS_COLORWRITEENABLE |
D3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
/*D3DPMISCCAPS_CLIPTLVERTS |*/
D3DPMISCCAPS_TSSARGTEMP |
D3DPMISCCAPS_BLENDOP |
D3DPIPECAP(INDEP_BLEND_ENABLE, D3DPMISCCAPS_INDEPENDENTWRITEMASKS) |
D3DPMISCCAPS_PERSTAGECONSTANT |
/*D3DPMISCCAPS_POSTBLENDSRGBCONVERT |*/ /* TODO: advertise if Ex and dx10 able card */
D3DPMISCCAPS_FOGANDSPECULARALPHA | /* Note: documentation of the flag is wrong */
D3DPIPECAP(BLEND_EQUATION_SEPARATE, D3DPMISCCAPS_SEPARATEALPHABLEND) |
D3DPIPECAP(MIXED_COLORBUFFER_FORMATS, D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS) |
D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING |
D3DPMISCCAPS_FOGVERTEXCLAMPED;
if (!screen->get_param(screen, PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION))
pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_CLIPTLVERTS;
pCaps->RasterCaps =
D3DPIPECAP(ANISOTROPIC_FILTER, D3DPRASTERCAPS_ANISOTROPY) |
D3DPRASTERCAPS_COLORPERSPECTIVE |
D3DPRASTERCAPS_DITHER |
D3DPRASTERCAPS_DEPTHBIAS |
D3DPRASTERCAPS_FOGRANGE |
D3DPRASTERCAPS_FOGTABLE |
D3DPRASTERCAPS_FOGVERTEX |
D3DPRASTERCAPS_MIPMAPLODBIAS |
D3DPRASTERCAPS_MULTISAMPLE_TOGGLE |
D3DPRASTERCAPS_SCISSORTEST |
D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
/*D3DPRASTERCAPS_WBUFFER |*/
D3DPRASTERCAPS_WFOG |
/*D3DPRASTERCAPS_ZBUFFERLESSHSR |*/
D3DPRASTERCAPS_ZFOG |
D3DPRASTERCAPS_ZTEST;
pCaps->ZCmpCaps = D3DPCMPCAPS_NEVER |
D3DPCMPCAPS_LESS |
D3DPCMPCAPS_EQUAL |
D3DPCMPCAPS_LESSEQUAL |
D3DPCMPCAPS_GREATER |
D3DPCMPCAPS_NOTEQUAL |
D3DPCMPCAPS_GREATEREQUAL |
D3DPCMPCAPS_ALWAYS;
pCaps->SrcBlendCaps = D3DPBLENDCAPS_ZERO |
D3DPBLENDCAPS_ONE |
D3DPBLENDCAPS_SRCCOLOR |
D3DPBLENDCAPS_INVSRCCOLOR |
D3DPBLENDCAPS_SRCALPHA |
D3DPBLENDCAPS_INVSRCALPHA |
D3DPBLENDCAPS_DESTALPHA |
D3DPBLENDCAPS_INVDESTALPHA |
D3DPBLENDCAPS_DESTCOLOR |
D3DPBLENDCAPS_INVDESTCOLOR |
D3DPBLENDCAPS_SRCALPHASAT |
D3DPBLENDCAPS_BOTHSRCALPHA |
D3DPBLENDCAPS_BOTHINVSRCALPHA |
D3DPBLENDCAPS_BLENDFACTOR |
D3DPIPECAP(MAX_DUAL_SOURCE_RENDER_TARGETS,
D3DPBLENDCAPS_INVSRCCOLOR2 |
D3DPBLENDCAPS_SRCCOLOR2);
pCaps->DestBlendCaps = pCaps->SrcBlendCaps;
pCaps->AlphaCmpCaps = D3DPCMPCAPS_NEVER |
D3DPCMPCAPS_LESS |
D3DPCMPCAPS_EQUAL |
D3DPCMPCAPS_LESSEQUAL |
D3DPCMPCAPS_GREATER |
D3DPCMPCAPS_NOTEQUAL |
D3DPCMPCAPS_GREATEREQUAL |
D3DPCMPCAPS_ALWAYS;
/* FLAT caps not legal for D3D9. */
pCaps->ShadeCaps = D3DPSHADECAPS_COLORGOURAUDRGB |
D3DPSHADECAPS_SPECULARGOURAUDRGB |
D3DPSHADECAPS_ALPHAGOURAUDBLEND |
D3DPSHADECAPS_FOGGOURAUD;
pCaps->TextureCaps =
D3DPTEXTURECAPS_ALPHA |
D3DPTEXTURECAPS_ALPHAPALETTE |
D3DPTEXTURECAPS_PERSPECTIVE |
D3DPTEXTURECAPS_PROJECTED |
D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE |
D3DPTEXTURECAPS_CUBEMAP |
D3DPTEXTURECAPS_VOLUMEMAP |
D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_POW2) |
D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_NONPOW2CONDITIONAL) |
D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_CUBEMAP_POW2) |
D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_VOLUMEMAP_POW2) |
D3DPIPECAP(MAX_TEXTURE_2D_SIZE, D3DPTEXTURECAPS_MIPMAP) |
D3DPIPECAP(MAX_TEXTURE_3D_LEVELS, D3DPTEXTURECAPS_MIPVOLUMEMAP) |
D3DPIPECAP(MAX_TEXTURE_CUBE_LEVELS, D3DPTEXTURECAPS_MIPCUBEMAP);
pCaps->TextureFilterCaps =
D3DPTFILTERCAPS_MINFPOINT |
D3DPTFILTERCAPS_MINFLINEAR |
D3DPIPECAP(ANISOTROPIC_FILTER, D3DPTFILTERCAPS_MINFANISOTROPIC) |
/*D3DPTFILTERCAPS_MINFPYRAMIDALQUAD |*/
/*D3DPTFILTERCAPS_MINFGAUSSIANQUAD |*/
D3DPTFILTERCAPS_MIPFPOINT |
D3DPTFILTERCAPS_MIPFLINEAR |
D3DPTFILTERCAPS_MAGFPOINT |
D3DPTFILTERCAPS_MAGFLINEAR |
D3DPIPECAP(ANISOTROPIC_FILTER, D3DPTFILTERCAPS_MAGFANISOTROPIC) |
/*D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD |*/
/*D3DPTFILTERCAPS_MAGFGAUSSIANQUAD*/0;
pCaps->CubeTextureFilterCaps = pCaps->TextureFilterCaps;
pCaps->VolumeTextureFilterCaps = pCaps->TextureFilterCaps;
pCaps->TextureAddressCaps =
D3DPTADDRESSCAPS_BORDER |
D3DPTADDRESSCAPS_INDEPENDENTUV |
D3DPTADDRESSCAPS_WRAP |
D3DPTADDRESSCAPS_MIRROR |
D3DPTADDRESSCAPS_CLAMP |
D3DPIPECAP(TEXTURE_MIRROR_CLAMP, D3DPTADDRESSCAPS_MIRRORONCE);
pCaps->VolumeTextureAddressCaps = pCaps->TextureAddressCaps;
pCaps->LineCaps =
D3DLINECAPS_ALPHACMP |
D3DLINECAPS_BLEND |
D3DLINECAPS_TEXTURE |
D3DLINECAPS_ZTEST |
D3DLINECAPS_FOG;
if (screen->get_paramf(screen, PIPE_CAPF_MAX_LINE_WIDTH_AA) > 0.0) {
pCaps->LineCaps |= D3DLINECAPS_ANTIALIAS;
}
pCaps->MaxTextureWidth =screen->get_param(screen,
PIPE_CAP_MAX_TEXTURE_2D_SIZE);
pCaps->MaxTextureHeight = pCaps->MaxTextureWidth;
pCaps->MaxVolumeExtent =
1 << (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS) - 1);
/* XXX values from wine */
pCaps->MaxTextureRepeat = 32768;
pCaps->MaxTextureAspectRatio = pCaps->MaxTextureWidth;
pCaps->MaxAnisotropy =
(DWORD)screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_ANISOTROPY);
/* Values for GeForce 9600 GT */
pCaps->MaxVertexW = 1e10f;
pCaps->GuardBandLeft = -1e9f;
pCaps->GuardBandTop = -1e9f;
pCaps->GuardBandRight = 1e9f;
pCaps->GuardBandBottom = 1e9f;
pCaps->ExtentsAdjust = 0.0f;
pCaps->StencilCaps =
D3DSTENCILCAPS_KEEP |
D3DSTENCILCAPS_ZERO |
D3DSTENCILCAPS_REPLACE |
D3DSTENCILCAPS_INCRSAT |
D3DSTENCILCAPS_DECRSAT |
D3DSTENCILCAPS_INVERT |
D3DSTENCILCAPS_INCR |
D3DSTENCILCAPS_DECR |
D3DSTENCILCAPS_TWOSIDED;
pCaps->FVFCaps =
8 | /* 8 textures max */
/*D3DFVFCAPS_DONOTSTRIPELEMENTS |*/
D3DFVFCAPS_PSIZE;
pCaps->TextureOpCaps = D3DTEXOPCAPS_DISABLE |
D3DTEXOPCAPS_SELECTARG1 |
D3DTEXOPCAPS_SELECTARG2 |
D3DTEXOPCAPS_MODULATE |
D3DTEXOPCAPS_MODULATE2X |
D3DTEXOPCAPS_MODULATE4X |
D3DTEXOPCAPS_ADD |
D3DTEXOPCAPS_ADDSIGNED |
D3DTEXOPCAPS_ADDSIGNED2X |
D3DTEXOPCAPS_SUBTRACT |
D3DTEXOPCAPS_ADDSMOOTH |
D3DTEXOPCAPS_BLENDDIFFUSEALPHA |
D3DTEXOPCAPS_BLENDTEXTUREALPHA |
D3DTEXOPCAPS_BLENDFACTORALPHA |
D3DTEXOPCAPS_BLENDTEXTUREALPHAPM |
D3DTEXOPCAPS_BLENDCURRENTALPHA |
D3DTEXOPCAPS_PREMODULATE |
D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
D3DTEXOPCAPS_BUMPENVMAP |
D3DTEXOPCAPS_BUMPENVMAPLUMINANCE |
D3DTEXOPCAPS_DOTPRODUCT3 |
D3DTEXOPCAPS_MULTIPLYADD |
D3DTEXOPCAPS_LERP;
pCaps->MaxTextureBlendStages = 8; /* XXX wine */
(DWORD)screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_SEPARATE);
pCaps->MaxSimultaneousTextures = 8;
pCaps->VertexProcessingCaps = D3DVTXPCAPS_TEXGEN |
D3DVTXPCAPS_TEXGEN_SPHEREMAP |
D3DVTXPCAPS_MATERIALSOURCE7 |
D3DVTXPCAPS_DIRECTIONALLIGHTS |
D3DVTXPCAPS_POSITIONALLIGHTS |
D3DVTXPCAPS_LOCALVIEWER |
D3DVTXPCAPS_TWEENING |
/*D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER*/0;
pCaps->MaxActiveLights = NINE_MAX_LIGHTS_ACTIVE; /* like GL_LIGHTi */
pCaps->MaxUserClipPlanes = PIPE_MAX_CLIP_PLANES;
pCaps->MaxVertexBlendMatrices = 4; /* 1 vec4 BLENDWEIGHT/INDICES input */
pCaps->MaxVertexBlendMatrixIndex = 8; /* D3DTS_WORLDMATRIX(0..8) */
pCaps->MaxPointSize = screen->get_paramf(screen, PIPE_CAPF_MAX_POINT_WIDTH);
pCaps->MaxPrimitiveCount = 0x555555; /* <- wine, really 0xFFFFFFFF; */
pCaps->MaxVertexIndex = 0xFFFFFF; /* <- wine, really 0xFFFFFFFF */
pCaps->MaxStreams =
_min(screen->get_shader_param(screen,
PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_INPUTS),
16);
pCaps->MaxStreamStride = screen->get_param(screen,
PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE);
pCaps->VertexShaderVersion = D3DVS_VERSION(3,0);
/* VS 2 as well as 3.0 supports a minimum of 256 consts.
* Wine and d3d9 drivers for dx1x hw advertise 256. Just as them,
* advertise 256. Problem is with hw that can only do 256, because
* we need take a few slots for boolean and integer constants. For these
* we'll have to fail later if they use complex shaders. */
pCaps->MaxVertexShaderConst = NINE_MAX_CONST_F;
pCaps->PixelShaderVersion = D3DPS_VERSION(3,0);
/* Value for GeForce 9600 GT */
pCaps->PixelShader1xMaxValue = 65504.f;
pCaps->DevCaps2 = D3DDEVCAPS2_STREAMOFFSET |
D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET |
D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES |
/*D3DDEVCAPS2_DMAPNPATCH |*/
/*D3DDEVCAPS2_ADAPTIVETESSRTPATCH |*/
/*D3DDEVCAPS2_ADAPTIVETESSNPATCH |*/
/*D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH*/0;
pCaps->MasterAdapterOrdinal = 0;
pCaps->AdapterOrdinalInGroup = 0;
pCaps->NumberOfAdaptersInGroup = 1;
/* Undocumented ? */
pCaps->MaxNpatchTessellationLevel = 0.0f;
pCaps->Reserved5 = 0;
/* XXX: use is_format_supported */
pCaps->DeclTypes = D3DDTCAPS_UBYTE4 |
D3DDTCAPS_UBYTE4N |
D3DDTCAPS_SHORT2N |
D3DDTCAPS_SHORT4N |
D3DDTCAPS_USHORT2N |
D3DDTCAPS_USHORT4N |
D3DDTCAPS_UDEC3 |
D3DDTCAPS_DEC3N |
D3DDTCAPS_FLOAT16_2 |
D3DDTCAPS_FLOAT16_4;
pCaps->NumSimultaneousRTs =
screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS);
if (pCaps->NumSimultaneousRTs > NINE_MAX_SIMULTANEOUS_RENDERTARGETS)
pCaps->NumSimultaneousRTs = NINE_MAX_SIMULTANEOUS_RENDERTARGETS;
pCaps->StretchRectFilterCaps = D3DPTFILTERCAPS_MINFPOINT |
D3DPTFILTERCAPS_MINFLINEAR |
D3DPTFILTERCAPS_MAGFPOINT |
D3DPTFILTERCAPS_MAGFLINEAR;
pCaps->VS20Caps.Caps = D3DVS20CAPS_PREDICATION;
pCaps->VS20Caps.DynamicFlowControlDepth = /* XXX is this dynamic ? */
screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
pCaps->VS20Caps.NumTemps =
screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
PIPE_SHADER_CAP_MAX_TEMPS);
pCaps->VS20Caps.StaticFlowControlDepth = /* XXX is this static ? */
screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
/* also check for values < 0, because get_shader_param may return unsigned */
if (pCaps->VS20Caps.DynamicFlowControlDepth > D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH
|| pCaps->VS20Caps.DynamicFlowControlDepth < 0)
pCaps->VS20Caps.DynamicFlowControlDepth = D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH;
if (pCaps->VS20Caps.StaticFlowControlDepth > D3DVS20_MAX_STATICFLOWCONTROLDEPTH
|| pCaps->VS20Caps.StaticFlowControlDepth < 0)
pCaps->VS20Caps.StaticFlowControlDepth = D3DVS20_MAX_STATICFLOWCONTROLDEPTH;
if (pCaps->VS20Caps.NumTemps > D3DVS20_MAX_NUMTEMPS)
pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
assert(pCaps->VS20Caps.DynamicFlowControlDepth >= D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH);
assert(pCaps->VS20Caps.StaticFlowControlDepth >= D3DVS20_MIN_STATICFLOWCONTROLDEPTH);
assert(pCaps->VS20Caps.NumTemps >= D3DVS20_MIN_NUMTEMPS);
pCaps->PS20Caps.Caps = D3DPS20CAPS_ARBITRARYSWIZZLE |
D3DPS20CAPS_GRADIENTINSTRUCTIONS |
D3DPS20CAPS_PREDICATION;
if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS) ==
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_INSTRUCTIONS))
pCaps->PS20Caps.Caps |= D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS) ==
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS))
pCaps->PS20Caps.Caps |= D3DPS20CAPS_NODEPENDENTREADLIMIT;
pCaps->PS20Caps.DynamicFlowControlDepth = /* XXX is this dynamic ? */
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
pCaps->PS20Caps.NumTemps =
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_TEMPS);
pCaps->PS20Caps.StaticFlowControlDepth = /* XXX is this static ? */
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
pCaps->PS20Caps.NumInstructionSlots =
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
if (pCaps->PS20Caps.DynamicFlowControlDepth > D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH
|| pCaps->PS20Caps.DynamicFlowControlDepth < 0)
pCaps->PS20Caps.DynamicFlowControlDepth = D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH;
if (pCaps->PS20Caps.StaticFlowControlDepth > D3DPS20_MAX_STATICFLOWCONTROLDEPTH
|| pCaps->PS20Caps.StaticFlowControlDepth < 0)
pCaps->PS20Caps.StaticFlowControlDepth = D3DPS20_MAX_STATICFLOWCONTROLDEPTH;
if (pCaps->PS20Caps.NumTemps > D3DPS20_MAX_NUMTEMPS)
pCaps->PS20Caps.NumTemps = D3DPS20_MAX_NUMTEMPS;
if (pCaps->PS20Caps.NumInstructionSlots > D3DPS20_MAX_NUMINSTRUCTIONSLOTS)
pCaps->PS20Caps.NumInstructionSlots = D3DPS20_MAX_NUMINSTRUCTIONSLOTS;
assert(pCaps->PS20Caps.DynamicFlowControlDepth >= D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH);
assert(pCaps->PS20Caps.StaticFlowControlDepth >= D3DPS20_MIN_STATICFLOWCONTROLDEPTH);
assert(pCaps->PS20Caps.NumTemps >= D3DPS20_MIN_NUMTEMPS);
assert(pCaps->PS20Caps.NumInstructionSlots >= D3DPS20_MIN_NUMINSTRUCTIONSLOTS);
if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS))
pCaps->VertexTextureFilterCaps = pCaps->TextureFilterCaps &
~(D3DPTFILTERCAPS_MIPFPOINT |
D3DPTFILTERCAPS_MIPFPOINT); /* XXX */
else
pCaps->VertexTextureFilterCaps = 0;
pCaps->MaxVertexShader30InstructionSlots =
screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
pCaps->MaxPixelShader30InstructionSlots =
screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
if (pCaps->MaxVertexShader30InstructionSlots > D3DMAX30SHADERINSTRUCTIONS)
pCaps->MaxVertexShader30InstructionSlots = D3DMAX30SHADERINSTRUCTIONS;
if (pCaps->MaxPixelShader30InstructionSlots > D3DMAX30SHADERINSTRUCTIONS)
pCaps->MaxPixelShader30InstructionSlots = D3DMAX30SHADERINSTRUCTIONS;
assert(pCaps->MaxVertexShader30InstructionSlots >= D3DMIN30SHADERINSTRUCTIONS);
assert(pCaps->MaxPixelShader30InstructionSlots >= D3DMIN30SHADERINSTRUCTIONS);
/* 65535 is required, advertise more for GPUs with >= 2048 instruction slots */
pCaps->MaxVShaderInstructionsExecuted = MAX2(65535, pCaps->MaxVertexShader30InstructionSlots * 32);
pCaps->MaxPShaderInstructionsExecuted = MAX2(65535, pCaps->MaxPixelShader30InstructionSlots * 32);
if (debug_get_bool_option("NINE_DUMP_CAPS", FALSE))
nine_dump_D3DCAPS9(DBG_CHANNEL, pCaps);
return D3D_OK;
}
HRESULT NINE_WINAPI
NineAdapter9_CheckDeviceMultiSampleType( struct NineAdapter9 *This,
D3DDEVTYPE DeviceType,
D3DFORMAT SurfaceFormat,
BOOL Windowed,
D3DMULTISAMPLE_TYPE MultiSampleType,
DWORD *pQualityLevels )
{
struct pipe_screen *screen;
HRESULT hr;
enum pipe_format pf;
unsigned bind;
DBG("This=%p DeviceType=%s SurfaceFormat=%s Windowed=%i MultiSampleType=%u "
"pQualityLevels=%p\n", This, nine_D3DDEVTYPE_to_str(DeviceType),
d3dformat_to_string(SurfaceFormat), Windowed, MultiSampleType,
pQualityLevels);
if (pQualityLevels) {
/* In error cases return only 1 quality level supported */
*pQualityLevels = 1;
}
user_assert(MultiSampleType <= D3DMULTISAMPLE_16_SAMPLES, D3DERR_INVALIDCALL);
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr))
return hr;
if (depth_stencil_format(SurfaceFormat))
bind = d3d9_get_pipe_depth_format_bindings(SurfaceFormat);
else /* render-target */
bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
pf = d3d9_to_pipe_format_checked(screen, SurfaceFormat, PIPE_TEXTURE_2D,
0, PIPE_BIND_SAMPLER_VIEW, FALSE, FALSE);
if (pf == PIPE_FORMAT_NONE && SurfaceFormat != D3DFMT_NULL) {
DBG("%s not available.\n", d3dformat_to_string(SurfaceFormat));
return D3DERR_INVALIDCALL;
}
pf = d3d9_to_pipe_format_checked(screen, SurfaceFormat, PIPE_TEXTURE_2D,
MultiSampleType, bind, FALSE, FALSE);
if (pf == PIPE_FORMAT_NONE && SurfaceFormat != D3DFMT_NULL) {
DBG("%s with %u samples not available.\n",
d3dformat_to_string(SurfaceFormat), MultiSampleType);
return D3DERR_NOTAVAILABLE;
}
if (pQualityLevels) {
/* NONMASKABLE MultiSampleType might have more than one quality level,
* while MASKABLE MultiSampleTypes have only one level.
* Advertise quality levels and map each level to a sample count. */
(void ) d3dmultisample_type_check(screen, SurfaceFormat,
&MultiSampleType, D3DMULTISAMPLE_16_SAMPLES, pQualityLevels);
DBG("advertising %u quality levels\n", *pQualityLevels);
}
return D3D_OK;
}
HRESULT NINE_WINAPI
NineAdapter9_CheckDeviceFormat( struct NineAdapter9 *This,
D3DDEVTYPE DeviceType,
D3DFORMAT AdapterFormat,
DWORD Usage,
D3DRESOURCETYPE RType,
D3DFORMAT CheckFormat )
{
struct pipe_screen *screen;
HRESULT hr;
enum pipe_format pf;
enum pipe_texture_target target;
unsigned bind = 0;
boolean srgb;
/* Check adapter format. */
DBG("This=%p DeviceType=%s AdapterFormat=%s\n", This,
nine_D3DDEVTYPE_to_str(DeviceType), d3dformat_to_string(AdapterFormat));
DBG("Usage=%x RType=%u CheckFormat=%s\n", Usage, RType,
d3dformat_to_string(CheckFormat));
user_assert(display_format(AdapterFormat, FALSE), D3DERR_INVALIDCALL);
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr))
return hr;
pf = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D, 0,
PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SHARED, FALSE, FALSE);
if (pf == PIPE_FORMAT_NONE) {
DBG("AdapterFormat %s not available.\n",
d3dformat_to_string(AdapterFormat));
return D3DERR_NOTAVAILABLE;
}
/* Check actual format. */
switch (RType) {
case D3DRTYPE_SURFACE: target = PIPE_TEXTURE_2D; break;
case D3DRTYPE_TEXTURE: target = PIPE_TEXTURE_2D; break;
case D3DRTYPE_CUBETEXTURE: target = PIPE_TEXTURE_CUBE; break;
case D3DRTYPE_VOLUME: target = PIPE_TEXTURE_3D; break;
case D3DRTYPE_VOLUMETEXTURE: target = PIPE_TEXTURE_3D; break;
case D3DRTYPE_VERTEXBUFFER: target = PIPE_BUFFER; break;
case D3DRTYPE_INDEXBUFFER: target = PIPE_BUFFER; break;
default:
user_assert(0, D3DERR_INVALIDCALL);
}
bind = 0;
if (Usage & D3DUSAGE_RENDERTARGET) bind |= PIPE_BIND_RENDER_TARGET;
if (Usage & D3DUSAGE_DEPTHSTENCIL) {
if (!depth_stencil_format(CheckFormat))
return D3DERR_NOTAVAILABLE;
bind |= d3d9_get_pipe_depth_format_bindings(CheckFormat);
}
/* API hack because setting RT[0] to NULL is forbidden */
if (CheckFormat == D3DFMT_NULL && bind == PIPE_BIND_RENDER_TARGET &&
(RType == D3DRTYPE_SURFACE ||
RType == D3DRTYPE_TEXTURE))
return D3D_OK;
/* RESZ hack */
if (CheckFormat == D3DFMT_RESZ && bind == PIPE_BIND_RENDER_TARGET &&
RType == D3DRTYPE_SURFACE)
return screen->get_param(screen, PIPE_CAP_MULTISAMPLE_Z_RESOLVE) ?
D3D_OK : D3DERR_NOTAVAILABLE;
/* ATOC hack */
if (CheckFormat == D3DFMT_ATOC && RType == D3DRTYPE_SURFACE)
return D3D_OK;
if ((Usage & D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) &&
(Usage & D3DUSAGE_RENDERTARGET))
bind |= PIPE_BIND_BLENDABLE;
if (Usage & D3DUSAGE_DMAP) {
DBG("D3DUSAGE_DMAP not available\n");
return D3DERR_NOTAVAILABLE; /* TODO: displacement mapping */
}
switch (RType) {
case D3DRTYPE_TEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
case D3DRTYPE_CUBETEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
case D3DRTYPE_VOLUMETEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
case D3DRTYPE_VERTEXBUFFER: bind |= PIPE_BIND_VERTEX_BUFFER; break;
case D3DRTYPE_INDEXBUFFER: bind |= PIPE_BIND_INDEX_BUFFER; break;
case D3DRTYPE_SURFACE:
if (!(Usage & D3DUSAGE_DEPTHSTENCIL))
bind |= PIPE_BIND_SAMPLER_VIEW; /* StretchRect */
/* Offscreen surface support: Usage = 0.
* In practice drivers are very restrictive on the formats supported.
* Basically a few common formats + YUV and compressed formats. The
* reason is that offscreen surface are useful only for directdraw
* compatibility (a WONTIMPL of nine) + format conversion (useful in
* particular for YUV because the format was not advertised for textures
* on NV chips). */
if (Usage == 0)
bind |= PIPE_BIND_RENDER_TARGET; /* A current requirement of our impl, which we should get rid of. */
default:
break;
}
srgb = (Usage & (D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE)) != 0;
pf = d3d9_to_pipe_format_checked(screen, CheckFormat, target,
0, bind, srgb, FALSE);
if (pf == PIPE_FORMAT_NONE) {
DBG("NOT AVAILABLE\n");
return D3DERR_NOTAVAILABLE;
}
/* we support ATI1 and ATI2 hack only for 2D and Cube textures */
if (RType != D3DRTYPE_TEXTURE && RType != D3DRTYPE_CUBETEXTURE &&
(CheckFormat == D3DFMT_ATI1 || CheckFormat == D3DFMT_ATI2))
return D3DERR_NOTAVAILABLE;
/* if (Usage & D3DUSAGE_NONSECURE) { don't know the implications of this } */
/* if (Usage & D3DUSAGE_SOFTWAREPROCESSING) { we can always support this } */
if ((Usage & D3DUSAGE_AUTOGENMIPMAP) && !(bind & PIPE_BIND_SAMPLER_VIEW))
return D3DOK_NOAUTOGEN;
return D3D_OK;
}
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);
}
HRESULT WINAPI
NineAdapter9_CheckDeviceFormat( struct NineAdapter9 *This,
D3DDEVTYPE DeviceType,
D3DFORMAT AdapterFormat,
DWORD Usage,
D3DRESOURCETYPE RType,
D3DFORMAT CheckFormat )
{
struct pipe_screen *screen;
HRESULT hr;
enum pipe_format pf;
enum pipe_texture_target target;
unsigned bind = 0;
boolean srgb;
/* Check adapter format. */
DBG("This=%p DeviceType=%s AdapterFormat=%s\n", This,
nine_D3DDEVTYPE_to_str(DeviceType), d3dformat_to_string(AdapterFormat));
DBG("Usage=%x RType=%u CheckFormat=%s\n", Usage, RType,
d3dformat_to_string(CheckFormat));
user_assert(display_format(AdapterFormat, FALSE), D3DERR_INVALIDCALL);
hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
if (FAILED(hr))
return hr;
pf = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D, 0,
PIPE_BIND_DISPLAY_TARGET |
PIPE_BIND_SHARED, FALSE);
if (pf == PIPE_FORMAT_NONE) {
DBG("AdapterFormat %s not available.\n",
d3dformat_to_string(AdapterFormat));
return D3DERR_NOTAVAILABLE;
}
/* Check actual format. */
switch (RType) {
case D3DRTYPE_SURFACE: target = PIPE_TEXTURE_2D; break;
case D3DRTYPE_TEXTURE: target = PIPE_TEXTURE_2D; break;
case D3DRTYPE_CUBETEXTURE: target = PIPE_TEXTURE_CUBE; break;
case D3DRTYPE_VOLUME: target = PIPE_TEXTURE_3D; break;
case D3DRTYPE_VOLUMETEXTURE: target = PIPE_TEXTURE_3D; break;
case D3DRTYPE_VERTEXBUFFER: target = PIPE_BUFFER; break;
case D3DRTYPE_INDEXBUFFER: target = PIPE_BUFFER; break;
default:
user_assert(0, D3DERR_INVALIDCALL);
}
bind = 0;
if (Usage & D3DUSAGE_RENDERTARGET) bind |= PIPE_BIND_RENDER_TARGET;
if (Usage & D3DUSAGE_DEPTHSTENCIL) bind |= PIPE_BIND_DEPTH_STENCIL;
/* API hack because setting RT[0] to NULL is forbidden */
if (CheckFormat == D3DFMT_NULL && bind == PIPE_BIND_RENDER_TARGET &&
(RType == D3DRTYPE_SURFACE ||
RType == D3DRTYPE_TEXTURE))
return D3D_OK;
/* RESZ hack */
if (CheckFormat == D3DFMT_RESZ && bind == PIPE_BIND_RENDER_TARGET &&
RType == D3DRTYPE_SURFACE)
return screen->get_param(screen, PIPE_CAP_MULTISAMPLE_Z_RESOLVE) ?
D3D_OK : D3DERR_NOTAVAILABLE;
/* ATOC hack */
if (CheckFormat == D3DFMT_ATOC && RType == D3DRTYPE_SURFACE)
return D3D_OK;
if ((Usage & D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) &&
(Usage & D3DUSAGE_RENDERTARGET))
bind |= PIPE_BIND_BLENDABLE;
if (Usage & D3DUSAGE_DMAP) {
DBG("D3DUSAGE_DMAP not available\n");
return D3DERR_NOTAVAILABLE; /* TODO: displacement mapping */
}
switch (RType) {
case D3DRTYPE_TEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
case D3DRTYPE_CUBETEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
case D3DRTYPE_VOLUMETEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
case D3DRTYPE_VERTEXBUFFER: bind |= PIPE_BIND_VERTEX_BUFFER; break;
case D3DRTYPE_INDEXBUFFER: bind |= PIPE_BIND_INDEX_BUFFER; break;
default:
break;
}
srgb = (Usage & (D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE)) != 0;
pf = d3d9_to_pipe_format_checked(screen, CheckFormat, target, 0, bind, srgb);
if (pf == PIPE_FORMAT_NONE) {
DBG("NOT AVAILABLE\n");
return D3DERR_NOTAVAILABLE;
}
/* we support ATI1 and ATI2 hack only for 2D textures */
if (RType != D3DRTYPE_TEXTURE && (CheckFormat == D3DFMT_ATI1 || CheckFormat == D3DFMT_ATI2))
return D3DERR_NOTAVAILABLE;
/* if (Usage & D3DUSAGE_NONSECURE) { don't know the implications of this } */
/* if (Usage & D3DUSAGE_SOFTWAREPROCESSING) { we can always support this } */
if ((Usage & D3DUSAGE_AUTOGENMIPMAP) && !(bind & PIPE_BIND_SAMPLER_VIEW))
return D3DOK_NOAUTOGEN;
return D3D_OK;
}
