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