Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 5564 | serge | 1 | /* |
| 2 | * Copyright 2011 Joakim Sindholt |
||
| 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, ¶ms, &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, ¶ms, &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 | } |