/* * Copyright 2011 Joakim Sindholt * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the "Software"), * to deal in the Software without restriction, including without limitation * on the rights to use, copy, modify, merge, publish, distribute, sub * license, and/or sell copies of the Software, and to permit persons to whom * the Software is furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice (including the next * paragraph) shall be included in all copies or substantial portions of the * Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM, * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE * USE OR OTHER DEALINGS IN THE SOFTWARE. */ #include "adapter9.h" #include "device9ex.h" #include "nine_helpers.h" #include "nine_defines.h" #include "nine_pipe.h" #include "nine_dump.h" #include "util/u_math.h" #include "util/format/u_format.h" #include "util/u_dump.h" #include "pipe/p_screen.h" #define DBG_CHANNEL DBG_ADAPTER static bool has_sm3(struct pipe_screen *hal) { return hal->get_param(hal, PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD) && hal->get_param(hal, PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES) && hal->get_param(hal, PIPE_CAP_VERTEX_SHADER_SATURATE); } HRESULT NineAdapter9_ctor( struct NineAdapter9 *This, struct NineUnknownParams *pParams, struct d3dadapter9_context *pCTX ) { struct pipe_screen *hal = pCTX->hal; HRESULT hr = NineUnknown_ctor(&This->base, pParams); if (FAILED(hr)) { return hr; } DBG("This=%p pParams=%p pCTX=%p\n", This, pParams, pCTX); nine_dump_D3DADAPTER_IDENTIFIER9(DBG_CHANNEL, &pCTX->identifier); This->ctx = pCTX; if (!hal->get_param(hal, PIPE_CAP_CLIP_HALFZ)) { ERR("Driver doesn't support d3d9 coordinates\n"); return D3DERR_DRIVERINTERNALERROR; } if (This->ctx->ref && !This->ctx->ref->get_param(This->ctx->ref, PIPE_CAP_CLIP_HALFZ)) { ERR("Warning: Sotware rendering driver doesn't support d3d9 coordinates\n"); } /* Old cards had tricks to bypass some restrictions to implement * everything and fit tight the requirements: number of constants, * number of temp registers, special behaviours, etc. Since we don't * have access to all this, we need a bit more than what dx9 required. * For example we have to use more than 32 temp registers to emulate * behaviours, while some dx9 hw don't have more. As for sm2 hardware, * we could support vs2 / ps2 for them but it needs some more care, and * as these are very old, we choose to drop support for them */ /* checks minimum requirements, most are vs3/ps3 strict requirements */ if (!has_sm3(hal) || hal->get_shader_param(hal, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) < 256 * sizeof(float[4]) || hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) < 244 * sizeof(float[4]) || hal->get_shader_param(hal, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_TEMPS) < 32 || hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_TEMPS) < 32 || hal->get_shader_param(hal, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_INPUTS) < 16 || hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INPUTS) < 10 || hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS) < 16) { ERR("Your card is not supported by Gallium Nine. Minimum requirement " "is >= r500, >= nv50, >= i965\n"); return D3DERR_DRIVERINTERNALERROR; } /* for r500 */ if (hal->get_shader_param(hal, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) < 276 * sizeof(float[4]) || /* we put bool and int constants with float constants */ hal->get_shader_param(hal, PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_TEMPS) < 40 || /* we use some more temp registers */ hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_TEMPS) < 40 || hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_INPUTS) < 20) /* we don't pack inputs as much as we could */ ERR("Your card is at the limit of Gallium Nine requirements. Some games " "may run into issues because requirements are too tight\n"); return D3D_OK; } void NineAdapter9_dtor( struct NineAdapter9 *This ) { struct d3dadapter9_context *ctx = This->ctx; DBG("This=%p\n", This); NineUnknown_dtor(&This->base); /* special case, call backend-specific dtor AFTER destroying this object * completely. */ if (ctx) { if (ctx->destroy) { ctx->destroy(ctx); } } } static HRESULT NineAdapter9_GetScreen( struct NineAdapter9 *This, D3DDEVTYPE DevType, struct pipe_screen **ppScreen ) { const char *force_sw = getenv("D3D_ALWAYS_SOFTWARE"); switch (DevType) { case D3DDEVTYPE_HAL: if (force_sw && !strcmp(force_sw, "1") && This->ctx->ref) { *ppScreen = This->ctx->ref; break; } *ppScreen = This->ctx->hal; break; case D3DDEVTYPE_REF: case D3DDEVTYPE_NULLREF: case D3DDEVTYPE_SW: if (force_sw && !strcmp(force_sw, "0")) { *ppScreen = This->ctx->hal; break; } *ppScreen = This->ctx->ref; break; default: user_assert(!"Invalid device type", D3DERR_INVALIDCALL); } if (!*ppScreen) { return D3DERR_NOTAVAILABLE; } return D3D_OK; } HRESULT NINE_WINAPI NineAdapter9_GetAdapterIdentifier( struct NineAdapter9 *This, DWORD Flags, D3DADAPTER_IDENTIFIER9 *pIdentifier ) { DBG("This=%p Flags=%x pIdentifier=%p\n", This, Flags, pIdentifier); /* regarding flags, MSDN has this to say: * Flags sets the WHQLLevel member of D3DADAPTER_IDENTIFIER9. Flags can be * set to either 0 or D3DENUM_WHQL_LEVEL. If D3DENUM_WHQL_LEVEL is * specified, this call can connect to the Internet to download new * Microsoft Windows Hardware Quality Labs (WHQL) certificates. * so let's just ignore it. */ *pIdentifier = This->ctx->identifier; return D3D_OK; } static inline boolean backbuffer_format( D3DFORMAT dfmt, D3DFORMAT bfmt, boolean win ) { if (dfmt == D3DFMT_A2R10G10B10 && win) { return FALSE; } if ((dfmt == D3DFMT_A2R10G10B10 && bfmt == dfmt) || (dfmt == D3DFMT_X8R8G8B8 && (bfmt == dfmt || bfmt == D3DFMT_A8R8G8B8)) || (dfmt == D3DFMT_X1R5G5B5 && (bfmt == dfmt || bfmt == D3DFMT_A1R5G5B5)) || (dfmt == D3DFMT_R5G6B5 && bfmt == dfmt)) { return TRUE; } return FALSE; } 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; } static inline boolean display_format( D3DFORMAT fmt, boolean win ) { /* http://msdn.microsoft.com/en-us/library/bb172558(v=VS.85).aspx#BackBuffer_or_Display_Formats */ static const D3DFORMAT allowed[] = { D3DFMT_A2R10G10B10, D3DFMT_X8R8G8B8, D3DFMT_X1R5G5B5, D3DFMT_R5G6B5, }; unsigned i; if (fmt == D3DFMT_A2R10G10B10 && win) { return FALSE; } for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) { if (fmt == allowed[i]) { return TRUE; } } return FALSE; } static inline boolean adapter_format( D3DFORMAT fmt ) { /* Formats that are compatible to display_format (modulo alpha bits) */ static const D3DFORMAT allowed[] = { D3DFMT_A2R10G10B10, D3DFMT_X8R8G8B8, D3DFMT_A8R8G8B8, D3DFMT_X1R5G5B5, D3DFMT_A1R5G5B5, D3DFMT_R5G6B5, }; unsigned i; for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) { if (fmt == allowed[i]) { return TRUE; } } return FALSE; } 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)); /* Wine tests, but suspicious. Needs more tests. */ user_assert(adapter_format(AdapterFormat), D3DERR_INVALIDCALL); user_assert(display_format(AdapterFormat, FALSE), D3DERR_NOTAVAILABLE); 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; } 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_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)); /* TODO: does it check AdapterFormat at all ? * It seems to need to pass at least for A8R8G8B8: * https://github.com/iXit/Mesa-3D/issues/317 */ user_assert(adapter_format(AdapterFormat), 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, NINE_BIND_BACKBUFFER_FLAGS, FALSE, FALSE); bfmt = d3d9_to_pipe_format_checked(screen, RenderTargetFormat, PIPE_TEXTURE_2D, 0, NINE_BIND_BACKBUFFER_FLAGS, 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 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, NINE_BIND_BACKBUFFER_FLAGS, FALSE, FALSE); bfmt = d3d9_to_pipe_format_checked(screen, SourceFormat, PIPE_TEXTURE_2D, 1, NINE_BIND_BACKBUFFER_FLAGS, 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_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_CreateDevice( struct NineAdapter9 *This, UINT RealAdapter, D3DDEVTYPE DeviceType, HWND hFocusWindow, DWORD BehaviorFlags, D3DPRESENT_PARAMETERS *pPresentationParameters, IDirect3D9 *pD3D9, ID3DPresentGroup *pPresentationGroup, IDirect3DDevice9 **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 " "pD3D9=%p pPresentationGroup=%p " "ppReturnedDeviceInterface=%p\n", This, RealAdapter, nine_D3DDEVTYPE_to_str(DeviceType), hFocusWindow, BehaviorFlags, pD3D9, 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 = NineDevice9_new(screen, ¶ms, &caps, pPresentationParameters, pD3D9, pPresentationGroup, This->ctx, FALSE, NULL, (struct NineDevice9 **)ppReturnedDeviceInterface, minor); if (FAILED(hr)) { DBG("Failed to create device.\n"); return hr; } DBG("NineDevice9 created successfully.\n"); return D3D_OK; } HRESULT NINE_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, minor); if (FAILED(hr)) { DBG("Failed to create device.\n"); return hr; } DBG("NineDevice9Ex created successfully.\n"); return D3D_OK; } ID3DAdapter9Vtbl NineAdapter9_vtable = { (void *)NineUnknown_QueryInterface, (void *)NineUnknown_AddRef, (void *)NineUnknown_Release, (void *)NineAdapter9_GetAdapterIdentifier, (void *)NineAdapter9_CheckDeviceType, (void *)NineAdapter9_CheckDeviceFormat, (void *)NineAdapter9_CheckDeviceMultiSampleType, (void *)NineAdapter9_CheckDepthStencilMatch, (void *)NineAdapter9_CheckDeviceFormatConversion, (void *)NineAdapter9_GetDeviceCaps, (void *)NineAdapter9_CreateDevice, (void *)NineAdapter9_CreateDeviceEx }; static const GUID *NineAdapter9_IIDs[] = { &IID_ID3D9Adapter, &IID_IUnknown, NULL }; HRESULT NineAdapter9_new( struct d3dadapter9_context *pCTX, struct NineAdapter9 **ppOut ) { NINE_NEW(Adapter9, ppOut, FALSE, /* args */ pCTX); }