src/gallium/state_trackers/nine/adapter9.c

   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(AdapterFormat);
 208     bfmt = d3d9_to_pipe_format(BackBufferFormat);
 209     if (dfmt == PIPE_FORMAT_NONE || bfmt == PIPE_FORMAT_NONE) {
 210         DBG("Invalid Adapter/BackBufferFormat.\n");
 211         return D3DERR_NOTAVAILABLE;
 212     }
 213
 214     if (!screen->is_format_supported(screen, dfmt, PIPE_TEXTURE_2D, 1,
 215                                      PIPE_BIND_DISPLAY_TARGET |
 216                                      PIPE_BIND_SHARED) ||
 217         !screen->is_format_supported(screen, bfmt, PIPE_TEXTURE_2D, 1,
 218                                      PIPE_BIND_DISPLAY_TARGET |
 219                                      PIPE_BIND_SHARED)) {
 220         DBG("Unsupported Adapter/BackBufferFormat.\n");
 221         return D3DERR_NOTAVAILABLE;
 222     }
 223
 224     return D3D_OK;
 225 }
 226
 227 static INLINE boolean
 228 display_format( D3DFORMAT fmt,
 229                 boolean win )
 230 {
 231     /* http://msdn.microsoft.com/en-us/library/bb172558(v=VS.85).aspx#BackBuffer_or_Display_Formats */
 232     static const D3DFORMAT allowed[] = {
 233         D3DFMT_A2R10G10B10,
 234         D3DFMT_X8R8G8B8,
 235         D3DFMT_X1R5G5B5,
 236         D3DFMT_R5G6B5,
 237     };
 238     unsigned i;
 239
 240     if (fmt == D3DFMT_A2R10G10B10 && win) { return FALSE; }
 241
 242     for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) {
 243         if (fmt == allowed[i]) { return TRUE; }
 244     }
 245     return FALSE;
 246 }
 247
 248 HRESULT WINAPI
 249 NineAdapter9_CheckDeviceFormat( struct NineAdapter9 *This,
 250                                 D3DDEVTYPE DeviceType,
 251                                 D3DFORMAT AdapterFormat,
 252                                 DWORD Usage,
 253                                 D3DRESOURCETYPE RType,
 254                                 D3DFORMAT CheckFormat )
 255 {
 256     struct pipe_screen *screen;
 257     HRESULT hr;
 258     enum pipe_format pf;
 259     enum pipe_texture_target target;
 260     unsigned bind = 0;
 261
 262     /* Check adapter format. */
 263
 264     DBG("This=%p DeviceType=%s AdapterFormat=%s\n", This,
 265         nine_D3DDEVTYPE_to_str(DeviceType), d3dformat_to_string(AdapterFormat));
 266     DBG("Usage=%x RType=%u CheckFormat=%s\n", Usage, RType,
 267         d3dformat_to_string(CheckFormat));
 268
 269     user_assert(display_format(AdapterFormat, FALSE), D3DERR_INVALIDCALL);
 270
 271     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
 272     if (FAILED(hr))
 273         return hr;
 274     pf = d3d9_to_pipe_format(AdapterFormat);
 275     if (pf == PIPE_FORMAT_NONE ||
 276         !screen->is_format_supported(screen, pf, PIPE_TEXTURE_2D, 0,
 277                                      PIPE_BIND_DISPLAY_TARGET |
 278                                      PIPE_BIND_SHARED)) {
 279         DBG("AdapterFormat %s not available.\n",
 280             d3dformat_to_string(AdapterFormat));
 281         return D3DERR_NOTAVAILABLE;
 282     }
 283
 284     /* Check actual format. */
 285
 286     switch (RType) {
 287     case D3DRTYPE_SURFACE:       target = PIPE_TEXTURE_2D; break;
 288     case D3DRTYPE_TEXTURE:       target = PIPE_TEXTURE_2D; break;
 289     case D3DRTYPE_CUBETEXTURE:   target = PIPE_TEXTURE_CUBE; break;
 290     case D3DRTYPE_VOLUME:        target = PIPE_TEXTURE_3D; break;
 291     case D3DRTYPE_VOLUMETEXTURE: target = PIPE_TEXTURE_3D; break;
 292     case D3DRTYPE_VERTEXBUFFER:  target = PIPE_BUFFER; break;
 293     case D3DRTYPE_INDEXBUFFER:   target = PIPE_BUFFER; break;
 294     default:
 295         user_assert(0, D3DERR_INVALIDCALL);
 296     }
 297
 298     bind = 0;
 299     if (Usage & D3DUSAGE_RENDERTARGET) bind |= PIPE_BIND_RENDER_TARGET;
 300     if (Usage & D3DUSAGE_DEPTHSTENCIL) bind |= PIPE_BIND_DEPTH_STENCIL;
 301
 302     /* API hack because setting RT[0] to NULL is forbidden */
 303     if (CheckFormat == D3DFMT_NULL && bind == PIPE_BIND_RENDER_TARGET &&
 304         (RType == D3DRTYPE_SURFACE ||
 305          RType == D3DRTYPE_TEXTURE))
 306         return D3D_OK;
 307
 308     /* RESZ hack */
 309     if (CheckFormat == D3DFMT_RESZ && bind == PIPE_BIND_RENDER_TARGET &&
 310         RType == D3DRTYPE_SURFACE)
 311         return screen->get_param(screen, PIPE_CAP_MULTISAMPLE_Z_RESOLVE) ?
 312                D3D_OK : D3DERR_NOTAVAILABLE;
 313
 314     if (Usage & D3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING)
 315         bind |= PIPE_BIND_BLENDABLE;
 316
 317     if (Usage & D3DUSAGE_DMAP) {
 318         DBG("D3DUSAGE_DMAP not available\n");
 319         return D3DERR_NOTAVAILABLE; /* TODO: displacement mapping */
 320     }
 321
 322     switch (RType) {
 323     case D3DRTYPE_TEXTURE:       bind |= PIPE_BIND_SAMPLER_VIEW; break;
 324     case D3DRTYPE_CUBETEXTURE:   bind |= PIPE_BIND_SAMPLER_VIEW; break;
 325     case D3DRTYPE_VOLUMETEXTURE: bind |= PIPE_BIND_SAMPLER_VIEW; break;
 326     case D3DRTYPE_VERTEXBUFFER:  bind |= PIPE_BIND_VERTEX_BUFFER; break;
 327     case D3DRTYPE_INDEXBUFFER:   bind |= PIPE_BIND_INDEX_BUFFER; break;
 328     default:
 329         break;
 330     }
 331
 332
 333     pf = d3d9_to_pipe_format(CheckFormat);
 334     if (Usage & (D3DUSAGE_QUERY_SRGBREAD | D3DUSAGE_QUERY_SRGBWRITE))
 335         pf = util_format_srgb(pf);
 336
 337     if (pf == PIPE_FORMAT_NONE ||
 338         !screen->is_format_supported(screen, pf, target, 0, bind)) {
 339         DBG("NOT AVAILABLE\n");
 340         return D3DERR_NOTAVAILABLE;
 341     }
 342
 343     /* we support ATI1 and ATI2 hack only for 2D textures */
 344     if (RType != D3DRTYPE_TEXTURE && (CheckFormat == D3DFMT_ATI1 || CheckFormat == D3DFMT_ATI2))
 345         return D3DERR_NOTAVAILABLE;
 346     /* if (Usage & D3DUSAGE_NONSECURE) { don't know the implications of this } */
 347     /* if (Usage & D3DUSAGE_SOFTWAREPROCESSING) { we can always support this } */
 348
 349     if ((Usage & D3DUSAGE_AUTOGENMIPMAP) && !(bind & PIPE_BIND_SAMPLER_VIEW))
 350         return D3DOK_NOAUTOGEN;
 351     return D3D_OK;
 352 }
 353
 354 HRESULT WINAPI
 355 NineAdapter9_CheckDeviceMultiSampleType( struct NineAdapter9 *This,
 356                                          D3DDEVTYPE DeviceType,
 357                                          D3DFORMAT SurfaceFormat,
 358                                          BOOL Windowed,
 359                                          D3DMULTISAMPLE_TYPE MultiSampleType,
 360                                          DWORD *pQualityLevels )
 361 {
 362     struct pipe_screen *screen;
 363     HRESULT hr;
 364     enum pipe_format pf;
 365     unsigned bind;
 366
 367     DBG("This=%p DeviceType=%s SurfaceFormat=%s Windowed=%i MultiSampleType=%u "
 368         "pQualityLevels=%p\n", This, nine_D3DDEVTYPE_to_str(DeviceType),
 369         d3dformat_to_string(SurfaceFormat), Windowed, MultiSampleType,
 370         pQualityLevels);
 371
 372     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
 373     if (FAILED(hr))
 374         return hr;
 375
 376     pf = d3d9_to_pipe_format(SurfaceFormat);
 377     bind = util_format_is_depth_or_stencil(pf) ?
 378         PIPE_BIND_DEPTH_STENCIL : PIPE_BIND_RENDER_TARGET;
 379
 380     if (pf == PIPE_FORMAT_NONE ||
 381         !screen->is_format_supported(screen, pf, PIPE_TEXTURE_2D,
 382                                      MultiSampleType, bind)) {
 383         DBG("%s with %u samples not available.\n",
 384             d3dformat_to_string(SurfaceFormat), MultiSampleType);
 385         return D3DERR_NOTAVAILABLE;
 386     }
 387
 388     if (pQualityLevels)
 389         *pQualityLevels = 1; /* gallium doesn't have quality levels */
 390
 391     return D3D_OK;
 392 }
 393
 394 static INLINE boolean
 395 depth_stencil_format( D3DFORMAT fmt )
 396 {
 397     static D3DFORMAT allowed[] = {
 398         D3DFMT_D16_LOCKABLE,
 399         D3DFMT_D32,
 400         D3DFMT_D15S1,
 401         D3DFMT_D24S8,
 402         D3DFMT_D24X8,
 403         D3DFMT_D24X4S4,
 404         D3DFMT_D16,
 405         D3DFMT_D32F_LOCKABLE,
 406         D3DFMT_D24FS8,
 407         D3DFMT_D32_LOCKABLE
 408     };
 409     unsigned i;
 410
 411     for (i = 0; i < sizeof(allowed)/sizeof(D3DFORMAT); i++) {
 412         if (fmt == allowed[i]) { return TRUE; }
 413     }
 414     return FALSE;
 415 }
 416
 417 HRESULT WINAPI
 418 NineAdapter9_CheckDepthStencilMatch( struct NineAdapter9 *This,
 419                                      D3DDEVTYPE DeviceType,
 420                                      D3DFORMAT AdapterFormat,
 421                                      D3DFORMAT RenderTargetFormat,
 422                                      D3DFORMAT DepthStencilFormat )
 423 {
 424     struct pipe_screen *screen;
 425     enum pipe_format dfmt, bfmt, zsfmt;
 426     HRESULT hr;
 427
 428     DBG("This=%p DeviceType=%s AdapterFormat=%s "
 429         "RenderTargetFormat=%s DepthStencilFormat=%s\n", This,
 430         nine_D3DDEVTYPE_to_str(DeviceType), d3dformat_to_string(AdapterFormat),
 431         d3dformat_to_string(RenderTargetFormat),
 432         d3dformat_to_string(DepthStencilFormat));
 433
 434     user_assert(display_format(AdapterFormat, FALSE), D3DERR_NOTAVAILABLE);
 435     user_assert(depth_stencil_format(DepthStencilFormat), D3DERR_NOTAVAILABLE);
 436
 437     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
 438     if (FAILED(hr)) { return hr; }
 439
 440     dfmt = d3d9_to_pipe_format(AdapterFormat);
 441     bfmt = d3d9_to_pipe_format(RenderTargetFormat);
 442     if (RenderTargetFormat == D3DFMT_NULL)
 443         bfmt = dfmt;
 444     zsfmt = d3d9_to_pipe_format(DepthStencilFormat);
 445     if (dfmt == PIPE_FORMAT_NONE ||
 446         bfmt == PIPE_FORMAT_NONE ||
 447         zsfmt == PIPE_FORMAT_NONE) {
 448         return D3DERR_NOTAVAILABLE;
 449     }
 450
 451     if (!screen->is_format_supported(screen, dfmt, PIPE_TEXTURE_2D, 0,
 452                                      PIPE_BIND_DISPLAY_TARGET |
 453                                      PIPE_BIND_SHARED) ||
 454         !screen->is_format_supported(screen, bfmt, PIPE_TEXTURE_2D, 0,
 455                                      PIPE_BIND_RENDER_TARGET) ||
 456         !screen->is_format_supported(screen, zsfmt, PIPE_TEXTURE_2D, 0,
 457                                      PIPE_BIND_DEPTH_STENCIL)) {
 458         return D3DERR_NOTAVAILABLE;
 459     }
 460
 461     return D3D_OK;
 462 }
 463
 464 HRESULT WINAPI
 465 NineAdapter9_CheckDeviceFormatConversion( struct NineAdapter9 *This,
 466                                           D3DDEVTYPE DeviceType,
 467                                           D3DFORMAT SourceFormat,
 468                                           D3DFORMAT TargetFormat )
 469 {
 470     /* MSDN says this tests whether a certain backbuffer format can be used in
 471      * conjunction with a certain front buffer format. It's a little confusing
 472      * but some one wiser might be able to figure this one out. XXX */
 473     struct pipe_screen *screen;
 474     enum pipe_format dfmt, bfmt;
 475     HRESULT hr;
 476
 477     DBG("This=%p DeviceType=%s SourceFormat=%s TargetFormat=%s\n", This,
 478         nine_D3DDEVTYPE_to_str(DeviceType),
 479         d3dformat_to_string(SourceFormat), d3dformat_to_string(TargetFormat));
 480
 481     user_assert(backbuffer_format(TargetFormat, SourceFormat, FALSE),
 482                 D3DERR_NOTAVAILABLE);
 483
 484     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
 485     if (FAILED(hr)) { return hr; }
 486
 487     dfmt = d3d9_to_pipe_format(TargetFormat);
 488     bfmt = d3d9_to_pipe_format(SourceFormat);
 489     if (dfmt == PIPE_FORMAT_NONE || bfmt == PIPE_FORMAT_NONE) {
 490         return D3DERR_NOTAVAILABLE;
 491     }
 492     if (!screen->is_format_supported(screen, dfmt, PIPE_TEXTURE_2D, 1,
 493                                      PIPE_BIND_DISPLAY_TARGET |
 494                                      PIPE_BIND_SHARED) ||
 495         !screen->is_format_supported(screen, bfmt, PIPE_TEXTURE_2D, 1,
 496                                      PIPE_BIND_DISPLAY_TARGET |
 497                                      PIPE_BIND_SHARED)) {
 498         DBG("%s to %s not supported.\n",
 499             d3dformat_to_string(SourceFormat),
 500             d3dformat_to_string(TargetFormat));
 501         return D3DERR_NOTAVAILABLE;
 502     }
 503
 504     return D3D_OK;
 505 }
 506
 507 HRESULT WINAPI
 508 NineAdapter9_GetDeviceCaps( struct NineAdapter9 *This,
 509                             D3DDEVTYPE DeviceType,
 510                             D3DCAPS9 *pCaps )
 511 {
 512     struct pipe_screen *screen;
 513     HRESULT hr;
 514
 515     DBG("This=%p DeviceType=%s pCaps=%p\n", This,
 516         nine_D3DDEVTYPE_to_str(DeviceType), pCaps);
 517
 518     user_assert(pCaps, D3DERR_INVALIDCALL);
 519
 520     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
 521     if (FAILED(hr)) {
 522        DBG("Failed to get pipe_screen.\n");
 523        return hr;
 524     }
 525
 526 #define D3DPIPECAP(pcap, d3dcap) \
 527     (screen->get_param(screen, PIPE_CAP_##pcap) ? (d3dcap) : 0)
 528
 529 #define D3DNPIPECAP(pcap, d3dcap) \
 530     (screen->get_param(screen, PIPE_CAP_##pcap) ? 0 : (d3dcap))
 531
 532     pCaps->DeviceType = DeviceType;
 533
 534     pCaps->AdapterOrdinal = 0;
 535
 536     pCaps->Caps = 0;
 537
 538     pCaps->Caps2 = D3DCAPS2_CANMANAGERESOURCE |
 539                 /* D3DCAPS2_CANSHARERESOURCE | */
 540                 /* D3DCAPS2_CANCALIBRATEGAMMA | */
 541                    D3DCAPS2_DYNAMICTEXTURES |
 542                    D3DCAPS2_FULLSCREENGAMMA |
 543                    D3DCAPS2_CANAUTOGENMIPMAP;
 544
 545     /* Note: D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD just means the
 546      * backbuffer can be ARGB (instead of only XRGB) when we are fullscreen
 547      * and in discard mode. */
 548     pCaps->Caps3 = D3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD |
 549                    D3DCAPS3_COPY_TO_VIDMEM |
 550                    D3DCAPS3_COPY_TO_SYSTEMMEM |
 551                    D3DCAPS3_LINEAR_TO_SRGB_PRESENTATION;
 552
 553     pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_DEFAULT |
 554                                    D3DPRESENT_INTERVAL_ONE |
 555                                    D3DPRESENT_INTERVAL_TWO |
 556                                    D3DPRESENT_INTERVAL_THREE |
 557                                    D3DPRESENT_INTERVAL_FOUR |
 558                                    D3DPRESENT_INTERVAL_IMMEDIATE;
 559     pCaps->CursorCaps = D3DCURSORCAPS_COLOR | D3DCURSORCAPS_LOWRES;
 560
 561     pCaps->DevCaps = D3DDEVCAPS_CANBLTSYSTONONLOCAL |
 562                      D3DDEVCAPS_CANRENDERAFTERFLIP |
 563                      D3DDEVCAPS_DRAWPRIMITIVES2 |
 564                      D3DDEVCAPS_DRAWPRIMITIVES2EX |
 565                      D3DDEVCAPS_DRAWPRIMTLVERTEX |
 566                      D3DDEVCAPS_EXECUTESYSTEMMEMORY |
 567                      D3DDEVCAPS_EXECUTEVIDEOMEMORY |
 568                      D3DDEVCAPS_HWRASTERIZATION |
 569                      D3DDEVCAPS_HWTRANSFORMANDLIGHT |
 570                      /*D3DDEVCAPS_NPATCHES |*/
 571                      D3DDEVCAPS_PUREDEVICE |
 572                      /*D3DDEVCAPS_QUINTICRTPATCHES |*/
 573                      /*D3DDEVCAPS_RTPATCHES |*/
 574                      /*D3DDEVCAPS_RTPATCHHANDLEZERO |*/
 575                      /*D3DDEVCAPS_SEPARATETEXTUREMEMORIES |*/
 576                      /*D3DDEVCAPS_TEXTURENONLOCALVIDMEM |*/
 577                      D3DDEVCAPS_TEXTURESYSTEMMEMORY |
 578                      D3DDEVCAPS_TEXTUREVIDEOMEMORY |
 579                      D3DDEVCAPS_TLVERTEXSYSTEMMEMORY |
 580                      D3DDEVCAPS_TLVERTEXVIDEOMEMORY;
 581
 582     pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_MASKZ |
 583                                D3DPMISCCAPS_CULLNONE | /* XXX */
 584                                D3DPMISCCAPS_CULLCW |
 585                                D3DPMISCCAPS_CULLCCW |
 586                                D3DPMISCCAPS_COLORWRITEENABLE |
 587                                D3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
 588                                /*D3DPMISCCAPS_CLIPTLVERTS |*/
 589                                D3DPMISCCAPS_TSSARGTEMP |
 590                                D3DPMISCCAPS_BLENDOP |
 591                                D3DPIPECAP(INDEP_BLEND_ENABLE, D3DPMISCCAPS_INDEPENDENTWRITEMASKS) |
 592                                /*D3DPMISCCAPS_PERSTAGECONSTANT |*/
 593                                /*D3DPMISCCAPS_POSTBLENDSRGBCONVERT |*/ /* TODO */
 594                                D3DPMISCCAPS_FOGANDSPECULARALPHA |
 595                                D3DPIPECAP(BLEND_EQUATION_SEPARATE, D3DPMISCCAPS_SEPARATEALPHABLEND) |
 596                                D3DPIPECAP(MIXED_COLORBUFFER_FORMATS, D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS) |
 597                                D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING |
 598                                /*D3DPMISCCAPS_FOGVERTEXCLAMPED*/0;
 599     if (!screen->get_param(screen, PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION))
 600         pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_CLIPTLVERTS;
 601
 602     pCaps->RasterCaps =
 603         D3DPIPECAP(ANISOTROPIC_FILTER, D3DPRASTERCAPS_ANISOTROPY) |
 604         /*D3DPRASTERCAPS_COLORPERSPECTIVE |*/
 605         D3DPRASTERCAPS_DITHER |
 606         D3DPRASTERCAPS_DEPTHBIAS |
 607         /*D3DPRASTERCAPS_FOGRANGE |*/
 608         /*D3DPRASTERCAPS_FOGTABLE |*/
 609         /*D3DPRASTERCAPS_FOGVERTEX |*/
 610         D3DPRASTERCAPS_MIPMAPLODBIAS |
 611         D3DPRASTERCAPS_MULTISAMPLE_TOGGLE |
 612         D3DPRASTERCAPS_SCISSORTEST |
 613         D3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
 614         /*D3DPRASTERCAPS_WBUFFER |*/
 615         /*D3DPRASTERCAPS_WFOG |*/
 616         /*D3DPRASTERCAPS_ZBUFFERLESSHSR |*/
 617         /*D3DPRASTERCAPS_ZFOG |*/
 618         D3DPRASTERCAPS_ZTEST;
 619
 620     pCaps->ZCmpCaps = D3DPCMPCAPS_NEVER |
 621                       D3DPCMPCAPS_LESS |
 622                       D3DPCMPCAPS_EQUAL |
 623                       D3DPCMPCAPS_LESSEQUAL |
 624                       D3DPCMPCAPS_GREATER |
 625                       D3DPCMPCAPS_NOTEQUAL |
 626                       D3DPCMPCAPS_GREATEREQUAL |
 627                       D3DPCMPCAPS_ALWAYS;
 628
 629     pCaps->SrcBlendCaps = D3DPBLENDCAPS_ZERO |
 630                           D3DPBLENDCAPS_ONE |
 631                           D3DPBLENDCAPS_SRCCOLOR |
 632                           D3DPBLENDCAPS_INVSRCCOLOR |
 633                           D3DPBLENDCAPS_SRCALPHA |
 634                           D3DPBLENDCAPS_INVSRCALPHA |
 635                           D3DPBLENDCAPS_DESTALPHA |
 636                           D3DPBLENDCAPS_INVDESTALPHA |
 637                           D3DPBLENDCAPS_DESTCOLOR |
 638                           D3DPBLENDCAPS_INVDESTCOLOR |
 639                           D3DPBLENDCAPS_SRCALPHASAT |
 640                           D3DPBLENDCAPS_BOTHSRCALPHA |
 641                           D3DPBLENDCAPS_BOTHINVSRCALPHA |
 642                           D3DPBLENDCAPS_BLENDFACTOR |
 643                           D3DPIPECAP(MAX_DUAL_SOURCE_RENDER_TARGETS,
 644                               D3DPBLENDCAPS_INVSRCCOLOR2 |
 645                               D3DPBLENDCAPS_SRCCOLOR2);
 646
 647     pCaps->DestBlendCaps = pCaps->SrcBlendCaps;
 648
 649     pCaps->AlphaCmpCaps = D3DPCMPCAPS_LESS |
 650                           D3DPCMPCAPS_EQUAL |
 651                           D3DPCMPCAPS_LESSEQUAL |
 652                           D3DPCMPCAPS_GREATER |
 653                           D3DPCMPCAPS_NOTEQUAL |
 654                           D3DPCMPCAPS_GREATEREQUAL |
 655                           D3DPCMPCAPS_ALWAYS;
 656
 657     /* FLAT caps not legal for D3D9. */
 658     pCaps->ShadeCaps = D3DPSHADECAPS_COLORGOURAUDRGB |
 659                        D3DPSHADECAPS_SPECULARGOURAUDRGB |
 660                        D3DPSHADECAPS_ALPHAGOURAUDBLEND |
 661                        D3DPSHADECAPS_FOGGOURAUD;
 662
 663     pCaps->TextureCaps =
 664         D3DPTEXTURECAPS_ALPHA |
 665         D3DPTEXTURECAPS_ALPHAPALETTE |
 666         D3DPTEXTURECAPS_PERSPECTIVE |
 667         D3DPTEXTURECAPS_PROJECTED |
 668         /*D3DPTEXTURECAPS_TEXREPEATNOTSCALEDBYSIZE |*/
 669         D3DPTEXTURECAPS_CUBEMAP |
 670         D3DPTEXTURECAPS_VOLUMEMAP |
 671         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_POW2) |
 672         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_NONPOW2CONDITIONAL) |
 673         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_CUBEMAP_POW2) |
 674         D3DNPIPECAP(NPOT_TEXTURES, D3DPTEXTURECAPS_VOLUMEMAP_POW2) |
 675         D3DPIPECAP(MAX_TEXTURE_2D_LEVELS, D3DPTEXTURECAPS_MIPMAP) |
 676         D3DPIPECAP(MAX_TEXTURE_3D_LEVELS, D3DPTEXTURECAPS_MIPVOLUMEMAP) |
 677         D3DPIPECAP(MAX_TEXTURE_CUBE_LEVELS, D3DPTEXTURECAPS_MIPCUBEMAP);
 678
 679     pCaps->TextureFilterCaps =
 680         D3DPTFILTERCAPS_MINFPOINT |
 681         D3DPTFILTERCAPS_MINFLINEAR |
 682         D3DPIPECAP(ANISOTROPIC_FILTER, D3DPTFILTERCAPS_MINFANISOTROPIC) |
 683         /*D3DPTFILTERCAPS_MINFPYRAMIDALQUAD |*/
 684         /*D3DPTFILTERCAPS_MINFGAUSSIANQUAD |*/
 685         D3DPTFILTERCAPS_MIPFPOINT |
 686         D3DPTFILTERCAPS_MIPFLINEAR |
 687         D3DPTFILTERCAPS_MAGFPOINT |
 688         D3DPTFILTERCAPS_MAGFLINEAR |
 689         D3DPIPECAP(ANISOTROPIC_FILTER, D3DPTFILTERCAPS_MAGFANISOTROPIC) |
 690         /*D3DPTFILTERCAPS_MAGFPYRAMIDALQUAD |*/
 691         /*D3DPTFILTERCAPS_MAGFGAUSSIANQUAD*/0;
 692
 693     pCaps->CubeTextureFilterCaps = pCaps->TextureFilterCaps;
 694     pCaps->VolumeTextureFilterCaps = pCaps->TextureFilterCaps;
 695
 696     pCaps->TextureAddressCaps =
 697         D3DPTADDRESSCAPS_BORDER |
 698         D3DPTADDRESSCAPS_INDEPENDENTUV |
 699         D3DPTADDRESSCAPS_WRAP |
 700         D3DPTADDRESSCAPS_MIRROR |
 701         D3DPTADDRESSCAPS_CLAMP |
 702         D3DPIPECAP(TEXTURE_MIRROR_CLAMP, D3DPTADDRESSCAPS_MIRRORONCE);
 703
 704     pCaps->VolumeTextureAddressCaps = pCaps->TextureAddressCaps;
 705
 706     pCaps->LineCaps =
 707         D3DLINECAPS_ALPHACMP |
 708         D3DLINECAPS_BLEND |
 709         D3DLINECAPS_TEXTURE |
 710         D3DLINECAPS_ZTEST |
 711         D3DLINECAPS_FOG;
 712     if (screen->get_paramf(screen, PIPE_CAPF_MAX_LINE_WIDTH_AA) > 0.0) {
 713         pCaps->LineCaps |= D3DLINECAPS_ANTIALIAS;
 714     }
 715
 716     pCaps->MaxTextureWidth =
 717         1 << (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS) - 1);
 718     pCaps->MaxTextureHeight = pCaps->MaxTextureWidth;
 719     pCaps->MaxVolumeExtent =
 720         1 << (screen->get_param(screen, PIPE_CAP_MAX_TEXTURE_3D_LEVELS) - 1);
 721     /* XXX values from wine */
 722     pCaps->MaxTextureRepeat = 32768;
 723     pCaps->MaxTextureAspectRatio = pCaps->MaxTextureWidth;
 724
 725     pCaps->MaxAnisotropy =
 726         (DWORD)screen->get_paramf(screen, PIPE_CAPF_MAX_TEXTURE_ANISOTROPY);
 727
 728     pCaps->MaxVertexW = 1.0f; /* XXX */
 729     pCaps->GuardBandLeft = screen->get_paramf(screen,
 730                                               PIPE_CAPF_GUARD_BAND_LEFT);
 731     pCaps->GuardBandTop = screen->get_paramf(screen,
 732                                              PIPE_CAPF_GUARD_BAND_TOP);
 733     pCaps->GuardBandRight = screen->get_paramf(screen,
 734                                                PIPE_CAPF_GUARD_BAND_RIGHT);
 735     pCaps->GuardBandBottom = screen->get_paramf(screen,
 736                                                 PIPE_CAPF_GUARD_BAND_BOTTOM);
 737     pCaps->ExtentsAdjust = 0.0f;
 738
 739     pCaps->StencilCaps =
 740         D3DSTENCILCAPS_KEEP |
 741         D3DSTENCILCAPS_ZERO |
 742         D3DSTENCILCAPS_REPLACE |
 743         D3DSTENCILCAPS_INCRSAT |
 744         D3DSTENCILCAPS_DECRSAT |
 745         D3DSTENCILCAPS_INVERT |
 746         D3DSTENCILCAPS_INCR |
 747         D3DSTENCILCAPS_DECR |
 748         D3DPIPECAP(TWO_SIDED_STENCIL, D3DSTENCILCAPS_TWOSIDED);
 749
 750     pCaps->FVFCaps =
 751         (D3DFVFCAPS_TEXCOORDCOUNTMASK & 0xff) |
 752         /*D3DFVFCAPS_DONOTSTRIPELEMENTS |*/
 753         D3DFVFCAPS_PSIZE;
 754
 755     /* XXX: Some of these are probably not in SM2.0 so cap them when I figure
 756      * them out. For now leave them all enabled. */
 757     pCaps->TextureOpCaps = D3DTEXOPCAPS_DISABLE |
 758                            D3DTEXOPCAPS_SELECTARG1 |
 759                            D3DTEXOPCAPS_SELECTARG2 |
 760                            D3DTEXOPCAPS_MODULATE |
 761                            D3DTEXOPCAPS_MODULATE2X |
 762                            D3DTEXOPCAPS_MODULATE4X |
 763                            D3DTEXOPCAPS_ADD |
 764                            D3DTEXOPCAPS_ADDSIGNED |
 765                            D3DTEXOPCAPS_ADDSIGNED2X |
 766                            D3DTEXOPCAPS_SUBTRACT |
 767                            D3DTEXOPCAPS_ADDSMOOTH |
 768                            D3DTEXOPCAPS_BLENDDIFFUSEALPHA |
 769                            D3DTEXOPCAPS_BLENDTEXTUREALPHA |
 770                            D3DTEXOPCAPS_BLENDFACTORALPHA |
 771                            D3DTEXOPCAPS_BLENDTEXTUREALPHAPM |
 772                            D3DTEXOPCAPS_BLENDCURRENTALPHA |
 773                            D3DTEXOPCAPS_PREMODULATE |
 774                            D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
 775                            D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
 776                            D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
 777                            D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA |
 778                            D3DTEXOPCAPS_BUMPENVMAP |
 779                            D3DTEXOPCAPS_BUMPENVMAPLUMINANCE |
 780                            D3DTEXOPCAPS_DOTPRODUCT3 |
 781                            D3DTEXOPCAPS_MULTIPLYADD |
 782                            D3DTEXOPCAPS_LERP;
 783
 784     pCaps->MaxTextureBlendStages = 8; /* XXX wine */
 785         (DWORD)screen->get_param(screen, PIPE_CAP_BLEND_EQUATION_SEPARATE);
 786     pCaps->MaxSimultaneousTextures = screen->get_shader_param(screen,
 787         PIPE_SHADER_FRAGMENT, PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS);
 788     if (pCaps->MaxSimultaneousTextures > NINE_MAX_SAMPLERS_PS)
 789         pCaps->MaxSimultaneousTextures = NINE_MAX_SAMPLERS_PS;
 790
 791     pCaps->VertexProcessingCaps = D3DVTXPCAPS_TEXGEN |
 792                                   /*D3DVTXPCAPS_TEXGEN_SPHEREMAP |*/
 793                                   D3DVTXPCAPS_MATERIALSOURCE7 |
 794                                   D3DVTXPCAPS_DIRECTIONALLIGHTS |
 795                                   D3DVTXPCAPS_POSITIONALLIGHTS |
 796                                   D3DVTXPCAPS_LOCALVIEWER |
 797                                   D3DVTXPCAPS_TWEENING |
 798                                   /*D3DVTXPCAPS_NO_TEXGEN_NONLOCALVIEWER*/0;
 799
 800     pCaps->MaxActiveLights = NINE_MAX_LIGHTS_ACTIVE; /* like GL_LIGHTi */
 801     pCaps->MaxUserClipPlanes = PIPE_MAX_CLIP_PLANES;
 802     pCaps->MaxVertexBlendMatrices = 4; /* 1 vec4 BLENDWEIGHT/INDICES input */
 803     pCaps->MaxVertexBlendMatrixIndex = 7; /* D3DTS_WORLDMATRIX(0..7) */
 804
 805     pCaps->MaxPointSize = screen->get_paramf(screen, PIPE_CAPF_MAX_POINT_WIDTH);
 806
 807     pCaps->MaxPrimitiveCount = 0xFFFFF; /* <- wine, really 0xFFFFFFFF; */
 808     pCaps->MaxVertexIndex = 0xFFFFF; /* <- wine, really 0xFFFFFFFF */
 809     pCaps->MaxStreams =
 810         _min(screen->get_shader_param(screen,
 811                  PIPE_SHADER_VERTEX, PIPE_SHADER_CAP_MAX_INPUTS),
 812              16);
 813
 814     pCaps->MaxStreamStride = screen->get_param(screen,
 815             PIPE_CAP_MAX_VERTEX_ATTRIB_STRIDE);
 816
 817     pCaps->VertexShaderVersion = D3DVS_VERSION(3,0);
 818
 819     /* VS 2 as well as 3.0 supports a minimum of 256 consts.
 820      * Wine and d3d9 drivers for dx1x hw advertise 256. Just as them,
 821      * advertise 256. Problem is with hw that can only do 256, because
 822      * we need take a few slots for boolean and integer constants. For these
 823      * we'll have to fail later if they use complex shaders. */
 824     pCaps->MaxVertexShaderConst = NINE_MAX_CONST_F;
 825
 826     pCaps->PixelShaderVersion = D3DPS_VERSION(3,0);
 827     pCaps->PixelShader1xMaxValue = 8.0f; /* XXX: wine */
 828
 829     pCaps->DevCaps2 = D3DDEVCAPS2_STREAMOFFSET |
 830                       D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET |
 831                       D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES |
 832                       /*D3DDEVCAPS2_DMAPNPATCH |*/
 833                       /*D3DDEVCAPS2_ADAPTIVETESSRTPATCH |*/
 834                       /*D3DDEVCAPS2_ADAPTIVETESSNPATCH |*/
 835                       /*D3DDEVCAPS2_PRESAMPLEDDMAPNPATCH*/0;
 836
 837     pCaps->MasterAdapterOrdinal = 0;
 838     pCaps->AdapterOrdinalInGroup = 0;
 839     pCaps->NumberOfAdaptersInGroup = 1;
 840
 841     /* Undocumented ? */
 842     pCaps->MaxNpatchTessellationLevel = 0.0f;
 843     pCaps->Reserved5 = 0;
 844
 845     /* XXX: use is_format_supported */
 846     pCaps->DeclTypes = D3DDTCAPS_UBYTE4 |
 847                        D3DDTCAPS_UBYTE4N |
 848                        D3DDTCAPS_SHORT2N |
 849                        D3DDTCAPS_SHORT4N |
 850                        D3DDTCAPS_USHORT2N |
 851                        D3DDTCAPS_USHORT4N |
 852                        D3DDTCAPS_UDEC3 |
 853                        D3DDTCAPS_DEC3N |
 854                        D3DDTCAPS_FLOAT16_2 |
 855                        D3DDTCAPS_FLOAT16_4;
 856
 857     pCaps->NumSimultaneousRTs =
 858         screen->get_param(screen, PIPE_CAP_MAX_RENDER_TARGETS);
 859     if (pCaps->NumSimultaneousRTs > NINE_MAX_SIMULTANEOUS_RENDERTARGETS)
 860         pCaps->NumSimultaneousRTs = NINE_MAX_SIMULTANEOUS_RENDERTARGETS;
 861
 862     pCaps->StretchRectFilterCaps = D3DPTFILTERCAPS_MINFPOINT |
 863                                    D3DPTFILTERCAPS_MINFLINEAR |
 864                                    D3DPTFILTERCAPS_MAGFPOINT |
 865                                    D3DPTFILTERCAPS_MAGFLINEAR;
 866
 867
 868     pCaps->VS20Caps.Caps = D3DVS20CAPS_PREDICATION;
 869     pCaps->VS20Caps.DynamicFlowControlDepth = /* XXX is this dynamic ? */
 870         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
 871                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
 872     pCaps->VS20Caps.NumTemps =
 873         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
 874                                  PIPE_SHADER_CAP_MAX_TEMPS);
 875     pCaps->VS20Caps.StaticFlowControlDepth = /* XXX is this static ? */
 876         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
 877                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
 878
 879     /* also check for values < 0, because get_shader_param may return unsigned */
 880     if (pCaps->VS20Caps.DynamicFlowControlDepth > D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH
 881         || pCaps->VS20Caps.DynamicFlowControlDepth < 0)
 882         pCaps->VS20Caps.DynamicFlowControlDepth = D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH;
 883     if (pCaps->VS20Caps.StaticFlowControlDepth > D3DVS20_MAX_STATICFLOWCONTROLDEPTH
 884         || pCaps->VS20Caps.StaticFlowControlDepth < 0)
 885         pCaps->VS20Caps.StaticFlowControlDepth = D3DVS20_MAX_STATICFLOWCONTROLDEPTH;
 886     if (pCaps->VS20Caps.NumTemps > D3DVS20_MAX_NUMTEMPS)
 887         pCaps->VS20Caps.NumTemps = D3DVS20_MAX_NUMTEMPS;
 888     assert(pCaps->VS20Caps.DynamicFlowControlDepth >= D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH);
 889     assert(pCaps->VS20Caps.StaticFlowControlDepth >= D3DVS20_MIN_STATICFLOWCONTROLDEPTH);
 890     assert(pCaps->VS20Caps.NumTemps >= D3DVS20_MIN_NUMTEMPS);
 891
 892
 893     pCaps->PS20Caps.Caps = D3DPS20CAPS_ARBITRARYSWIZZLE |
 894                            D3DPS20CAPS_GRADIENTINSTRUCTIONS |
 895                            D3DPS20CAPS_PREDICATION;
 896     if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 897                                  PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS) ==
 898         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 899                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS))
 900         pCaps->PS20Caps.Caps |= D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
 901     if (screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 902                                  PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS) ==
 903         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 904                                  PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS))
 905         pCaps->PS20Caps.Caps |= D3DPS20CAPS_NODEPENDENTREADLIMIT;
 906     pCaps->PS20Caps.DynamicFlowControlDepth = /* XXX is this dynamic ? */
 907         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 908                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
 909     pCaps->PS20Caps.NumTemps =
 910         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 911                                  PIPE_SHADER_CAP_MAX_TEMPS);
 912     pCaps->PS20Caps.StaticFlowControlDepth =  /* XXX is this static ? */
 913         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 914                                  PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH);
 915     pCaps->PS20Caps.NumInstructionSlots =
 916         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 917                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
 918
 919     if (pCaps->PS20Caps.DynamicFlowControlDepth > D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH
 920         || pCaps->PS20Caps.DynamicFlowControlDepth < 0)
 921         pCaps->PS20Caps.DynamicFlowControlDepth = D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH;
 922     if (pCaps->PS20Caps.StaticFlowControlDepth > D3DPS20_MAX_STATICFLOWCONTROLDEPTH
 923         || pCaps->PS20Caps.StaticFlowControlDepth < 0)
 924         pCaps->PS20Caps.StaticFlowControlDepth = D3DPS20_MAX_STATICFLOWCONTROLDEPTH;
 925     if (pCaps->PS20Caps.NumTemps > D3DPS20_MAX_NUMTEMPS)
 926         pCaps->PS20Caps.NumTemps = D3DPS20_MAX_NUMTEMPS;
 927     if (pCaps->PS20Caps.NumInstructionSlots > D3DPS20_MAX_NUMINSTRUCTIONSLOTS)
 928         pCaps->PS20Caps.NumInstructionSlots = D3DPS20_MAX_NUMINSTRUCTIONSLOTS;
 929     assert(pCaps->PS20Caps.DynamicFlowControlDepth >= D3DPS20_MIN_DYNAMICFLOWCONTROLDEPTH);
 930     assert(pCaps->PS20Caps.StaticFlowControlDepth >= D3DPS20_MIN_STATICFLOWCONTROLDEPTH);
 931     assert(pCaps->PS20Caps.NumTemps >= D3DPS20_MIN_NUMTEMPS);
 932     assert(pCaps->PS20Caps.NumInstructionSlots >= D3DPS20_MIN_NUMINSTRUCTIONSLOTS);
 933
 934
 935     if (screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
 936                                  PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS))
 937         pCaps->VertexTextureFilterCaps = pCaps->TextureFilterCaps &
 938             ~(D3DPTFILTERCAPS_MIPFPOINT |
 939               D3DPTFILTERCAPS_MIPFPOINT); /* XXX */
 940     else
 941         pCaps->VertexTextureFilterCaps = 0;
 942
 943     pCaps->MaxVertexShader30InstructionSlots =
 944         screen->get_shader_param(screen, PIPE_SHADER_VERTEX,
 945                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
 946     pCaps->MaxPixelShader30InstructionSlots =
 947         screen->get_shader_param(screen, PIPE_SHADER_FRAGMENT,
 948                                  PIPE_SHADER_CAP_MAX_INSTRUCTIONS);
 949     if (pCaps->MaxVertexShader30InstructionSlots > D3DMAX30SHADERINSTRUCTIONS)
 950         pCaps->MaxVertexShader30InstructionSlots = D3DMAX30SHADERINSTRUCTIONS;
 951     if (pCaps->MaxPixelShader30InstructionSlots > D3DMAX30SHADERINSTRUCTIONS)
 952         pCaps->MaxPixelShader30InstructionSlots = D3DMAX30SHADERINSTRUCTIONS;
 953     assert(pCaps->MaxVertexShader30InstructionSlots >= D3DMIN30SHADERINSTRUCTIONS);
 954     assert(pCaps->MaxPixelShader30InstructionSlots >= D3DMIN30SHADERINSTRUCTIONS);
 955
 956     /* 65535 is required, advertise more for GPUs with >= 2048 instruction slots */
 957     pCaps->MaxVShaderInstructionsExecuted = MAX2(65535, pCaps->MaxVertexShader30InstructionSlots * 32);
 958     pCaps->MaxPShaderInstructionsExecuted = MAX2(65535, pCaps->MaxPixelShader30InstructionSlots * 32);
 959
 960     if (debug_get_bool_option("NINE_DUMP_CAPS", FALSE))
 961         nine_dump_D3DCAPS9(DBG_CHANNEL, pCaps);
 962
 963     return D3D_OK;
 964 }
 965
 966 HRESULT WINAPI
 967 NineAdapter9_CreateDevice( struct NineAdapter9 *This,
 968                            UINT RealAdapter,
 969                            D3DDEVTYPE DeviceType,
 970                            HWND hFocusWindow,
 971                            DWORD BehaviorFlags,
 972                            D3DPRESENT_PARAMETERS *pPresentationParameters,
 973                            IDirect3D9 *pD3D9,
 974                            ID3DPresentGroup *pPresentationGroup,
 975                            IDirect3DDevice9 **ppReturnedDeviceInterface )
 976 {
 977     struct pipe_screen *screen;
 978     D3DDEVICE_CREATION_PARAMETERS params;
 979     D3DCAPS9 caps;
 980     int major, minor;
 981     HRESULT hr;
 982
 983     DBG("This=%p RealAdapter=%u DeviceType=%s hFocusWindow=%p "
 984         "BehaviourFlags=%x " "pD3D9=%p pPresentationGroup=%p "
 985         "ppReturnedDeviceInterface=%p\n", This,
 986         RealAdapter, nine_D3DDEVTYPE_to_str(DeviceType), hFocusWindow,
 987         BehaviorFlags, pD3D9, pPresentationGroup, ppReturnedDeviceInterface);
 988
 989     ID3DPresentGroup_GetVersion(pPresentationGroup, &major, &minor);
 990     if (major != 1) {
 991         ERR("Doesn't support the ID3DPresentGroup version %d %d. Expected 1\n",
 992             major, minor);
 993         return D3DERR_NOTAVAILABLE;
 994     }
 995
 996     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
 997     if (FAILED(hr)) {
 998         DBG("Failed to get pipe_screen.\n");
 999         return hr;
1000     }
1001
1002     hr = NineAdapter9_GetDeviceCaps(This, DeviceType, &caps);
1003     if (FAILED(hr)) {
1004         DBG("Failed to get device caps.\n");
1005         return hr;
1006     }
1007
1008     params.AdapterOrdinal = RealAdapter;
1009     params.DeviceType = DeviceType;
1010     params.hFocusWindow = hFocusWindow;
1011     params.BehaviorFlags = BehaviorFlags;
1012
1013     hr = NineDevice9_new(screen, &params, &caps, pPresentationParameters,
1014                          pD3D9, pPresentationGroup, This->ctx, FALSE, NULL,
1015                          (struct NineDevice9 **)ppReturnedDeviceInterface);
1016     if (FAILED(hr)) {
1017         DBG("Failed to create device.\n");
1018         return hr;
1019     }
1020     DBG("NineDevice9 created successfully.\n");
1021
1022     return D3D_OK;
1023 }
1024
1025 HRESULT WINAPI
1026 NineAdapter9_CreateDeviceEx( struct NineAdapter9 *This,
1027                              UINT RealAdapter,
1028                              D3DDEVTYPE DeviceType,
1029                              HWND hFocusWindow,
1030                              DWORD BehaviorFlags,
1031                              D3DPRESENT_PARAMETERS *pPresentationParameters,
1032                              D3DDISPLAYMODEEX *pFullscreenDisplayMode,
1033                              IDirect3D9Ex *pD3D9Ex,
1034                              ID3DPresentGroup *pPresentationGroup,
1035                              IDirect3DDevice9Ex **ppReturnedDeviceInterface )
1036 {
1037     struct pipe_screen *screen;
1038     D3DDEVICE_CREATION_PARAMETERS params;
1039     D3DCAPS9 caps;
1040     int major, minor;
1041     HRESULT hr;
1042
1043     DBG("This=%p RealAdapter=%u DeviceType=%s hFocusWindow=%p "
1044         "BehaviourFlags=%x " "pD3D9Ex=%p pPresentationGroup=%p "
1045         "ppReturnedDeviceInterface=%p\n", This,
1046         RealAdapter, nine_D3DDEVTYPE_to_str(DeviceType), hFocusWindow,
1047         BehaviorFlags, pD3D9Ex, pPresentationGroup, ppReturnedDeviceInterface);
1048
1049     ID3DPresentGroup_GetVersion(pPresentationGroup, &major, &minor);
1050     if (major != 1) {
1051         ERR("Doesn't support the ID3DPresentGroup version %d %d. Expected 1\n",
1052             major, minor);
1053         return D3DERR_NOTAVAILABLE;
1054     }
1055
1056     hr = NineAdapter9_GetScreen(This, DeviceType, &screen);
1057     if (FAILED(hr)) {
1058         DBG("Failed to get pipe_screen.\n");
1059         return hr;
1060     }
1061
1062     hr = NineAdapter9_GetDeviceCaps(This, DeviceType, &caps);
1063     if (FAILED(hr)) {
1064         DBG("Failed to get device caps.\n");
1065         return hr;
1066     }
1067
1068     params.AdapterOrdinal = RealAdapter;
1069     params.DeviceType = DeviceType;
1070     params.hFocusWindow = hFocusWindow;
1071     params.BehaviorFlags = BehaviorFlags;
1072
1073     hr = NineDevice9Ex_new(screen, &params, &caps, pPresentationParameters,
1074                            pFullscreenDisplayMode,
1075                            pD3D9Ex, pPresentationGroup, This->ctx,
1076                            (struct NineDevice9Ex **)ppReturnedDeviceInterface);
1077     if (FAILED(hr)) {
1078         DBG("Failed to create device.\n");
1079         return hr;
1080     }
1081     DBG("NineDevice9Ex created successfully.\n");
1082
1083     return D3D_OK;
1084 }
1085
1086 ID3DAdapter9Vtbl NineAdapter9_vtable = {
1087     (void *)NineUnknown_QueryInterface,
1088     (void *)NineUnknown_AddRef,
1089     (void *)NineUnknown_Release,
1090     (void *)NineAdapter9_GetAdapterIdentifier,
1091     (void *)NineAdapter9_CheckDeviceType,
1092     (void *)NineAdapter9_CheckDeviceFormat,
1093     (void *)NineAdapter9_CheckDeviceMultiSampleType,
1094     (void *)NineAdapter9_CheckDepthStencilMatch,
1095     (void *)NineAdapter9_CheckDeviceFormatConversion,
1096     (void *)NineAdapter9_GetDeviceCaps,
1097     (void *)NineAdapter9_CreateDevice,
1098     (void *)NineAdapter9_CreateDeviceEx
1099 };
1100
1101 static const GUID *NineAdapter9_IIDs[] = {
1102     &IID_ID3D9Adapter,
1103     &IID_IUnknown,
1104     NULL
1105 };
1106
1107 HRESULT
1108 NineAdapter9_new( struct d3dadapter9_context *pCTX,
1109                   struct NineAdapter9 **ppOut )
1110 {
1111     NINE_NEW(Adapter9, ppOut, FALSE, /* args */ pCTX);
1112 }