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