Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Copyright 2011 Joakim Sindholt <opensource@zhasha.com>
  3.  *
  4.  * Permission is hereby granted, free of charge, to any person obtaining a
  5.  * copy of this software and associated documentation files (the "Software"),
  6.  * to deal in the Software without restriction, including without limitation
  7.  * on the rights to use, copy, modify, merge, publish, distribute, sub
  8.  * license, and/or sell copies of the Software, and to permit persons to whom
  9.  * the Software is furnished to do so, subject to the following conditions:
  10.  *
  11.  * The above copyright notice and this permission notice (including the next
  12.  * paragraph) shall be included in all copies or substantial portions of the
  13.  * Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18.  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19.  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20.  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21.  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  22.  
  23. #include "adapter9.h"
  24. #include "device9ex.h"
  25. #include "nine_helpers.h"
  26. #include "nine_defines.h"
  27. #include "nine_pipe.h"
  28. #include "nine_dump.h"
  29. #include "util/u_math.h"
  30. #include "util/u_format.h"
  31. #include "util/u_dump.h"
  32.  
  33. #include "pipe/p_screen.h"
  34.  
  35. #define DBG_CHANNEL DBG_ADAPTER
  36.  
  37. HRESULT
  38. NineAdapter9_ctor( struct NineAdapter9 *This,
  39.                    struct NineUnknownParams *pParams,
  40.                    struct d3dadapter9_context *pCTX )
  41. {
  42.     struct pipe_screen *hal = pCTX->hal;
  43.     HRESULT hr = NineUnknown_ctor(&This->base, pParams);
  44.     if (FAILED(hr)) { return hr; }
  45.  
  46.     DBG("This=%p pParams=%p pCTX=%p\n", This, pParams, pCTX);
  47.     nine_dump_D3DADAPTER_IDENTIFIER9(DBG_CHANNEL, &pCTX->identifier);
  48.  
  49.     This->ctx = pCTX;
  50.     if (!hal->get_param(hal, PIPE_CAP_CLIP_HALFZ)) {
  51.         ERR("Driver doesn't support d3d9 coordinates\n");
  52.         return D3DERR_DRIVERINTERNALERROR;
  53.     }
  54.     if (This->ctx->ref &&
  55.         !This->ctx->ref->get_param(This->ctx->ref, PIPE_CAP_CLIP_HALFZ)) {
  56.         ERR("Warning: Sotware rendering driver doesn't support d3d9 coordinates\n");
  57.     }
  58.     /* Old cards had tricks to bypass some restrictions to implement
  59.      * everything and fit tight the requirements: number of constants,
  60.      * number of temp registers, special behaviours, etc. Since we don't
  61.      * have access to all this, we need a bit more than what dx9 required.
  62.      * For example we have to use more than 32 temp registers to emulate
  63.      * behaviours, while some dx9 hw don't have more. As for sm2 hardware,
  64.      * we could support vs2 / ps2 for them but it needs some more care, and
  65.      * as these are very old, we choose to drop support for them */
  66.  
  67.     /* checks minimum requirements, most are vs3/ps3 strict requirements */
  68.     if (!hal->get_param(hal, PIPE_CAP_SM3) ||
  69.         hal->get_shader_param(hal, PIPE_SHADER_VERTEX,
  70.                               PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) < 256 * sizeof(float[4]) ||
  71.         hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT,
  72.                               PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) < 244 * sizeof(float[4]) ||
  73.         hal->get_shader_param(hal, PIPE_SHADER_VERTEX,
  74.                               PIPE_SHADER_CAP_MAX_TEMPS) < 32 ||
  75.         hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT,
  76.                               PIPE_SHADER_CAP_MAX_TEMPS) < 32 ||
  77.         hal->get_shader_param(hal, PIPE_SHADER_VERTEX,
  78.                               PIPE_SHADER_CAP_MAX_INPUTS) < 16 ||
  79.         hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT,
  80.                               PIPE_SHADER_CAP_MAX_INPUTS) < 10) {
  81.         ERR("Your card is not supported by Gallium Nine. Minimum requirement "
  82.             "is >= r500, >= nv50, >= i965\n");
  83.         return D3DERR_DRIVERINTERNALERROR;
  84.     }
  85.     /* for r500 */
  86.     if (hal->get_shader_param(hal, PIPE_SHADER_VERTEX,
  87.                               PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE) < 276 * sizeof(float[4]) || /* we put bool and int constants with float constants */
  88.         hal->get_shader_param(hal, PIPE_SHADER_VERTEX,
  89.                               PIPE_SHADER_CAP_MAX_TEMPS) < 40 || /* we use some more temp registers */
  90.         hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT,
  91.                               PIPE_SHADER_CAP_MAX_TEMPS) < 40 ||
  92.         hal->get_shader_param(hal, PIPE_SHADER_FRAGMENT,
  93.                               PIPE_SHADER_CAP_MAX_INPUTS) < 20) /* we don't pack inputs as much as we could */
  94.         ERR("Your card is at the limit of Gallium Nine requirements. Some games "
  95.             "may run into issues because requirements are too tight\n");
  96.     return D3D_OK;
  97. }
  98.  
  99. void
  100. NineAdapter9_dtor( struct NineAdapter9 *This )
  101. {
  102.     struct d3dadapter9_context *ctx = This->ctx;
  103.  
  104.     DBG("This=%p\n", This);
  105.  
  106.     NineUnknown_dtor(&This->base);
  107.  
  108.     /* special case, call backend-specific dtor AFTER destroying this object
  109.      * completely. */
  110.     if (ctx) {
  111.         if (ctx->destroy) { ctx->destroy(ctx); }
  112.     }
  113. }
  114.  
  115. static HRESULT
  116. NineAdapter9_GetScreen( struct NineAdapter9 *This,
  117.                         D3DDEVTYPE DevType,
  118.                         struct pipe_screen **ppScreen )
  119. {
  120.     const char *force_sw = getenv("D3D_ALWAYS_SOFTWARE");
  121.     switch (DevType) {
  122.         case D3DDEVTYPE_HAL:
  123.             if (force_sw && !strcmp(force_sw, "1") && This->ctx->ref) {
  124.                 *ppScreen = This->ctx->ref;
  125.                 break;
  126.             }
  127.             *ppScreen = This->ctx->hal;
  128.             break;
  129.  
  130.         case D3DDEVTYPE_REF:
  131.         case D3DDEVTYPE_NULLREF:
  132.         case D3DDEVTYPE_SW:
  133.             if (force_sw && !strcmp(force_sw, "0")) {
  134.                 *ppScreen = This->ctx->hal;
  135.                 break;
  136.             }
  137.             *ppScreen = This->ctx->ref;
  138.             break;
  139.  
  140.         default:
  141.             user_assert(!"Invalid device type", D3DERR_INVALIDCALL);
  142.     }
  143.  
  144.     if (!*ppScreen) { return D3DERR_NOTAVAILABLE; }
  145.  
  146.     return D3D_OK;
  147. }
  148.  
  149. HRESULT WINAPI
  150. NineAdapter9_GetAdapterIdentifier( struct NineAdapter9 *This,
  151.                                    DWORD Flags,
  152.                                    D3DADAPTER_IDENTIFIER9 *pIdentifier )
  153. {
  154.     DBG("This=%p Flags=%x pIdentifier=%p\n", This, Flags, pIdentifier);
  155.  
  156.     /* regarding flags, MSDN has this to say:
  157.      *  Flags sets the WHQLLevel member of D3DADAPTER_IDENTIFIER9. Flags can be
  158.      *  set to either 0 or D3DENUM_WHQL_LEVEL. If D3DENUM_WHQL_LEVEL is
  159.      *  specified, this call can connect to the Internet to download new
  160.      *  Microsoft Windows Hardware Quality Labs (WHQL) certificates.
  161.      * so let's just ignore it. */
  162.     *pIdentifier = This->ctx->identifier;
  163.     return D3D_OK;
  164. }
  165.  
  166. static INLINE boolean
  167. backbuffer_format( D3DFORMAT dfmt,
  168.                    D3DFORMAT bfmt,
  169.                    boolean win )
  170. {
  171.     if (dfmt == D3DFMT_A2R10G10B10 && win) { return FALSE; }
  172.  
  173.     if ((dfmt == D3DFMT_A2R10G10B10 && bfmt == dfmt) ||
  174.         (dfmt == D3DFMT_X8R8G8B8 && (bfmt == dfmt ||
  175.                                      bfmt == D3DFMT_A8R8G8B8)) ||
  176.         (dfmt == D3DFMT_X1R5G5B5 && (bfmt == dfmt ||
  177.                                      bfmt == D3DFMT_A1R5G5B5)) ||
  178.         (dfmt == D3DFMT_R5G6B5 && bfmt == dfmt)) {
  179.         return TRUE;
  180.     }
  181.  
  182.     return FALSE;
  183. }
  184.  
  185. HRESULT WINAPI
  186. NineAdapter9_CheckDeviceType( struct NineAdapter9 *This,
  187.                               D3DDEVTYPE DevType,
  188.                               D3DFORMAT AdapterFormat,
  189.                               D3DFORMAT BackBufferFormat,
  190.                               BOOL bWindowed )
  191. {
  192.     struct pipe_screen *screen;
  193.     enum pipe_format dfmt, bfmt;
  194.     HRESULT hr;
  195.  
  196.     DBG("This=%p DevType=%s AdapterFormat=%s BackBufferFormat=%s "
  197.         "bWindowed=%i\n", This, nine_D3DDEVTYPE_to_str(DevType),
  198.         d3dformat_to_string(AdapterFormat),
  199.         d3dformat_to_string(BackBufferFormat), bWindowed);
  200.  
  201.     user_assert(backbuffer_format(AdapterFormat, BackBufferFormat, bWindowed),
  202.                 D3DERR_NOTAVAILABLE);
  203.  
  204.     hr = NineAdapter9_GetScreen(This, DevType, &screen);
  205.     if (FAILED(hr)) { return hr; }
  206.  
  207.     dfmt = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D,
  208.                                        1,
  209.                                        PIPE_BIND_DISPLAY_TARGET |
  210.                                        PIPE_BIND_SHARED, FALSE);
  211.     bfmt = d3d9_to_pipe_format_checked(screen, BackBufferFormat, PIPE_TEXTURE_2D,
  212.                                        1,
  213.                                        PIPE_BIND_DISPLAY_TARGET |
  214.                                        PIPE_BIND_SHARED, FALSE);
  215.     if (dfmt == PIPE_FORMAT_NONE || bfmt == PIPE_FORMAT_NONE) {
  216.         DBG("Unsupported Adapter/BackBufferFormat.\n");
  217.         return D3DERR_NOTAVAILABLE;
  218.     }
  219.  
  220.     return D3D_OK;
  221. }
  222.  
  223. static INLINE boolean
  224. display_format( D3DFORMAT fmt,
  225.                 boolean win )
  226. {
  227.     /* http://msdn.microsoft.com/en-us/library/bb172558(v=VS.85).aspx#BackBuffer_or_Display_Formats */
  228.     static const D3DFORMAT allowed[] = {
  229.         D3DFMT_A2R10G10B10,
  230.         D3DFMT_X8R8G8B8,
  231.         D3DFMT_X1R5G5B5,
  232.         D3DFMT_R5G6B5,
  233.     };
  234.     unsigned i;
  235.  
  236.     if (fmt == D3DFMT_A2R10G10B10 && win) { return FALSE; }
  237.  
  238.     for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) {
  239.         if (fmt == allowed[i]) { return TRUE; }
  240.     }
  241.     return FALSE;
  242. }
  243.  
  244. HRESULT WINAPI
  245. NineAdapter9_CheckDeviceFormat( struct NineAdapter9 *This,
  246.                                 D3DDEVTYPE DeviceType,
  247.                                 D3DFORMAT AdapterFormat,
  248.                                 DWORD Usage,
  249.                                 D3DRESOURCETYPE RType,
  250.                                 D3DFORMAT CheckFormat )
  251. {
  252.     struct pipe_screen *screen;
  253.     HRESULT hr;
  254.     enum pipe_format pf;
  255.     enum pipe_texture_target target;
  256.     unsigned bind = 0;
  257.     boolean srgb;
  258.  
  259.     /* Check adapter format. */
  260.  
  261.     DBG("This=%p DeviceType=%s AdapterFormat=%s\n", This,
  262.         nine_D3DDEVTYPE_to_str(DeviceType), d3dformat_to_string(AdapterFormat));
  263.     DBG("Usage=%x RType=%u CheckFormat=%s\n", Usage, RType,
  264.         d3dformat_to_string(CheckFormat));
  265.  
  266.     user_assert(display_format(AdapterFormat, FALSE), D3DERR_INVALIDCALL);
  267.  
  268.     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
  269.     if (FAILED(hr))
  270.         return hr;
  271.     pf = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D, 0,
  272.                                      PIPE_BIND_DISPLAY_TARGET |
  273.                                      PIPE_BIND_SHARED, FALSE);
  274.     if (pf == PIPE_FORMAT_NONE) {
  275.         DBG("AdapterFormat %s not available.\n",
  276.             d3dformat_to_string(AdapterFormat));
  277.         return D3DERR_NOTAVAILABLE;
  278.     }
  279.  
  280.     /* Check actual format. */
  281.  
  282.     switch (RType) {
  283.     case D3DRTYPE_SURFACE:       target = PIPE_TEXTURE_2D; break;
  284.     case D3DRTYPE_TEXTURE:       target = PIPE_TEXTURE_2D; break;
  285.     case D3DRTYPE_CUBETEXTURE:   target = PIPE_TEXTURE_CUBE; break;
  286.     case D3DRTYPE_VOLUME:        target = PIPE_TEXTURE_3D; break;
  287.     case D3DRTYPE_VOLUMETEXTURE: target = PIPE_TEXTURE_3D; break;
  288.     case D3DRTYPE_VERTEXBUFFER:  target = PIPE_BUFFER; break;
  289.     case D3DRTYPE_INDEXBUFFER:   target = PIPE_BUFFER; break;
  290.     default:
  291.         user_assert(0, D3DERR_INVALIDCALL);
  292.     }
  293.  
  294.     bind = 0;
  295.     if (Usage & D3DUSAGE_RENDERTARGET) bind |= PIPE_BIND_RENDER_TARGET;
  296.     if (Usage & D3DUSAGE_DEPTHSTENCIL) bind |= PIPE_BIND_DEPTH_STENCIL;
  297.  
  298.     /* API hack because setting RT[0] to NULL is forbidden */
  299.     if (CheckFormat == D3DFMT_NULL && bind == PIPE_BIND_RENDER_TARGET &&
  300.         (RType == D3DRTYPE_SURFACE ||
  301.          RType == D3DRTYPE_TEXTURE))
  302.         return D3D_OK;
  303.  
  304.     /* RESZ hack */
  305.     if (CheckFormat == D3DFMT_RESZ && bind == PIPE_BIND_RENDER_TARGET &&
  306.         RType == D3DRTYPE_SURFACE)
  307.         return screen->get_param(screen, PIPE_CAP_MULTISAMPLE_Z_RESOLVE) ?
  308.                D3D_OK : D3DERR_NOTAVAILABLE;
  309.  
  310.     /* ATOC hack */
  311.     if (CheckFormat == D3DFMT_ATOC && RType == D3DRTYPE_SURFACE)
  312.         return D3D_OK;
  313.  
  314.     if ((Usage & D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) &&
  315.         (Usage & D3DUSAGE_RENDERTARGET))
  316.         bind |= PIPE_BIND_BLENDABLE;
  317.  
  318.     if (Usage & D3DUSAGE_DMAP) {
  319.         DBG("D3DUSAGE_DMAP not available\n");
  320.         return D3DERR_NOTAVAILABLE; /* TODO: displacement mapping */
  321.     }
  322.  
  323.     switch (RType) {
  324.     case D3DRTYPE_TEXTURE:       bind |= PIPE_BIND_SAMPLER_VIEW; break;
  325.     case D3DRTYPE_CUBETEXTURE:   bind |= PIPE_BIND_SAMPLER_VIEW; break;
  326.     case D3DRTYPE_VOLUMETEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
  327.     case D3DRTYPE_VERTEXBUFFER:  bind |= PIPE_BIND_VERTEX_BUFFER; break;
  328.     case D3DRTYPE_INDEXBUFFER:   bind |= PIPE_BIND_INDEX_BUFFER; break;
  329.     default:
  330.         break;
  331.     }
  332.  
  333.  
  334.     srgb = (Usage & (D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE)) != 0;
  335.     pf = d3d9_to_pipe_format_checked(screen, CheckFormat, target, 0, bind, srgb);
  336.     if (pf == PIPE_FORMAT_NONE) {
  337.         DBG("NOT AVAILABLE\n");
  338.         return D3DERR_NOTAVAILABLE;
  339.     }
  340.  
  341.     /* we support ATI1 and ATI2 hack only for 2D textures */
  342.     if (RType != D3DRTYPE_TEXTURE && (CheckFormat == D3DFMT_ATI1 || CheckFormat == D3DFMT_ATI2))
  343.         return D3DERR_NOTAVAILABLE;
  344.     /* if (Usage & D3DUSAGE_NONSECURE) { don't know the implications of this } */
  345.     /* if (Usage & D3DUSAGE_SOFTWAREPROCESSING) { we can always support this } */
  346.  
  347.     if ((Usage & D3DUSAGE_AUTOGENMIPMAP) && !(bind & PIPE_BIND_SAMPLER_VIEW))
  348.         return D3DOK_NOAUTOGEN;
  349.     return D3D_OK;
  350. }
  351.  
  352. HRESULT WINAPI
  353. NineAdapter9_CheckDeviceMultiSampleType( struct NineAdapter9 *This,
  354.                                          D3DDEVTYPE DeviceType,
  355.                                          D3DFORMAT SurfaceFormat,
  356.                                          BOOL Windowed,
  357.                                          D3DMULTISAMPLE_TYPE MultiSampleType,
  358.                                          DWORD *pQualityLevels )
  359. {
  360.     struct pipe_screen *screen;
  361.     HRESULT hr;
  362.     enum pipe_format pf;
  363.     unsigned bind;
  364.  
  365.     DBG("This=%p DeviceType=%s SurfaceFormat=%s Windowed=%i MultiSampleType=%u "
  366.         "pQualityLevels=%p\n", This, nine_D3DDEVTYPE_to_str(DeviceType),
  367.         d3dformat_to_string(SurfaceFormat), Windowed, MultiSampleType,
  368.         pQualityLevels);
  369.  
  370.     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
  371.     if (FAILED(hr))
  372.         return hr;
  373.  
  374.     if (depth_stencil_format(SurfaceFormat))
  375.         bind = d3d9_get_pipe_depth_format_bindings(SurfaceFormat);
  376.     else /* render-target */
  377.         bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_TRANSFER_READ |
  378.                PIPE_BIND_TRANSFER_WRITE | PIPE_BIND_RENDER_TARGET;
  379.  
  380.     pf = d3d9_to_pipe_format_checked(screen, SurfaceFormat, PIPE_TEXTURE_2D,
  381.                                      MultiSampleType, bind, FALSE);
  382.  
  383.     if (pf == PIPE_FORMAT_NONE) {
  384.         DBG("%s with %u samples not available.\n",
  385.             d3dformat_to_string(SurfaceFormat), MultiSampleType);
  386.         return D3DERR_NOTAVAILABLE;
  387.     }
  388.  
  389.     if (pQualityLevels)
  390.         *pQualityLevels = 1; /* gallium doesn't have quality levels */
  391.  
  392.     return D3D_OK;
  393. }
  394.  
  395. HRESULT WINAPI
  396. NineAdapter9_CheckDepthStencilMatch( struct NineAdapter9 *This,
  397.                                      D3DDEVTYPE DeviceType,
  398.                                      D3DFORMAT AdapterFormat,
  399.                                      D3DFORMAT RenderTargetFormat,
  400.                                      D3DFORMAT DepthStencilFormat )
  401. {
  402.     struct pipe_screen *screen;
  403.     enum pipe_format dfmt, bfmt, zsfmt;
  404.     HRESULT hr;
  405.  
  406.     DBG("This=%p DeviceType=%s AdapterFormat=%s "
  407.         "RenderTargetFormat=%s DepthStencilFormat=%s\n", This,
  408.         nine_D3DDEVTYPE_to_str(DeviceType), d3dformat_to_string(AdapterFormat),
  409.         d3dformat_to_string(RenderTargetFormat),
  410.         d3dformat_to_string(DepthStencilFormat));
  411.  
  412.     user_assert(display_format(AdapterFormat, FALSE), D3DERR_NOTAVAILABLE);
  413.     user_assert(depth_stencil_format(DepthStencilFormat), D3DERR_NOTAVAILABLE);
  414.  
  415.     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
  416.     if (FAILED(hr)) { return hr; }
  417.  
  418.     dfmt = d3d9_to_pipe_format_checked(screen, AdapterFormat, PIPE_TEXTURE_2D, 0,
  419.                                        PIPE_BIND_DISPLAY_TARGET |
  420.                                        PIPE_BIND_SHARED, FALSE);
  421.     bfmt = d3d9_to_pipe_format_checked(screen, RenderTargetFormat,
  422.                                        PIPE_TEXTURE_2D, 0,
  423.                                        PIPE_BIND_RENDER_TARGET, FALSE);
  424.     if (RenderTargetFormat == D3DFMT_NULL)
  425.         bfmt = dfmt;
  426.     zsfmt = d3d9_to_pipe_format_checked(screen, DepthStencilFormat,
  427.                                         PIPE_TEXTURE_2D, 0,
  428.                                         d3d9_get_pipe_depth_format_bindings(DepthStencilFormat),
  429.                                         FALSE);
  430.     if (dfmt == PIPE_FORMAT_NONE ||
  431.         bfmt == PIPE_FORMAT_NONE ||
  432.         zsfmt == PIPE_FORMAT_NONE) {
  433.         return D3DERR_NOTAVAILABLE;
  434.     }
  435.  
  436.     return D3D_OK;
  437. }
  438.  
  439. HRESULT WINAPI
  440. NineAdapter9_CheckDeviceFormatConversion( struct NineAdapter9 *This,
  441.                                           D3DDEVTYPE DeviceType,
  442.                                           D3DFORMAT SourceFormat,
  443.                                           D3DFORMAT TargetFormat )
  444. {
  445.     /* MSDN says this tests whether a certain backbuffer format can be used in
  446.      * conjunction with a certain front buffer format. It's a little confusing
  447.      * but some one wiser might be able to figure this one out. XXX */
  448.     struct pipe_screen *screen;
  449.     enum pipe_format dfmt, bfmt;
  450.     HRESULT hr;
  451.  
  452.     DBG("This=%p DeviceType=%s SourceFormat=%s TargetFormat=%s\n", This,
  453.         nine_D3DDEVTYPE_to_str(DeviceType),
  454.         d3dformat_to_string(SourceFormat), d3dformat_to_string(TargetFormat));
  455.  
  456.     user_assert(backbuffer_format(TargetFormat, SourceFormat, FALSE),
  457.                 D3DERR_NOTAVAILABLE);
  458.  
  459.     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
  460.     if (FAILED(hr)) { return hr; }
  461.  
  462.     dfmt = d3d9_to_pipe_format_checked(screen, TargetFormat, PIPE_TEXTURE_2D, 1,
  463.                                        PIPE_BIND_DISPLAY_TARGET |
  464.                                        PIPE_BIND_SHARED, FALSE);
  465.     bfmt = d3d9_to_pipe_format_checked(screen, SourceFormat, PIPE_TEXTURE_2D, 1,
  466.                                        PIPE_BIND_DISPLAY_TARGET |
  467.                                        PIPE_BIND_SHARED, FALSE);
  468.  
  469.     if (dfmt == PIPE_FORMAT_NONE || bfmt == PIPE_FORMAT_NONE) {
  470.         DBG("%s to %s not supported.\n",
  471.             d3dformat_to_string(SourceFormat),
  472.             d3dformat_to_string(TargetFormat));
  473.         return D3DERR_NOTAVAILABLE;
  474.     }
  475.  
  476.     return D3D_OK;
  477. }
  478.  
  479. HRESULT WINAPI
  480. NineAdapter9_GetDeviceCaps( struct NineAdapter9 *This,
  481.                             D3DDEVTYPE DeviceType,
  482.                             D3DCAPS9 *pCaps )
  483. {
  484.     struct pipe_screen *screen;
  485.     HRESULT hr;
  486.  
  487.     DBG("This=%p DeviceType=%s pCaps=%p\n", This,
  488.         nine_D3DDEVTYPE_to_str(DeviceType), pCaps);
  489.  
  490.     user_assert(pCaps, D3DERR_INVALIDCALL);
  491.  
  492.     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
  493.     if (FAILED(hr)) {
  494.        DBG("Failed to get pipe_screen.\n");
  495.        return hr;
  496.     }
  497.  
  498. #define D3DPIPECAP(pcap, d3dcap) \
  499.     (screen->get_param(screen, PIPE_CAP_##pcap) ? (d3dcap) : 0)
  500.  
  501. #define D3DNPIPECAP(pcap, d3dcap) \
  502.     (screen->get_param(screen, PIPE_CAP_##pcap) ? 0 : (d3dcap))
  503.  
  504.     pCaps->DeviceType = DeviceType;
  505.  
  506.     pCaps->AdapterOrdinal = 0;
  507.  
  508.     pCaps->Caps = 0;
  509.  
  510.     pCaps->Caps2 = D3DCAPS2_CANMANAGERESOURCE |
  511.                 /* D3DCAPS2_CANSHARERESOURCE | */
  512.                 /* D3DCAPS2_CANCALIBRATEGAMMA | */
  513.                    D3DCAPS2_DYNAMICTEXTURES |
  514.                    D3DCAPS2_FULLSCREENGAMMA |
  515.                    D3DCAPS2_CANAUTOGENMIPMAP;
  516.  
  517.     /* Note: D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD just means the
  518.      * backbuffer can be ARGB (instead of only XRGB) when we are fullscreen
  519.      * and in discard mode. */
  520.     pCaps->Caps3 = D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
  521.                    D3DCAPS3_COPY_TO_VIDMEM |
  522.                    D3DCAPS3_COPY_TO_SYSTEMMEM |
  523.                    D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION;
  524.  
  525.     pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_DEFAULT |
  526.                                    D3DPRESENT_INTERVAL_ONE |
  527.                                    D3DPRESENT_INTERVAL_TWO |
  528.                                    D3DPRESENT_INTERVAL_THREE |
  529.                                    D3DPRESENT_INTERVAL_FOUR |
  530.                                    D3DPRESENT_INTERVAL_IMMEDIATE;
  531.     pCaps->CursorCaps = D3DCURSORCAPS_COLOR | D3DCURSORCAPS_LOWRES;
  532.  
  533.     pCaps->DevCaps = D3DDEVCAPS_CANBLTSYSTONONLOCAL |
  534.                      D3DDEVCAPS_CANRENDERAFTERFLIP |
  535.                      D3DDEVCAPS_DRAWPRIMITIVES2 |
  536.                      D3DDEVCAPS_DRAWPRIMITIVES2EX |
  537.                      D3DDEVCAPS_DRAWPRIMTLVERTEX |
  538.                      D3DDEVCAPS_EXECUTESYSTEMMEMORY |
  539.                      D3DDEVCAPS_EXECUTEVIDEOMEMORY |
  540.                      D3DDEVCAPS_HWRASTERIZATION |
  541.                      D3DDEVCAPS_HWTRANSFORMANDLIGHT |
  542.                      /*D3DDEVCAPS_NPATCHES |*/
  543.                      D3DDEVCAPS_PUREDEVICE |
  544.                      /*D3DDEVCAPS_QUINTICRTPATCHES |*/
  545.                      /*D3DDEVCAPS_RTPATCHES |*/
  546.                      /*D3DDEVCAPS_RTPATCHHANDLEZERO |*/
  547.                      /*D3DDEVCAPS_SEPARATETEXTUREMEMORIES |*/
  548.                      /*D3DDEVCAPS_TEXTURENONLOCALVIDMEM |*/
  549.                      /* D3DDEVCAPS_TEXTURESYSTEMMEMORY |*/
  550.                      D3DDEVCAPS_TEXTUREVIDEOMEMORY |
  551.                      D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
  552.                      D3DDEVCAPS_TLVERTEXVIDEOMEMORY;
  553.  
  554.     pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_MASKZ |
  555.                                D3DPMISCCAPS_CULLNONE | /* XXX */
  556.                                D3DPMISCCAPS_CULLCW |
  557.                                D3DPMISCCAPS_CULLCCW |
  558.                                D3DPMISCCAPS_COLORWRITEENABLE |
  559.                                D3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
  560.                                /*D3DPMISCCAPS_CLIPTLVERTS |*/
  561.                                D3DPMISCCAPS_TSSARGTEMP |
  562.                                D3DPMISCCAPS_BLENDOP |
  563.                                D3DPIPECAP(INDEP_BLEND_ENABLE, D3DPMISCCAPS_INDEPENDENTWRITEMASKS) |
  564.                                /*D3DPMISCCAPS_PERSTAGECONSTANT |*/
  565.                                /*D3DPMISCCAPS_POSTBLENDSRGBCONVERT |*/ /* TODO */
  566.                                D3DPMISCCAPS_FOGANDSPECULARALPHA |
  567.                                D3DPIPECAP(BLEND_EQUATION_SEPARATE, D3DPMISCCAPS_SEPARATEALPHABLEND) |
  568.                                D3DPIPECAP(MIXED_COLORBUFFER_FORMATS, D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS) |
  569.                                D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING |
  570.                                /*D3DPMISCCAPS_FOGVERTEXCLAMPED*/0;
  571.     if (!screen->get_param(screen, PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION))
  572.         pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_CLIPTLVERTS;
  573.  
  574.     pCaps->RasterCaps =
  575.         D3DPIPECAP(ANISOTROPIC_FILTER, D3DPRASTERCAPS_ANISOTROPY) |
  576.         /*D3DPRASTERCAPS_COLORPERSPECTIVE |*/
  577.         D3DPRASTERCAPS_DITHER |
  578.         D3DPRASTERCAPS_DEPTHBIAS |
  579.         /*D3DPRASTERCAPS_FOGRANGE |*/
  580.         /*D3DPRASTERCAPS_FOGTABLE |*/
  581.         /*D3DPRASTERCAPS_FOGVERTEX |*/
  582.         D3DPRASTERCAPS_MIPMAPLODBIAS |
  583.         D3DPRASTERCAPS_MULTISAMPLE_TOGGLE |
  584.         D3DPRASTERCAPS_SCISSORTEST |
  585.         D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
  586.         /*D3DPRASTERCAPS_WBUFFER |*/
  587.         /*D3DPRASTERCAPS_WFOG |*/
  588.         /*D3DPRASTERCAPS_ZBUFFERLESSHSR |*/
  589.         /*D3DPRASTERCAPS_ZFOG |*/
  590.         D3DPRASTERCAPS_ZTEST;
  591.  
  592.     pCaps->ZCmpCaps = D3DPCMPCAPS_NEVER |
  593.                       D3DPCMPCAPS_LESS |
  594.                       D3DPCMPCAPS_EQUAL |
  595.                       D3DPCMPCAPS_LESSEQUAL |
  596.                       D3DPCMPCAPS_GREATER |
  597.                       D3DPCMPCAPS_NOTEQUAL |
  598.                       D3DPCMPCAPS_GREATEREQUAL |
  599.                       D3DPCMPCAPS_ALWAYS;
  600.  
  601.     pCaps->SrcBlendCaps = D3DPBLENDCAPS_ZERO |
  602.                           D3DPBLENDCAPS_ONE |
  603.                           D3DPBLENDCAPS_SRCCOLOR |
  604.                           D3DPBLENDCAPS_INVSRCCOLOR |
  605.                           D3DPBLENDCAPS_SRCALPHA |
  606.                           D3DPBLENDCAPS_INVSRCALPHA |
  607.                           D3DPBLENDCAPS_DESTALPHA |
  608.                           D3DPBLENDCAPS_INVDESTALPHA |
  609.                           D3DPBLENDCAPS_DESTCOLOR |
  610.                           D3DPBLENDCAPS_INVDESTCOLOR |
  611.                           D3DPBLENDCAPS_SRCALPHASAT |
  612.                           D3DPBLENDCAPS_BOTHSRCALPHA |
  613.                           D3DPBLENDCAPS_BOTHINVSRCALPHA |
  614.                           D3DPBLENDCAPS_BLENDFACTOR |
  615.                           D3DPIPECAP(MAX_DUAL_SOURCE_RENDER_TARGETS,
  616.                               D3DPBLENDCAPS_INVSRCCOLOR2 |
  617.                               D3DPBLENDCAPS_SRCCOLOR2);
  618.  
  619.     pCaps->DestBlendCaps = pCaps->SrcBlendCaps;
  620.  
  621.     pCaps->AlphaCmpCaps = D3DPCMPCAPS_LESS |
  622.                           D3DPCMPCAPS_EQUAL |
  623.                           D3DPCMPCAPS_LESSEQUAL |
  624.                           D3DPCMPCAPS_GREATER |
  625.                           D3DPCMPCAPS_NOTEQUAL |
  626.                           D3DPCMPCAPS_GREATEREQUAL |
  627.                           D3DPCMPCAPS_ALWAYS;
  628.  
  629.     /* FLAT caps not legal for D3D9. */
  630.     pCaps->ShadeCaps = D3DPSHADECAPS_COLORGOURAUDRGB |
  631.                        D3DPSHADECAPS_SPECULARGOURAUDRGB |
  632.                        D3DPSHADECAPS_ALPHAGOURAUDBLEND |
  633.                        D3DPSHADECAPS_FOGGOURAUD;
  634.  
  635.     pCaps->TextureCaps =
  636.         D3DPTEXTURECAPS_ALPHA |
  637.         D3DPTEXTURECAPS_ALPHAPALETTE |
  638.         D3DPTEXTURECAPS_PERSPECTIVE |
  639.         D3DPTEXTURECAPS_PROJECTED |
  640.         /*D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE |*/
  641.         D3DPTEXTURECAPS_CUBEMAP |
  642.         D3DPTEXTURECAPS_VOLUMEMAP |
  643.         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_POW2) |
  644.         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_NONPOW2CONDITIONAL) |
  645.         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_CUBEMAP_POW2) |
  646.         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_VOLUMEMAP_POW2) |
  647.         D3DPIPECAP(MAX_TEXTURE_2D_LEVELS, D3DPTEXTURECAPS_MIPMAP) |
  648.         D3DPIPECAP(MAX_TEXTURE_3D_LEVELS, D3DPTEXTURECAPS_MIPVOLUMEMAP) |
  649.         D3DPIPECAP(MAX_TEXTURE_CUBE_LEVELS, D3DPTEXTURECAPS_MIPCUBEMAP);
  650.  
  651.     pCaps->TextureFilterCaps =
  652.         D3DPTFILTERCAPS_MINFPOINT |
  653.         D3DPTFILTERCAPS_MINFLINEAR |
  654.         D3DPIPECAP(ANISOTROPIC_FILTER, D3DPTFILTERCAPS_MINFANISOTROPIC) |
  655.         /*D3DPTFILTERCAPS_MINFPYRAMIDALQUAD |*/
  656.         /*D3DPTFILTERCAPS_MINFGAUSSIANQUAD |*/
  657.         D3DPTFILTERCAPS_MIPFPOINT |
  658.         D3DPTFILTERCAPS_MIPFLINEAR |
  659.         D3DPTFILTERCAPS_MAGFPOINT |
  660.         D3DPTFILTERCAPS_MAGFLINEAR |
  661.         D3DPIPECAP(ANISOTROPIC_FILTER, D3DPTFILTERCAPS_MAGFANISOTROPIC) |
  662.         /*D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD |*/
  663.         /*D3DPTFILTERCAPS_MAGFGAUSSIANQUAD*/0;
  664.  
  665.     pCaps->CubeTextureFilterCaps = pCaps->TextureFilterCaps;
  666.     pCaps->VolumeTextureFilterCaps = pCaps->TextureFilterCaps;
  667.  
  668.     pCaps->TextureAddressCaps =
  669.         D3DPTADDRESSCAPS_BORDER |
  670.         D3DPTADDRESSCAPS_INDEPENDENTUV |
  671.         D3DPTADDRESSCAPS_WRAP |
  672.         D3DPTADDRESSCAPS_MIRROR |
  673.         D3DPTADDRESSCAPS_CLAMP |
  674.         D3DPIPECAP(TEXTURE_MIRROR_CLAMP, D3DPTADDRESSCAPS_MIRRORONCE);
  675.  
  676.     pCaps->VolumeTextureAddressCaps = pCaps->TextureAddressCaps;
  677.  
  678.     pCaps->LineCaps =
  679.         D3DLINECAPS_ALPHACMP |
  680.         D3DLINECAPS_BLEND |
  681.         D3DLINECAPS_TEXTURE |
  682.         D3DLINECAPS_ZTEST |
  683.         D3DLINECAPS_FOG;
  684.     if (screen->get_paramf(screen, PIPE_CAPF_MAX_LINE_WIDTH_AA) > 0.0) {
  685.         pCaps->LineCaps |= D3DLINECAPS_ANTIALIAS;
  686.     }
  687.  
  688.     pCaps->MaxTextureWidth =
  689.         1 << (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
  690.     pCaps->MaxTextureHeight = pCaps->MaxTextureWidth;
  691.     pCaps->MaxVolumeExtent =
  692.         1 << (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS) - 1);
  693.     /* XXX values from wine */
  694.     pCaps->MaxTextureRepeat = 32768;
  695.     pCaps->MaxTextureAspectRatio = pCaps->MaxTextureWidth;
  696.  
  697.     pCaps->MaxAnisotropy =
  698.         (DWORD)screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_ANISOTROPY);
  699.  
  700.     pCaps->MaxVertexW = 1.0f; /* XXX */
  701.     pCaps->GuardBandLeft = screen->get_paramf(screen,
  702.                                               PIPE_CAPF_GUARD_BAND_LEFT);
  703.     pCaps->GuardBandTop = screen->get_paramf(screen,
  704.                                              PIPE_CAPF_GUARD_BAND_TOP);
  705.     pCaps->GuardBandRight = screen->get_paramf(screen,
  706.                                                PIPE_CAPF_GUARD_BAND_RIGHT);
  707.     pCaps->GuardBandBottom = screen->get_paramf(screen,
  708.                                                 PIPE_CAPF_GUARD_BAND_BOTTOM);
  709.     pCaps->ExtentsAdjust = 0.0f;
  710.  
  711.     pCaps->StencilCaps =
  712.         D3DSTENCILCAPS_KEEP |
  713.         D3DSTENCILCAPS_ZERO |
  714.         D3DSTENCILCAPS_REPLACE |
  715.         D3DSTENCILCAPS_INCRSAT |
  716.         D3DSTENCILCAPS_DECRSAT |
  717.         D3DSTENCILCAPS_INVERT |
  718.         D3DSTENCILCAPS_INCR |
  719.         D3DSTENCILCAPS_DECR |
  720.         D3DPIPECAP(TWO_SIDED_STENCIL, D3DSTENCILCAPS_TWOSIDED);
  721.  
  722.     pCaps->FVFCaps =
  723.         8 | /* 8 textures max */
  724.         /*D3DFVFCAPS_DONOTSTRIPELEMENTS |*/
  725.         D3DFVFCAPS_PSIZE;
  726.  
  727.     /* XXX: Some of these are probably not in SM2.0 so cap them when I figure
  728.      * them out. For now leave them all enabled. */
  729.     pCaps->TextureOpCaps = D3DTEXOPCAPS_DISABLE |
  730.                            D3DTEXOPCAPS_SELECTARG1 |
  731.                            D3DTEXOPCAPS_SELECTARG2 |
  732.                            D3DTEXOPCAPS_MODULATE |
  733.                            D3DTEXOPCAPS_MODULATE2X |
  734.                            D3DTEXOPCAPS_MODULATE4X |
  735.                            D3DTEXOPCAPS_ADD |
  736.                            D3DTEXOPCAPS_ADDSIGNED |
  737.                            D3DTEXOPCAPS_ADDSIGNED2X |
  738.                            D3DTEXOPCAPS_SUBTRACT |
  739.                            D3DTEXOPCAPS_ADDSMOOTH |
  740.                            D3DTEXOPCAPS_BLENDDIFFUSEALPHA |
  741.                            D3DTEXOPCAPS_BLENDTEXTUREALPHA |
  742.                            D3DTEXOPCAPS_BLENDFACTORALPHA |
  743.                            D3DTEXOPCAPS_BLENDTEXTUREALPHAPM |
  744.                            D3DTEXOPCAPS_BLENDCURRENTALPHA |
  745.                            D3DTEXOPCAPS_PREMODULATE |
  746.                            D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
  747.                            D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
  748.                            D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
  749.                            D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
  750.                            D3DTEXOPCAPS_BUMPENVMAP |
  751.                            D3DTEXOPCAPS_BUMPENVMAPLUMINANCE |
  752.                            D3DTEXOPCAPS_DOTPRODUCT3 |
  753.                            D3DTEXOPCAPS_MULTIPLYADD |
  754.                            D3DTEXOPCAPS_LERP;
  755.  
  756.     pCaps->MaxTextureBlendStages = 8; /* XXX wine */
  757.         (DWORD)screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_SEPARATE);
  758.     pCaps->MaxSimultaneousTextures = screen->get_shader_param(screen,
  759.         PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS);
  760.     if (pCaps->MaxSimultaneousTextures > NINE_MAX_SAMPLERS_PS)
  761.         pCaps->MaxSimultaneousTextures = NINE_MAX_SAMPLERS_PS;
  762.  
  763.     pCaps->VertexProcessingCaps = D3DVTXPCAPS_TEXGEN |
  764.                                   /*D3DVTXPCAPS_TEXGEN_SPHEREMAP |*/
  765.                                   D3DVTXPCAPS_MATERIALSOURCE7 |
  766.                                   D3DVTXPCAPS_DIRECTIONALLIGHTS |
  767.                                   D3DVTXPCAPS_POSITIONALLIGHTS |
  768.                                   D3DVTXPCAPS_LOCALVIEWER |
  769.                                   D3DVTXPCAPS_TWEENING |
  770.                                   /*D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER*/0;
  771.  
  772.     pCaps->MaxActiveLights = NINE_MAX_LIGHTS_ACTIVE; /* like GL_LIGHTi */
  773.     pCaps->MaxUserClipPlanes = PIPE_MAX_CLIP_PLANES;
  774.     pCaps->MaxVertexBlendMatrices = 4; /* 1 vec4 BLENDWEIGHT/INDICES input */
  775.     pCaps->MaxVertexBlendMatrixIndex = 7; /* D3DTS_WORLDMATRIX(0..7) */
  776.  
  777.     pCaps->MaxPointSize = screen->get_paramf(screen, PIPE_CAPF_MAX_POINT_WIDTH);
  778.  
  779.     pCaps->MaxPrimitiveCount = 0x555555; /* <- wine, really 0xFFFFFFFF; */
  780.     pCaps->MaxVertexIndex = 0xFFFFFF; /* <- wine, really 0xFFFFFFFF */
  781.     pCaps->MaxStreams =
  782.         _min(screen->get_shader_param(screen,
  783.                  PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_INPUTS),
  784.              16);
  785.  
  786.     pCaps->MaxStreamStride = screen->get_param(screen,
  787.             PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE);
  788.  
  789.     pCaps->VertexShaderVersion = D3DVS_VERSION(3,0);
  790.  
  791.     /* VS 2 as well as 3.0 supports a minimum of 256 consts.
  792.      * Wine and d3d9 drivers for dx1x hw advertise 256. Just as them,
  793.      * advertise 256. Problem is with hw that can only do 256, because
  794.      * we need take a few slots for boolean and integer constants. For these
  795.      * we'll have to fail later if they use complex shaders. */
  796.     pCaps->MaxVertexShaderConst = NINE_MAX_CONST_F;
  797.  
  798.     pCaps->PixelShaderVersion = D3DPS_VERSION(3,0);
  799.     pCaps->PixelShader1xMaxValue = 8.0f; /* XXX: wine */
  800.  
  801.     pCaps->DevCaps2 = D3DDEVCAPS2_STREAMOFFSET |
  802.                       D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET |
  803.                       D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES |
  804.                       /*D3DDEVCAPS2_DMAPNPATCH |*/
  805.                       /*D3DDEVCAPS2_ADAPTIVETESSRTPATCH |*/
  806.                       /*D3DDEVCAPS2_ADAPTIVETESSNPATCH |*/
  807.                       /*D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH*/0;
  808.  
  809.     pCaps->MasterAdapterOrdinal = 0;
  810.     pCaps->AdapterOrdinalInGroup = 0;
  811.     pCaps->NumberOfAdaptersInGroup = 1;
  812.  
  813.     /* Undocumented ? */
  814.     pCaps->MaxNpatchTessellationLevel = 0.0f;
  815.     pCaps->Reserved5 = 0;
  816.  
  817.     /* XXX: use is_format_supported */
  818.     pCaps->DeclTypes = D3DDTCAPS_UBYTE4 |
  819.                        D3DDTCAPS_UBYTE4N |
  820.                        D3DDTCAPS_SHORT2N |
  821.                        D3DDTCAPS_SHORT4N |
  822.                        D3DDTCAPS_USHORT2N |
  823.                        D3DDTCAPS_USHORT4N |
  824.                        D3DDTCAPS_UDEC3 |
  825.                        D3DDTCAPS_DEC3N |
  826.                        D3DDTCAPS_FLOAT16_2 |
  827.                        D3DDTCAPS_FLOAT16_4;
  828.  
  829.     pCaps->NumSimultaneousRTs =
  830.         screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS);
  831.     if (pCaps->NumSimultaneousRTs > NINE_MAX_SIMULTANEOUS_RENDERTARGETS)
  832.         pCaps->NumSimultaneousRTs = NINE_MAX_SIMULTANEOUS_RENDERTARGETS;
  833.  
  834.     pCaps->StretchRectFilterCaps = D3DPTFILTERCAPS_MINFPOINT |
  835.                                    D3DPTFILTERCAPS_MINFLINEAR |
  836.                                    D3DPTFILTERCAPS_MAGFPOINT |
  837.                                    D3DPTFILTERCAPS_MAGFLINEAR;
  838.  
  839.  
  840.     pCaps->VS20Caps.Caps = D3DVS20CAPS_PREDICATION;
  841.     pCaps->VS20Caps.DynamicFlowControlDepth = /* XXX is this dynamic ? */
  842.         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
  843.                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
  844.     pCaps->VS20Caps.NumTemps =
  845.         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
  846.                                  PIPE_SHADER_CAP_MAX_TEMPS);
  847.     pCaps->VS20Caps.StaticFlowControlDepth = /* XXX is this static ? */
  848.         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
  849.                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
  850.  
  851.     /* also check for values < 0, because get_shader_param may return unsigned */
  852.     if (pCaps->VS20Caps.DynamicFlowControlDepth > D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH
  853.         || pCaps->VS20Caps.DynamicFlowControlDepth < 0)
  854.         pCaps->VS20Caps.DynamicFlowControlDepth = D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH;
  855.     if (pCaps->VS20Caps.StaticFlowControlDepth > D3DVS20_MAX_STATICFLOWCONTROLDEPTH
  856.         || pCaps->VS20Caps.StaticFlowControlDepth < 0)
  857.         pCaps->VS20Caps.StaticFlowControlDepth = D3DVS20_MAX_STATICFLOWCONTROLDEPTH;
  858.     if (pCaps->VS20Caps.NumTemps > D3DVS20_MAX_NUMTEMPS)
  859.         pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
  860.     assert(pCaps->VS20Caps.DynamicFlowControlDepth >= D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH);
  861.     assert(pCaps->VS20Caps.StaticFlowControlDepth >= D3DVS20_MIN_STATICFLOWCONTROLDEPTH);
  862.     assert(pCaps->VS20Caps.NumTemps >= D3DVS20_MIN_NUMTEMPS);
  863.  
  864.  
  865.     pCaps->PS20Caps.Caps = D3DPS20CAPS_ARBITRARYSWIZZLE |
  866.                            D3DPS20CAPS_GRADIENTINSTRUCTIONS |
  867.                            D3DPS20CAPS_PREDICATION;
  868.     if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  869.                                  PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS) ==
  870.         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  871.                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS))
  872.         pCaps->PS20Caps.Caps |= D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
  873.     if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  874.                                  PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS) ==
  875.         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  876.                                  PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS))
  877.         pCaps->PS20Caps.Caps |= D3DPS20CAPS_NODEPENDENTREADLIMIT;
  878.     pCaps->PS20Caps.DynamicFlowControlDepth = /* XXX is this dynamic ? */
  879.         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  880.                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
  881.     pCaps->PS20Caps.NumTemps =
  882.         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  883.                                  PIPE_SHADER_CAP_MAX_TEMPS);
  884.     pCaps->PS20Caps.StaticFlowControlDepth =  /* XXX is this static ? */
  885.         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  886.                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
  887.     pCaps->PS20Caps.NumInstructionSlots =
  888.         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  889.                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
  890.  
  891.     if (pCaps->PS20Caps.DynamicFlowControlDepth > D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH
  892.         || pCaps->PS20Caps.DynamicFlowControlDepth < 0)
  893.         pCaps->PS20Caps.DynamicFlowControlDepth = D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH;
  894.     if (pCaps->PS20Caps.StaticFlowControlDepth > D3DPS20_MAX_STATICFLOWCONTROLDEPTH
  895.         || pCaps->PS20Caps.StaticFlowControlDepth < 0)
  896.         pCaps->PS20Caps.StaticFlowControlDepth = D3DPS20_MAX_STATICFLOWCONTROLDEPTH;
  897.     if (pCaps->PS20Caps.NumTemps > D3DPS20_MAX_NUMTEMPS)
  898.         pCaps->PS20Caps.NumTemps = D3DPS20_MAX_NUMTEMPS;
  899.     if (pCaps->PS20Caps.NumInstructionSlots > D3DPS20_MAX_NUMINSTRUCTIONSLOTS)
  900.         pCaps->PS20Caps.NumInstructionSlots = D3DPS20_MAX_NUMINSTRUCTIONSLOTS;
  901.     assert(pCaps->PS20Caps.DynamicFlowControlDepth >= D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH);
  902.     assert(pCaps->PS20Caps.StaticFlowControlDepth >= D3DPS20_MIN_STATICFLOWCONTROLDEPTH);
  903.     assert(pCaps->PS20Caps.NumTemps >= D3DPS20_MIN_NUMTEMPS);
  904.     assert(pCaps->PS20Caps.NumInstructionSlots >= D3DPS20_MIN_NUMINSTRUCTIONSLOTS);
  905.  
  906.  
  907.     if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
  908.                                  PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS))
  909.         pCaps->VertexTextureFilterCaps = pCaps->TextureFilterCaps &
  910.             ~(D3DPTFILTERCAPS_MIPFPOINT |
  911.               D3DPTFILTERCAPS_MIPFPOINT); /* XXX */
  912.     else
  913.         pCaps->VertexTextureFilterCaps = 0;
  914.  
  915.     pCaps->MaxVertexShader30InstructionSlots =
  916.         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
  917.                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
  918.     pCaps->MaxPixelShader30InstructionSlots =
  919.         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
  920.                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
  921.     if (pCaps->MaxVertexShader30InstructionSlots > D3DMAX30SHADERINSTRUCTIONS)
  922.         pCaps->MaxVertexShader30InstructionSlots = D3DMAX30SHADERINSTRUCTIONS;
  923.     if (pCaps->MaxPixelShader30InstructionSlots > D3DMAX30SHADERINSTRUCTIONS)
  924.         pCaps->MaxPixelShader30InstructionSlots = D3DMAX30SHADERINSTRUCTIONS;
  925.     assert(pCaps->MaxVertexShader30InstructionSlots >= D3DMIN30SHADERINSTRUCTIONS);
  926.     assert(pCaps->MaxPixelShader30InstructionSlots >= D3DMIN30SHADERINSTRUCTIONS);
  927.  
  928.     /* 65535 is required, advertise more for GPUs with >= 2048 instruction slots */
  929.     pCaps->MaxVShaderInstructionsExecuted = MAX2(65535, pCaps->MaxVertexShader30InstructionSlots * 32);
  930.     pCaps->MaxPShaderInstructionsExecuted = MAX2(65535, pCaps->MaxPixelShader30InstructionSlots * 32);
  931.  
  932.     if (debug_get_bool_option("NINE_DUMP_CAPS", FALSE))
  933.         nine_dump_D3DCAPS9(DBG_CHANNEL, pCaps);
  934.  
  935.     return D3D_OK;
  936. }
  937.  
  938. HRESULT WINAPI
  939. NineAdapter9_CreateDevice( struct NineAdapter9 *This,
  940.                            UINT RealAdapter,
  941.                            D3DDEVTYPE DeviceType,
  942.                            HWND hFocusWindow,
  943.                            DWORD BehaviorFlags,
  944.                            D3DPRESENT_PARAMETERS *pPresentationParameters,
  945.                            IDirect3D9 *pD3D9,
  946.                            ID3DPresentGroup *pPresentationGroup,
  947.                            IDirect3DDevice9 **ppReturnedDeviceInterface )
  948. {
  949.     struct pipe_screen *screen;
  950.     D3DDEVICE_CREATION_PARAMETERS params;
  951.     D3DCAPS9 caps;
  952.     int major, minor;
  953.     HRESULT hr;
  954.  
  955.     DBG("This=%p RealAdapter=%u DeviceType=%s hFocusWindow=%p "
  956.         "BehaviourFlags=%x " "pD3D9=%p pPresentationGroup=%p "
  957.         "ppReturnedDeviceInterface=%p\n", This,
  958.         RealAdapter, nine_D3DDEVTYPE_to_str(DeviceType), hFocusWindow,
  959.         BehaviorFlags, pD3D9, pPresentationGroup, ppReturnedDeviceInterface);
  960.  
  961.     ID3DPresentGroup_GetVersion(pPresentationGroup, &major, &minor);
  962.     if (major != 1) {
  963.         ERR("Doesn't support the ID3DPresentGroup version %d %d. Expected 1\n",
  964.             major, minor);
  965.         return D3DERR_NOTAVAILABLE;
  966.     }
  967.  
  968.     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
  969.     if (FAILED(hr)) {
  970.         DBG("Failed to get pipe_screen.\n");
  971.         return hr;
  972.     }
  973.  
  974.     hr = NineAdapter9_GetDeviceCaps(This, DeviceType, &caps);
  975.     if (FAILED(hr)) {
  976.         DBG("Failed to get device caps.\n");
  977.         return hr;
  978.     }
  979.  
  980.     params.AdapterOrdinal = RealAdapter;
  981.     params.DeviceType = DeviceType;
  982.     params.hFocusWindow = hFocusWindow;
  983.     params.BehaviorFlags = BehaviorFlags;
  984.  
  985.     hr = NineDevice9_new(screen, &params, &caps, pPresentationParameters,
  986.                          pD3D9, pPresentationGroup, This->ctx, FALSE, NULL,
  987.                          (struct NineDevice9 **)ppReturnedDeviceInterface);
  988.     if (FAILED(hr)) {
  989.         DBG("Failed to create device.\n");
  990.         return hr;
  991.     }
  992.     DBG("NineDevice9 created successfully.\n");
  993.  
  994.     return D3D_OK;
  995. }
  996.  
  997. HRESULT WINAPI
  998. NineAdapter9_CreateDeviceEx( struct NineAdapter9 *This,
  999.                              UINT RealAdapter,
  1000.                              D3DDEVTYPE DeviceType,
  1001.                              HWND hFocusWindow,
  1002.                              DWORD BehaviorFlags,
  1003.                              D3DPRESENT_PARAMETERS *pPresentationParameters,
  1004.                              D3DDISPLAYMODEEX *pFullscreenDisplayMode,
  1005.                              IDirect3D9Ex *pD3D9Ex,
  1006.                              ID3DPresentGroup *pPresentationGroup,
  1007.                              IDirect3DDevice9Ex **ppReturnedDeviceInterface )
  1008. {
  1009.     struct pipe_screen *screen;
  1010.     D3DDEVICE_CREATION_PARAMETERS params;
  1011.     D3DCAPS9 caps;
  1012.     int major, minor;
  1013.     HRESULT hr;
  1014.  
  1015.     DBG("This=%p RealAdapter=%u DeviceType=%s hFocusWindow=%p "
  1016.         "BehaviourFlags=%x " "pD3D9Ex=%p pPresentationGroup=%p "
  1017.         "ppReturnedDeviceInterface=%p\n", This,
  1018.         RealAdapter, nine_D3DDEVTYPE_to_str(DeviceType), hFocusWindow,
  1019.         BehaviorFlags, pD3D9Ex, pPresentationGroup, ppReturnedDeviceInterface);
  1020.  
  1021.     ID3DPresentGroup_GetVersion(pPresentationGroup, &major, &minor);
  1022.     if (major != 1) {
  1023.         ERR("Doesn't support the ID3DPresentGroup version %d %d. Expected 1\n",
  1024.             major, minor);
  1025.         return D3DERR_NOTAVAILABLE;
  1026.     }
  1027.  
  1028.     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
  1029.     if (FAILED(hr)) {
  1030.         DBG("Failed to get pipe_screen.\n");
  1031.         return hr;
  1032.     }
  1033.  
  1034.     hr = NineAdapter9_GetDeviceCaps(This, DeviceType, &caps);
  1035.     if (FAILED(hr)) {
  1036.         DBG("Failed to get device caps.\n");
  1037.         return hr;
  1038.     }
  1039.  
  1040.     params.AdapterOrdinal = RealAdapter;
  1041.     params.DeviceType = DeviceType;
  1042.     params.hFocusWindow = hFocusWindow;
  1043.     params.BehaviorFlags = BehaviorFlags;
  1044.  
  1045.     hr = NineDevice9Ex_new(screen, &params, &caps, pPresentationParameters,
  1046.                            pFullscreenDisplayMode,
  1047.                            pD3D9Ex, pPresentationGroup, This->ctx,
  1048.                            (struct NineDevice9Ex **)ppReturnedDeviceInterface);
  1049.     if (FAILED(hr)) {
  1050.         DBG("Failed to create device.\n");
  1051.         return hr;
  1052.     }
  1053.     DBG("NineDevice9Ex created successfully.\n");
  1054.  
  1055.     return D3D_OK;
  1056. }
  1057.  
  1058. ID3DAdapter9Vtbl NineAdapter9_vtable = {
  1059.     (void *)NineUnknown_QueryInterface,
  1060.     (void *)NineUnknown_AddRef,
  1061.     (void *)NineUnknown_Release,
  1062.     (void *)NineAdapter9_GetAdapterIdentifier,
  1063.     (void *)NineAdapter9_CheckDeviceType,
  1064.     (void *)NineAdapter9_CheckDeviceFormat,
  1065.     (void *)NineAdapter9_CheckDeviceMultiSampleType,
  1066.     (void *)NineAdapter9_CheckDepthStencilMatch,
  1067.     (void *)NineAdapter9_CheckDeviceFormatConversion,
  1068.     (void *)NineAdapter9_GetDeviceCaps,
  1069.     (void *)NineAdapter9_CreateDevice,
  1070.     (void *)NineAdapter9_CreateDeviceEx
  1071. };
  1072.  
  1073. static const GUID *NineAdapter9_IIDs[] = {
  1074.     &IID_ID3D9Adapter,
  1075.     &IID_IUnknown,
  1076.     NULL
  1077. };
  1078.  
  1079. HRESULT
  1080. NineAdapter9_new( struct d3dadapter9_context *pCTX,
  1081.                   struct NineAdapter9 **ppOut )
  1082. {
  1083.     NINE_NEW(Adapter9, ppOut, FALSE, /* args */ pCTX);
  1084. }
  1085.