?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Add warn trace for INVALIDCALL case in CheckDeviceType.
[wine/hacks.git] / dlls / wined3d / directx.c
blob0413520a21da4ac9c63907bfee4e50295f45bd01
1 /*
2 * IWineD3D implementation
3 *
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2003-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 /* Compile time diagnostics: */
25
26 /* Uncomment this to force only a single display mode to be exposed: */
27 /*#define DEBUG_SINGLE_MODE*/
28
29
30 #include "config.h"
31 #include "wined3d_private.h"
32
33 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
34 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
35 #define GLINFO_LOCATION This->gl_info
36
37 /**********************************************************
38 * Utility functions follow
39 **********************************************************/
40
41 /* x11drv GDI escapes */
42 #define X11DRV_ESCAPE 6789
43 enum x11drv_escape_codes
44 {
45 X11DRV_GET_DISPLAY, /* get X11 display for a DC */
46 X11DRV_GET_DRAWABLE, /* get current drawable for a DC */
47 X11DRV_GET_FONT, /* get current X font for a DC */
48 };
49
50 /* retrieve the X display to use on a given DC */
51 inline static Display *get_display( HDC hdc )
52 {
53 Display *display;
54 enum x11drv_escape_codes escape = X11DRV_GET_DISPLAY;
55
56 if (!ExtEscape( hdc, X11DRV_ESCAPE, sizeof(escape), (LPCSTR)&escape,
57 sizeof(display), (LPSTR)&display )) display = NULL;
58 return display;
59 }
60
61 /* lookup tables */
62 int minLookup[MAX_LOOKUPS];
63 int maxLookup[MAX_LOOKUPS];
64 DWORD *stateLookup[MAX_LOOKUPS];
65
66 DWORD minMipLookup[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1];
67
68
69 typedef struct _WineD3D_GLContext {
70 GLXContext glCtx;
71 Display* display;
72 LONG ref;
73 } WineD3D_Context;
74
75
76 /**
77 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created
78 * ie there is no GL Context - Get a default rendering context to enable the
79 * function query some info from GL
80 */
81 static WineD3D_Context* WineD3D_CreateFakeGLContext(void) {
82 static WineD3D_Context ctx;
83 WineD3D_Context* ret = NULL;
84
85 if (glXGetCurrentContext() == NULL) {
86 BOOL gotContext = FALSE;
87 BOOL created = FALSE;
88 XVisualInfo template;
89 HDC device_context;
90 Visual* visual;
91 BOOL failed = FALSE;
92 int num;
93 XVisualInfo *visInfo;
94 Drawable drawable;
95 XWindowAttributes win_attr;
96 TRACE_(d3d_caps)("Creating Fake GL Context\n");
97
98 drawable = (Drawable) GetPropA(GetDesktopWindow(), "__wine_x11_whole_window");
99
100 /* Get the display */
101 device_context = GetDC(0);
102 ctx.display = get_display(device_context);
103 ReleaseDC(0, device_context);
104
105 /* Get the X visual */
106 ENTER_GL();
107 if (XGetWindowAttributes(ctx.display, drawable, &win_attr)) {
108 visual = win_attr.visual;
109 } else {
110 visual = DefaultVisual(ctx.display, DefaultScreen(ctx.display));
111 }
112 template.visualid = XVisualIDFromVisual(visual);
113 visInfo = XGetVisualInfo(ctx.display, VisualIDMask, &template, &num);
114 if (visInfo == NULL) {
115 LEAVE_GL();
116 WARN_(d3d_caps)("Error creating visual info for capabilities initialization\n");
117 failed = TRUE;
118 }
119
120 /* Create a GL context */
121 if (!failed) {
122 ctx.glCtx = glXCreateContext(ctx.display, visInfo, NULL, GL_TRUE);
123 XFree( visInfo );
124
125 if (ctx.glCtx == NULL) {
126 LEAVE_GL();
127 WARN_(d3d_caps)("Error creating default context for capabilities initialization\n");
128 failed = TRUE;
129 }
130 }
131
132 /* Make it the current GL context */
133 if (!failed && glXMakeCurrent(ctx.display, drawable, ctx.glCtx) == False) {
134 glXDestroyContext(ctx.display, ctx.glCtx);
135 LEAVE_GL();
136 WARN_(d3d_caps)("Error setting default context as current for capabilities initialization\n");
137 failed = TRUE;
138 }
139
140 /* It worked! Wow... */
141 if (!failed) {
142 gotContext = TRUE;
143 created = TRUE;
144 ret = &ctx;
145 } else {
146 ret = NULL;
147 }
148
149 } else {
150 if (ctx.ref > 0) ret = &ctx;
151 }
152
153 if (NULL != ret) InterlockedIncrement(&ret->ref);
154 return ret;
155 }
156
157 static void WineD3D_ReleaseFakeGLContext(WineD3D_Context* ctx) {
158 /* If we created a dummy context, throw it away */
159 if (NULL != ctx) {
160 if (0 == InterlockedDecrement(&ctx->ref)) {
161 glXMakeCurrent(ctx->display, None, NULL);
162 glXDestroyContext(ctx->display, ctx->glCtx);
163 ctx->display = NULL;
164 ctx->glCtx = NULL;
165 LEAVE_GL();
166 }
167 }
168 }
169
170 /**********************************************************
171 * IUnknown parts follows
172 **********************************************************/
173
174 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
175 {
176 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
177
178 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
179 if (IsEqualGUID(riid, &IID_IUnknown)
180 || IsEqualGUID(riid, &IID_IWineD3DBase)
181 || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
182 IUnknown_AddRef(iface);
183 *ppobj = This;
184 return S_OK;
185 }
186 *ppobj = NULL;
187 return E_NOINTERFACE;
188 }
189
190 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
191 IWineD3DImpl *This = (IWineD3DImpl *)iface;
192 ULONG refCount = InterlockedIncrement(&This->ref);
193
194 TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
195 return refCount;
196 }
197
198 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
199 IWineD3DImpl *This = (IWineD3DImpl *)iface;
200 ULONG ref;
201 TRACE("(%p) : Releasing from %d\n", This, This->ref);
202 ref = InterlockedDecrement(&This->ref);
203 if (ref == 0) {
204 HeapFree(GetProcessHeap(), 0, This);
205 }
206
207 return ref;
208 }
209
210 /* Set the shader type for this device, depending on the given capabilities,
211 * the device type, and the user preferences in wined3d_settings */
212
213 static void select_shader_mode(
214 WineD3D_GL_Info *gl_info,
215 WINED3DDEVTYPE DeviceType,
216 int* ps_selected,
217 int* vs_selected) {
218
219 /* Give priority to user disable/emulation request.
220 * Then respect REF device for software.
221 * Then check capabilities for hardware, and fallback to software */
222
223 if (wined3d_settings.vs_mode == VS_NONE) {
224 *vs_selected = SHADER_NONE;
225 } else if (DeviceType == WINED3DDEVTYPE_REF || wined3d_settings.vs_mode == VS_SW) {
226 *vs_selected = SHADER_SW;
227 } else if (gl_info->supported[ARB_VERTEX_SHADER] && wined3d_settings.glslRequested) {
228 *vs_selected = SHADER_GLSL;
229 } else if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
230 *vs_selected = SHADER_ARB;
231 } else {
232 *vs_selected = SHADER_SW;
233 }
234
235 /* Fallback to SHADER_NONE where software pixel shaders should be used */
236 if (wined3d_settings.ps_mode == PS_NONE) {
237 *ps_selected = SHADER_NONE;
238 } else if (DeviceType == WINED3DDEVTYPE_REF) {
239 *ps_selected = SHADER_NONE;
240 } else if (gl_info->supported[ARB_FRAGMENT_SHADER] && wined3d_settings.glslRequested) {
241 *ps_selected = SHADER_GLSL;
242 } else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
243 *ps_selected = SHADER_ARB;
244 } else {
245 *ps_selected = SHADER_NONE;
246 }
247 }
248
249 /** Select the number of report maximum shader constants based on the selected shader modes */
250 void select_shader_max_constants(
251 int ps_selected_mode,
252 int vs_selected_mode,
253 WineD3D_GL_Info *gl_info) {
254
255 switch (vs_selected_mode) {
256 case SHADER_GLSL:
257 /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
258 gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF - MAX_CONST_B - MAX_CONST_I - 1;
259 break;
260 case SHADER_ARB:
261 /* We have to subtract any other PARAMs that we might use in our shader programs.
262 * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
263 * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
264 gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF - 3;
265 break;
266 case SHADER_SW:
267 gl_info->max_vshader_constantsF = 96; /* TODO: Fixup software shaders */
268 break;
269 default:
270 gl_info->max_vshader_constantsF = 0;
271 break;
272 }
273
274 switch (ps_selected_mode) {
275 case SHADER_GLSL:
276 /* Subtract the other potential uniforms from the max available (bools & ints) */
277 gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF - MAX_CONST_B - MAX_CONST_I;
278 break;
279 case SHADER_ARB:
280 gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF;
281 break;
282 case SHADER_SW:
283 gl_info->max_pshader_constantsF = 96; /* TODO: Fixup software shaders */
284 break;
285 default:
286 gl_info->max_pshader_constantsF = 0;
287 break;
288 }
289 }
290
291 /**********************************************************
292 * IWineD3D parts follows
293 **********************************************************/
294
295 BOOL IWineD3DImpl_FillGLCaps(IWineD3D *iface, Display* display) {
296 IWineD3DImpl *This = (IWineD3DImpl *)iface;
297 WineD3D_GL_Info *gl_info = &This->gl_info;
298
299 const char *GL_Extensions = NULL;
300 const char *GLX_Extensions = NULL;
301 const char *gl_string = NULL;
302 const char *gl_string_cursor = NULL;
303 GLint gl_max;
304 GLfloat gl_floatv[2];
305 Bool test = 0;
306 int major, minor;
307 WineD3D_Context *fake_ctx = NULL;
308 BOOL gotContext = FALSE;
309 int i;
310
311 /* Make sure that we've got a context */
312 if (glXGetCurrentContext() == NULL) {
313 /* TODO: CreateFakeGLContext should really take a display as a parameter */
314 fake_ctx = WineD3D_CreateFakeGLContext();
315 if (NULL != fake_ctx) gotContext = TRUE;
316 } else {
317 gotContext = TRUE;
318 }
319
320 TRACE_(d3d_caps)("(%p, %p)\n", gl_info, display);
321
322 gl_string = (const char *) glGetString(GL_RENDERER);
323 if (NULL == gl_string)
324 gl_string = "None";
325 strcpy(gl_info->gl_renderer, gl_string);
326
327 /* Fill in the GL info retrievable depending on the display */
328 if (NULL != display) {
329 test = glXQueryVersion(display, &major, &minor);
330 gl_info->glx_version = ((major & 0x0000FFFF) << 16) | (minor & 0x0000FFFF);
331 } else {
332 FIXME("Display must not be NULL, use glXGetCurrentDisplay or getAdapterDisplay()\n");
333 }
334 gl_string = (const char *) glGetString(GL_VENDOR);
335
336 TRACE_(d3d_caps)("Filling vendor string %s\n", gl_string);
337 if (gl_string != NULL) {
338 /* Fill in the GL vendor */
339 if (strstr(gl_string, "NVIDIA")) {
340 gl_info->gl_vendor = VENDOR_NVIDIA;
341 } else if (strstr(gl_string, "ATI")) {
342 gl_info->gl_vendor = VENDOR_ATI;
343 } else if (strstr(gl_string, "Intel(R)") ||
344 strstr(gl_info->gl_renderer, "Intel(R)")) {
345 gl_info->gl_vendor = VENDOR_INTEL;
346 } else if (strstr(gl_string, "Mesa")) {
347 gl_info->gl_vendor = VENDOR_MESA;
348 } else {
349 gl_info->gl_vendor = VENDOR_WINE;
350 }
351 } else {
352 gl_info->gl_vendor = VENDOR_WINE;
353 }
354
355
356 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string), gl_info->gl_vendor);
357
358 /* Parse the GL_VERSION field into major and minor information */
359 gl_string = (const char *) glGetString(GL_VERSION);
360 if (gl_string != NULL) {
361
362 switch (gl_info->gl_vendor) {
363 case VENDOR_NVIDIA:
364 gl_string_cursor = strstr(gl_string, "NVIDIA");
365 if (!gl_string_cursor) {
366 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
367 break;
368 }
369
370 gl_string_cursor = strstr(gl_string_cursor, " ");
371 if (!gl_string_cursor) {
372 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
373 break;
374 }
375
376 while (*gl_string_cursor == ' ') {
377 ++gl_string_cursor;
378 }
379
380 if (!*gl_string_cursor) {
381 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
382 break;
383 }
384
385 major = atoi(gl_string_cursor);
386 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
387 ++gl_string_cursor;
388 }
389
390 if (*gl_string_cursor++ != '.') {
391 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
392 break;
393 }
394
395 minor = atoi(gl_string_cursor);
396 minor = major*100+minor;
397 major = 10;
398
399 break;
400
401 case VENDOR_ATI:
402 major = minor = 0;
403 gl_string_cursor = strchr(gl_string, '-');
404 if (gl_string_cursor) {
405 int error = 0;
406 gl_string_cursor++;
407
408 /* Check if version number is of the form x.y.z */
409 if (*gl_string_cursor > '9' && *gl_string_cursor < '0')
410 error = 1;
411 if (!error && *(gl_string_cursor+2) > '9' && *(gl_string_cursor+2) < '0')
412 error = 1;
413 if (!error && *(gl_string_cursor+4) > '9' && *(gl_string_cursor+4) < '0')
414 error = 1;
415 if (!error && *(gl_string_cursor+1) != '.' && *(gl_string_cursor+3) != '.')
416 error = 1;
417
418 /* Mark version number as malformed */
419 if (error)
420 gl_string_cursor = 0;
421 }
422
423 if (!gl_string_cursor)
424 WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
425 else {
426 major = *gl_string_cursor - '0';
427 minor = (*(gl_string_cursor+2) - '0') * 256 + (*(gl_string_cursor+4) - '0');
428 }
429 break;
430
431 case VENDOR_INTEL:
432 case VENDOR_MESA:
433 gl_string_cursor = strstr(gl_string, "Mesa");
434 gl_string_cursor = strstr(gl_string_cursor, " ");
435 while (*gl_string_cursor && ' ' == *gl_string_cursor) ++gl_string_cursor;
436 if (*gl_string_cursor) {
437 char tmp[16];
438 int cursor = 0;
439
440 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
441 tmp[cursor++] = *gl_string_cursor;
442 ++gl_string_cursor;
443 }
444 tmp[cursor] = 0;
445 major = atoi(tmp);
446
447 if (*gl_string_cursor != '.') WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
448 ++gl_string_cursor;
449
450 cursor = 0;
451 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
452 tmp[cursor++] = *gl_string_cursor;
453 ++gl_string_cursor;
454 }
455 tmp[cursor] = 0;
456 minor = atoi(tmp);
457 }
458 break;
459
460 default:
461 major = 0;
462 minor = 9;
463 }
464 gl_info->gl_driver_version = MAKEDWORD_VERSION(major, minor);
465 TRACE_(d3d_caps)("found GL_VERSION (%s)->%i.%i->(0x%08x)\n", debugstr_a(gl_string), major, minor, gl_info->gl_driver_version);
466 }
467
468 TRACE_(d3d_caps)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(gl_info->gl_renderer), gl_info->gl_card);
469
470 /*
471 * Initialize openGL extension related variables
472 * with Default values
473 */
474 memset(&gl_info->supported, 0, sizeof(gl_info->supported));
475 gl_info->max_buffers = 1;
476 gl_info->max_textures = 1;
477 gl_info->max_texture_stages = 1;
478 gl_info->max_samplers = 1;
479 gl_info->max_sampler_stages = 1;
480 gl_info->ps_arb_version = PS_VERSION_NOT_SUPPORTED;
481 gl_info->ps_arb_max_temps = 0;
482 gl_info->ps_arb_max_instructions = 0;
483 gl_info->vs_arb_version = VS_VERSION_NOT_SUPPORTED;
484 gl_info->vs_arb_max_temps = 0;
485 gl_info->vs_arb_max_instructions = 0;
486 gl_info->vs_nv_version = VS_VERSION_NOT_SUPPORTED;
487 gl_info->vs_ati_version = VS_VERSION_NOT_SUPPORTED;
488 gl_info->vs_glsl_constantsF = 0;
489 gl_info->ps_glsl_constantsF = 0;
490 gl_info->vs_arb_constantsF = 0;
491 gl_info->ps_arb_constantsF = 0;
492
493 /* Now work out what GL support this card really has */
494 #define USE_GL_FUNC(type, pfn) gl_info->pfn = (type) glXGetProcAddressARB( (const GLubyte *) #pfn);
495 GL_EXT_FUNCS_GEN;
496 GLX_EXT_FUNCS_GEN;
497 #undef USE_GL_FUNC
498
499 /* Retrieve opengl defaults */
500 glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
501 gl_info->max_clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
502 TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
503
504 glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
505 gl_info->max_lights = gl_max;
506 TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
507
508 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
509 gl_info->max_texture_size = gl_max;
510 TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
511
512 glGetFloatv(GL_POINT_SIZE_RANGE, gl_floatv);
513 gl_info->max_pointsize = gl_floatv[1];
514 TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
515
516 /* Parse the gl supported features, in theory enabling parts of our code appropriately */
517 GL_Extensions = (const char *) glGetString(GL_EXTENSIONS);
518 TRACE_(d3d_caps)("GL_Extensions reported:\n");
519
520 if (NULL == GL_Extensions) {
521 ERR(" GL_Extensions returns NULL\n");
522 } else {
523 while (*GL_Extensions != 0x00) {
524 const char *Start = GL_Extensions;
525 char ThisExtn[256];
526
527 memset(ThisExtn, 0x00, sizeof(ThisExtn));
528 while (*GL_Extensions != ' ' && *GL_Extensions != 0x00) {
529 GL_Extensions++;
530 }
531 memcpy(ThisExtn, Start, (GL_Extensions - Start));
532 TRACE_(d3d_caps)("- %s\n", ThisExtn);
533
534 /**
535 * ARB
536 */
537 if (strcmp(ThisExtn, "GL_ARB_draw_buffers") == 0) {
538 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
539 TRACE_(d3d_caps)(" FOUND: ARB_draw_buffers support - max buffers=%u\n", gl_max);
540 gl_info->supported[ARB_DRAW_BUFFERS] = TRUE;
541 gl_info->max_buffers = gl_max;
542 } else if (strcmp(ThisExtn, "GL_ARB_fragment_program") == 0) {
543 gl_info->ps_arb_version = PS_VERSION_11;
544 TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - version=%02x\n", gl_info->ps_arb_version);
545 gl_info->supported[ARB_FRAGMENT_PROGRAM] = TRUE;
546 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &gl_max);
547 TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - GL_MAX_TEXTURE_IMAGE_UNITS_ARB=%u\n", gl_max);
548 gl_info->max_samplers = min(MAX_SAMPLERS, gl_max);
549 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
550 TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - max float constants=%u\n", gl_max);
551 gl_info->ps_arb_constantsF = gl_max;
552 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
553 TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - max temporaries=%u\n", gl_max);
554 gl_info->ps_arb_max_temps = gl_max;
555 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
556 TRACE_(d3d_caps)(" FOUND: ARB Pixel Shader support - max instructions=%u\n", gl_max);
557 gl_info->ps_arb_max_instructions = gl_max;
558 } else if (strcmp(ThisExtn, "GL_ARB_fragment_shader") == 0) {
559 gl_info->supported[ARB_FRAGMENT_SHADER] = TRUE;
560 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
561 gl_max /= 4;
562 TRACE_(d3d_caps)(" FOUND: ARB_fragment_shader (GLSL) support - max float ps constants=%u\n", gl_max);
563 gl_info->ps_glsl_constantsF = gl_max;
564 } else if (strcmp(ThisExtn, "GL_ARB_imaging") == 0) {
565 TRACE_(d3d_caps)(" FOUND: ARB imaging support\n");
566 gl_info->supported[ARB_IMAGING] = TRUE;
567 } else if (strcmp(ThisExtn, "GL_ARB_multisample") == 0) {
568 TRACE_(d3d_caps)(" FOUND: ARB Multisample support\n");
569 gl_info->supported[ARB_MULTISAMPLE] = TRUE;
570 } else if (strcmp(ThisExtn, "GL_ARB_multitexture") == 0) {
571 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
572 TRACE_(d3d_caps)(" FOUND: ARB Multitexture support - GL_MAX_TEXTURE_UNITS_ARB=%u\n", gl_max);
573 gl_info->supported[ARB_MULTITEXTURE] = TRUE;
574 gl_info->max_textures = min(MAX_TEXTURES, gl_max);
575 gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
576 gl_info->max_samplers = max(gl_info->max_samplers, gl_max);
577 } else if (strcmp(ThisExtn, "GL_ARB_texture_cube_map") == 0) {
578 TRACE_(d3d_caps)(" FOUND: ARB Texture Cube Map support\n");
579 gl_info->supported[ARB_TEXTURE_CUBE_MAP] = TRUE;
580 TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
581 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
582 } else if (strcmp(ThisExtn, "GL_ARB_texture_compression") == 0) {
583 TRACE_(d3d_caps)(" FOUND: ARB Texture Compression support\n");
584 gl_info->supported[ARB_TEXTURE_COMPRESSION] = TRUE;
585 } else if (strcmp(ThisExtn, "GL_ARB_texture_env_add") == 0) {
586 TRACE_(d3d_caps)(" FOUND: ARB Texture Env Add support\n");
587 gl_info->supported[ARB_TEXTURE_ENV_ADD] = TRUE;
588 } else if (strcmp(ThisExtn, "GL_ARB_texture_env_combine") == 0) {
589 TRACE_(d3d_caps)(" FOUND: ARB Texture Env combine support\n");
590 gl_info->supported[ARB_TEXTURE_ENV_COMBINE] = TRUE;
591 } else if (strcmp(ThisExtn, "GL_ARB_texture_env_dot3") == 0) {
592 TRACE_(d3d_caps)(" FOUND: ARB Dot3 support\n");
593 gl_info->supported[ARB_TEXTURE_ENV_DOT3] = TRUE;
594 } else if (strcmp(ThisExtn, "GL_ARB_texture_float") == 0) {
595 TRACE_(d3d_caps)(" FOUND: ARB Float texture support\n");
596 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
597 } else if (strcmp(ThisExtn, "GL_ARB_half_float_pixel") == 0) {
598 TRACE_(d3d_caps)(" FOUND: ARB Half-float pixel support\n");
599 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
600 } else if (strcmp(ThisExtn, "GL_ARB_texture_border_clamp") == 0) {
601 TRACE_(d3d_caps)(" FOUND: ARB Texture border clamp support\n");
602 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] = TRUE;
603 } else if (strcmp(ThisExtn, "GL_ARB_texture_mirrored_repeat") == 0) {
604 TRACE_(d3d_caps)(" FOUND: ARB Texture mirrored repeat support\n");
605 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] = TRUE;
606 } else if (strcmp(ThisExtn, "GL_ARB_texture_non_power_of_two") == 0) {
607 TRACE_(d3d_caps)(" FOUND: ARB NPOT texture support\n");
608 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = TRUE;
609 } else if (strcmp(ThisExtn, "GLX_ARB_multisample") == 0) {
610 TRACE_(d3d_caps)(" FOUND: ARB multisample support\n");
611 gl_info->supported[ARB_MULTISAMPLE] = TRUE;
612 } else if (strcmp(ThisExtn, "GL_ARB_pixel_buffer_object") == 0) {
613 TRACE_(d3d_caps)(" FOUND: ARB Pixel Buffer support\n");
614 gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = TRUE;
615 } else if (strcmp(ThisExtn, "GL_ARB_point_sprite") == 0) {
616 TRACE_(d3d_caps)(" FOUND: ARB point sprite support\n");
617 gl_info->supported[ARB_POINT_SPRITE] = TRUE;
618 } else if (strstr(ThisExtn, "GL_ARB_vertex_program")) {
619 gl_info->vs_arb_version = VS_VERSION_11;
620 TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - version=%02x\n", gl_info->vs_arb_version);
621 gl_info->supported[ARB_VERTEX_PROGRAM] = TRUE;
622 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
623 TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - max float constants=%u\n", gl_max);
624 gl_info->vs_arb_constantsF = gl_max;
625 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_TEMPORARIES_ARB, &gl_max));
626 TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - max temporaries=%u\n", gl_max);
627 gl_info->vs_arb_max_temps = gl_max;
628 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_INSTRUCTIONS_ARB, &gl_max));
629 TRACE_(d3d_caps)(" FOUND: ARB Vertex Shader support - max instructions=%u\n", gl_max);
630 gl_info->vs_arb_max_instructions = gl_max;
631 } else if (strcmp(ThisExtn, "GL_ARB_vertex_shader") == 0) {
632 gl_info->supported[ARB_VERTEX_SHADER] = TRUE;
633 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
634 gl_max /= 4;
635 TRACE_(d3d_caps)(" FOUND: ARB_vertex_shader (GLSL) support - max float vs constants=%u\n", gl_max);
636 gl_info->vs_glsl_constantsF = gl_max;
637 } else if (strcmp(ThisExtn, "GL_ARB_vertex_blend") == 0) {
638 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
639 TRACE_(d3d_caps)(" FOUND: ARB Vertex Blend support GL_MAX_VERTEX_UNITS_ARB %d\n", gl_max);
640 gl_info->max_blends = gl_max;
641 gl_info->supported[ARB_VERTEX_BLEND] = TRUE;
642 } else if (strcmp(ThisExtn, "GL_ARB_vertex_buffer_object") == 0) {
643 TRACE_(d3d_caps)(" FOUND: ARB Vertex Buffer support\n");
644 gl_info->supported[ARB_VERTEX_BUFFER_OBJECT] = TRUE;
645 } else if (strcmp(ThisExtn, "GL_ARB_occlusion_query") == 0) {
646 TRACE_(d3d_caps)(" FOUND: ARB Occlusion Query support\n");
647 gl_info->supported[ARB_OCCLUSION_QUERY] = TRUE;
648 } else if (strcmp(ThisExtn, "GL_ARB_point_parameters") == 0) {
649 TRACE_(d3d_caps)(" FOUND: ARB Point parameters support\n");
650 gl_info->supported[ARB_POINT_PARAMETERS] = TRUE;
651 /**
652 * EXT
653 */
654 } else if (strcmp(ThisExtn, "GL_EXT_fog_coord") == 0) {
655 TRACE_(d3d_caps)(" FOUND: EXT Fog coord support\n");
656 gl_info->supported[EXT_FOG_COORD] = TRUE;
657 } else if (strcmp(ThisExtn, "GL_EXT_framebuffer_object") == 0) {
658 TRACE_(d3d_caps)(" FOUND: EXT Frame Buffer Object support\n");
659 gl_info->supported[EXT_FRAMEBUFFER_OBJECT] = TRUE;
660 } else if (strcmp(ThisExtn, "GL_EXT_blend_minmax") == 0) {
661 TRACE_(d3d_caps)(" FOUND: EXT Blend minmax support\n");
662 gl_info->supported[EXT_BLEND_MINMAX] = TRUE;
663 } else if (strcmp(ThisExtn, "GL_EXT_paletted_texture") == 0) { /* handle paletted texture extensions */
664 TRACE_(d3d_caps)(" FOUND: EXT Paletted texture support\n");
665 gl_info->supported[EXT_PALETTED_TEXTURE] = TRUE;
666 } else if (strcmp(ThisExtn, "GL_EXT_point_parameters") == 0) {
667 TRACE_(d3d_caps)(" FOUND: EXT Point parameters support\n");
668 gl_info->supported[EXT_POINT_PARAMETERS] = TRUE;
669 } else if (strcmp(ThisExtn, "GL_EXT_secondary_color") == 0) {
670 TRACE_(d3d_caps)(" FOUND: EXT Secondary coord support\n");
671 gl_info->supported[EXT_SECONDARY_COLOR] = TRUE;
672 } else if (strcmp(ThisExtn, "GL_EXT_stencil_two_side") == 0) {
673 TRACE_(d3d_caps)(" FOUND: EXT Stencil two side support\n");
674 gl_info->supported[EXT_STENCIL_TWO_SIDE] = TRUE;
675 } else if (strcmp(ThisExtn, "GL_EXT_stencil_wrap") == 0) {
676 TRACE_(d3d_caps)(" FOUND: EXT Stencil wrap support\n");
677 gl_info->supported[EXT_STENCIL_WRAP] = TRUE;
678 } else if (strcmp(ThisExtn, "GL_EXT_texture3D") == 0) {
679 TRACE_(d3d_caps)(" FOUND: EXT_texture3D support\n");
680 gl_info->supported[EXT_TEXTURE3D] = TRUE;
681 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
682 TRACE_(d3d_caps)("Max texture3D size: %d\n", gl_max);
683 gl_info->max_texture3d_size = gl_max;
684 } else if (strcmp(ThisExtn, "GL_EXT_texture_compression_s3tc") == 0) {
685 TRACE_(d3d_caps)(" FOUND: EXT Texture S3TC compression support\n");
686 gl_info->supported[EXT_TEXTURE_COMPRESSION_S3TC] = TRUE;
687 } else if (strcmp(ThisExtn, "GL_EXT_texture_env_add") == 0) {
688 TRACE_(d3d_caps)(" FOUND: EXT Texture Env Add support\n");
689 gl_info->supported[EXT_TEXTURE_ENV_ADD] = TRUE;
690 } else if (strcmp(ThisExtn, "GL_EXT_texture_env_combine") == 0) {
691 TRACE_(d3d_caps)(" FOUND: EXT Texture Env combine support\n");
692 gl_info->supported[EXT_TEXTURE_ENV_COMBINE] = TRUE;
693 } else if (strcmp(ThisExtn, "GL_EXT_texture_env_dot3") == 0) {
694 TRACE_(d3d_caps)(" FOUND: EXT Dot3 support\n");
695 gl_info->supported[EXT_TEXTURE_ENV_DOT3] = TRUE;
696 } else if (strcmp(ThisExtn, "GL_EXT_texture_filter_anisotropic") == 0) {
697 gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] = TRUE;
698 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
699 TRACE_(d3d_caps)(" FOUND: EXT Texture Anisotropic filter support. GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT %d\n", gl_max);
700 gl_info->max_anisotropy = gl_max;
701 } else if (strcmp(ThisExtn, "GL_EXT_texture_lod") == 0) {
702 TRACE_(d3d_caps)(" FOUND: EXT Texture LOD support\n");
703 gl_info->supported[EXT_TEXTURE_LOD] = TRUE;
704 } else if (strcmp(ThisExtn, "GL_EXT_texture_lod_bias") == 0) {
705 TRACE_(d3d_caps)(" FOUND: EXT Texture LOD bias support\n");
706 gl_info->supported[EXT_TEXTURE_LOD_BIAS] = TRUE;
707 } else if (strcmp(ThisExtn, "GL_EXT_vertex_weighting") == 0) {
708 TRACE_(d3d_caps)(" FOUND: EXT Vertex weighting support\n");
709 gl_info->supported[EXT_VERTEX_WEIGHTING] = TRUE;
710
711 /**
712 * NVIDIA
713 */
714 } else if (strstr(ThisExtn, "GL_NV_fog_distance")) {
715 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Fog Distance support\n");
716 gl_info->supported[NV_FOG_DISTANCE] = TRUE;
717 } else if (strstr(ThisExtn, "GL_NV_fragment_program")) {
718 gl_info->ps_nv_version = (strcmp(ThisExtn, "GL_NV_fragment_program2") == 0) ? PS_VERSION_30 : PS_VERSION_20;
719 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Pixel Shader support - version=%02x\n", gl_info->ps_nv_version);
720 } else if (strcmp(ThisExtn, "GL_NV_register_combiners") == 0) {
721 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
722 gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
723 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Register combiners (1) support - GL_MAX_GENERAL_COMBINERS_NV=%d\n", gl_max);
724 gl_info->supported[NV_REGISTER_COMBINERS] = TRUE;
725 } else if (strcmp(ThisExtn, "GL_NV_register_combiners2") == 0) {
726 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Register combiners (2) support\n");
727 gl_info->supported[NV_REGISTER_COMBINERS2] = TRUE;
728 } else if (strcmp(ThisExtn, "GL_NV_texgen_reflection") == 0) {
729 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Gen Reflection support\n");
730 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
731 } else if (strcmp(ThisExtn, "GL_NV_texture_env_combine4") == 0) {
732 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Env combine (4) support\n");
733 gl_info->supported[NV_TEXTURE_ENV_COMBINE4] = TRUE;
734 } else if (strcmp(ThisExtn, "GL_NV_texture_shader") == 0) {
735 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (1) support\n");
736 gl_info->supported[NV_TEXTURE_SHADER] = TRUE;
737 } else if (strcmp(ThisExtn, "GL_NV_texture_shader2") == 0) {
738 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (2) support\n");
739 gl_info->supported[NV_TEXTURE_SHADER2] = TRUE;
740 } else if (strcmp(ThisExtn, "GL_NV_texture_shader3") == 0) {
741 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Texture Shader (3) support\n");
742 gl_info->supported[NV_TEXTURE_SHADER3] = TRUE;
743 } else if (strcmp(ThisExtn, "GL_NV_occlusion_query") == 0) {
744 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Occlusion Query (3) support\n");
745 gl_info->supported[NV_OCCLUSION_QUERY] = TRUE;
746 } else if (strstr(ThisExtn, "GL_NV_vertex_program")) {
747 if(strcmp(ThisExtn, "GL_NV_vertex_program3") == 0)
748 gl_info->vs_nv_version = VS_VERSION_30;
749 else if(strcmp(ThisExtn, "GL_NV_vertex_program2") == 0)
750 gl_info->vs_nv_version = VS_VERSION_20;
751 else if(strcmp(ThisExtn, "GL_NV_vertex_program1_1") == 0)
752 gl_info->vs_nv_version = VS_VERSION_11;
753 else
754 gl_info->vs_nv_version = VS_VERSION_10;
755 TRACE_(d3d_caps)(" FOUND: NVIDIA (NV) Vertex Shader support - version=%02x\n", gl_info->vs_nv_version);
756 gl_info->supported[NV_VERTEX_PROGRAM] = TRUE;
757
758 /**
759 * ATI
760 */
761 /** TODO */
762 } else if (strcmp(ThisExtn, "GL_ATI_separate_stencil") == 0) {
763 TRACE_(d3d_caps)(" FOUND: ATI Separate stencil support\n");
764 gl_info->supported[ATI_SEPARATE_STENCIL] = TRUE;
765 } else if (strcmp(ThisExtn, "GL_ATI_texture_env_combine3") == 0) {
766 TRACE_(d3d_caps)(" FOUND: ATI Texture Env combine (3) support\n");
767 gl_info->supported[ATI_TEXTURE_ENV_COMBINE3] = TRUE;
768 } else if (strcmp(ThisExtn, "GL_ATI_texture_mirror_once") == 0) {
769 TRACE_(d3d_caps)(" FOUND: ATI Texture Mirror Once support\n");
770 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] = TRUE;
771 } else if (strcmp(ThisExtn, "GL_EXT_vertex_shader") == 0) {
772 gl_info->vs_ati_version = VS_VERSION_11;
773 TRACE_(d3d_caps)(" FOUND: ATI (EXT) Vertex Shader support - version=%02x\n", gl_info->vs_ati_version);
774 gl_info->supported[EXT_VERTEX_SHADER] = TRUE;
775 }
776
777
778 if (*GL_Extensions == ' ') GL_Extensions++;
779 }
780 }
781 checkGLcall("extension detection\n");
782
783 /* In some cases the number of texture stages can be larger than the number
784 * of samplers. The GF4 for example can use only 2 samplers (no fragment
785 * shaders), but 8 texture stages (register combiners). */
786 gl_info->max_sampler_stages = max(gl_info->max_samplers, gl_info->max_texture_stages);
787
788 /* We can only use NP2_NATIVE when the hardware supports it. */
789 if (wined3d_settings.nonpower2_mode == NP2_NATIVE && !gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) {
790 WARN_(d3d_caps)("GL_ARB_texture_non_power_of_two not supported, falling back to NP2_NONE NPOT mode.\n");
791 wined3d_settings.nonpower2_mode = NP2_NONE;
792 }
793
794 /* We can only use ORM_FBO when the hardware supports it. */
795 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) {
796 WARN_(d3d_caps)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
797 wined3d_settings.offscreen_rendering_mode = ORM_PBUFFER;
798 }
799
800 /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
801 * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
802 * in case of the latest videocards in the number of pixel/vertex pipelines.
803 *
804 * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
805 * rendering. Various games use this information to get a rough estimation of the features of the card
806 * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
807 * games might even use it to work around bugs which happen on certain videocards/driver combinations.
808 * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
809 * not the PCI id.
810 *
811 * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
812 * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
813 * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
814 * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
815 * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
816 * is used for rendering which is not always the case). This would work but it is not very portable. Second
817 * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
818 * is limited.
819 *
820 * As said most games only use the PCI id to get an indication of the capabilities of the card.
821 * It doesn't really matter if the given id is the correct one if we return the id of a card with
822 * similar 3d features.
823 *
824 * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
825 * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
826 * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
827 * won't pass we return a default card. This way is better than maintaining a full card database as even
828 * without a full database we can return a card with similar features. Second the size of the database
829 * can be made quite small because when you know what type of 3d functionality a card has, you know to which
830 * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
831 * to distinguishes between different models from that family.
832 */
833 switch (gl_info->gl_vendor) {
834 case VENDOR_NVIDIA:
835 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
836 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
837 */
838 if(WINE_D3D9_CAPABLE(gl_info) && (gl_info->vs_nv_version == VS_VERSION_30)) {
839 if (strstr(gl_info->gl_renderer, "7800") ||
840 strstr(gl_info->gl_renderer, "7900") ||
841 strstr(gl_info->gl_renderer, "7950") ||
842 strstr(gl_info->gl_renderer, "Quadro FX 4") ||
843 strstr(gl_info->gl_renderer, "Quadro FX 5"))
844 gl_info->gl_card = CARD_NVIDIA_GEFORCE_7800GT;
845 else if(strstr(gl_info->gl_renderer, "6800") ||
846 strstr(gl_info->gl_renderer, "7600"))
847 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6800;
848 else if(strstr(gl_info->gl_renderer, "6600") ||
849 strstr(gl_info->gl_renderer, "6610") ||
850 strstr(gl_info->gl_renderer, "6700"))
851 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6600GT;
852 else
853 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400 */
854 } else if(WINE_D3D9_CAPABLE(gl_info)) {
855 if (strstr(gl_info->gl_renderer, "5800") ||
856 strstr(gl_info->gl_renderer, "5900") ||
857 strstr(gl_info->gl_renderer, "5950") ||
858 strstr(gl_info->gl_renderer, "Quadro FX"))
859 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5800;
860 else if(strstr(gl_info->gl_renderer, "5600") ||
861 strstr(gl_info->gl_renderer, "5650") ||
862 strstr(gl_info->gl_renderer, "5700") ||
863 strstr(gl_info->gl_renderer, "5750"))
864 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
865 else
866 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
867 } else if(WINE_D3D8_CAPABLE(gl_info)) {
868 if (strstr(gl_info->gl_renderer, "GeForce4 Ti") || strstr(gl_info->gl_renderer, "Quadro4"))
869 gl_info->gl_card = CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
870 else
871 gl_info->gl_card = CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
872 } else if(WINE_D3D7_CAPABLE(gl_info)) {
873 if (strstr(gl_info->gl_renderer, "GeForce4 MX"))
874 gl_info->gl_card = CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
875 else if(strstr(gl_info->gl_renderer, "GeForce2 MX") || strstr(gl_info->gl_renderer, "Quadro2 MXR"))
876 gl_info->gl_card = CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
877 else if(strstr(gl_info->gl_renderer, "GeForce2") || strstr(gl_info->gl_renderer, "Quadro2"))
878 gl_info->gl_card = CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
879 else
880 gl_info->gl_card = CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
881 } else {
882 if (strstr(gl_info->gl_renderer, "TNT2"))
883 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
884 else
885 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
886 }
887 break;
888 case VENDOR_ATI:
889 if(WINE_D3D9_CAPABLE(gl_info)) {
890 /* Radeon R5xx */
891 if (strstr(gl_info->gl_renderer, "X1600") ||
892 strstr(gl_info->gl_renderer, "X1800") ||
893 strstr(gl_info->gl_renderer, "X1900") ||
894 strstr(gl_info->gl_renderer, "X1950"))
895 gl_info->gl_card = CARD_ATI_RADEON_X1600;
896 /* Radeon R4xx + X1300/X1400 (lowend R5xx) */
897 else if(strstr(gl_info->gl_renderer, "X700") ||
898 strstr(gl_info->gl_renderer, "X800") ||
899 strstr(gl_info->gl_renderer, "X850") ||
900 strstr(gl_info->gl_renderer, "X1300") ||
901 strstr(gl_info->gl_renderer, "X1400"))
902 gl_info->gl_card = CARD_ATI_RADEON_X700;
903 /* Radeon R3xx */
904 else
905 gl_info->gl_card = CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
906 } else if(WINE_D3D8_CAPABLE(gl_info)) {
907 gl_info->gl_card = CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
908 } else if(WINE_D3D7_CAPABLE(gl_info)) {
909 gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
910 } else
911 gl_info->gl_card = CARD_ATI_RAGE_128PRO;
912 break;
913 case VENDOR_INTEL:
914 if (strstr(gl_info->gl_renderer, "915GM")) {
915 gl_info->gl_card = CARD_INTEL_I915GM;
916 } else if (strstr(gl_info->gl_renderer, "915G")) {
917 gl_info->gl_card = CARD_INTEL_I915G;
918 } else if (strstr(gl_info->gl_renderer, "865G")) {
919 gl_info->gl_card = CARD_INTEL_I865G;
920 } else if (strstr(gl_info->gl_renderer, "855G")) {
921 gl_info->gl_card = CARD_INTEL_I855G;
922 } else if (strstr(gl_info->gl_renderer, "830G")) {
923 gl_info->gl_card = CARD_INTEL_I830G;
924 } else {
925 gl_info->gl_card = CARD_INTEL_I915G;
926 }
927 break;
928 case VENDOR_MESA:
929 case VENDOR_WINE:
930 default:
931 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
932 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
933 * them a good generic choice.
934 */
935 gl_info->gl_vendor = VENDOR_NVIDIA;
936 if(WINE_D3D9_CAPABLE(gl_info))
937 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
938 else if(WINE_D3D8_CAPABLE(gl_info))
939 gl_info->gl_card = CARD_NVIDIA_GEFORCE3;
940 else if(WINE_D3D7_CAPABLE(gl_info))
941 gl_info->gl_card = CARD_NVIDIA_GEFORCE;
942 else if(WINE_D3D6_CAPABLE(gl_info))
943 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT;
944 else
945 gl_info->gl_card = CARD_NVIDIA_RIVA_128;
946 }
947 TRACE("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info->gl_vendor, gl_info->gl_card);
948
949 /* Load all the lookup tables
950 TODO: It may be a good idea to make minLookup and maxLookup const and populate them in wined3d_private.h where they are declared */
951 minLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_WRAP;
952 maxLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_MIRRORONCE;
953
954 minLookup[WINELOOKUP_MAGFILTER] = WINED3DTEXF_NONE;
955 maxLookup[WINELOOKUP_MAGFILTER] = WINED3DTEXF_ANISOTROPIC;
956
957
958 for (i = 0; i < MAX_LOOKUPS; i++) {
959 stateLookup[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup[i]) * (1 + maxLookup[i] - minLookup[i]) );
960 }
961
962 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_WRAP - minLookup[WINELOOKUP_WARPPARAM]] = GL_REPEAT;
963 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_CLAMP - minLookup[WINELOOKUP_WARPPARAM]] = GL_CLAMP_TO_EDGE;
964 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
965 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
966 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
967 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
968 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRROR - minLookup[WINELOOKUP_WARPPARAM]] =
969 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
970 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRRORONCE - minLookup[WINELOOKUP_WARPPARAM]] =
971 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
972
973 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_NONE - minLookup[WINELOOKUP_MAGFILTER]] = GL_NEAREST;
974 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_POINT - minLookup[WINELOOKUP_MAGFILTER]] = GL_NEAREST;
975 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_LINEAR - minLookup[WINELOOKUP_MAGFILTER]] = GL_LINEAR;
976 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_ANISOTROPIC - minLookup[WINELOOKUP_MAGFILTER]] =
977 gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR : GL_NEAREST;
978
979
980 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_NONE] = GL_LINEAR;
981 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_POINT] = GL_LINEAR;
982 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_LINEAR] = GL_LINEAR;
983 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_NONE] = GL_NEAREST;
984 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_POINT] = GL_NEAREST_MIPMAP_NEAREST;
985 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_LINEAR] = GL_NEAREST_MIPMAP_LINEAR;
986 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_NONE] = GL_LINEAR;
987 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_POINT] = GL_LINEAR_MIPMAP_NEAREST;
988 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_LINEAR] = GL_LINEAR_MIPMAP_LINEAR;
989 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_NONE] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ?
990 GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
991 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_POINT] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
992 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_LINEAR] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
993
994 /* TODO: config lookups */
995
996 if (display != NULL) {
997 GLX_Extensions = glXQueryExtensionsString(display, DefaultScreen(display));
998 TRACE_(d3d_caps)("GLX_Extensions reported:\n");
999
1000 if (NULL == GLX_Extensions) {
1001 ERR(" GLX_Extensions returns NULL\n");
1002 } else {
1003 while (*GLX_Extensions != 0x00) {
1004 const char *Start = GLX_Extensions;
1005 char ThisExtn[256];
1006
1007 memset(ThisExtn, 0x00, sizeof(ThisExtn));
1008 while (*GLX_Extensions != ' ' && *GLX_Extensions != 0x00) {
1009 GLX_Extensions++;
1010 }
1011 memcpy(ThisExtn, Start, (GLX_Extensions - Start));
1012 TRACE_(d3d_caps)("- %s\n", ThisExtn);
1013 if (*GLX_Extensions == ' ') GLX_Extensions++;
1014 }
1015 }
1016 }
1017
1018 /* If we created a dummy context, throw it away */
1019 if (NULL != fake_ctx) WineD3D_ReleaseFakeGLContext(fake_ctx);
1020
1021 /* Only save the values obtained when a display is provided */
1022 if (fake_ctx == NULL) {
1023 return TRUE;
1024 } else {
1025 return FALSE;
1026 }
1027 }
1028
1029 /**********************************************************
1030 * IWineD3D implementation follows
1031 **********************************************************/
1032
1033 static UINT WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
1034 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1035
1036 /* FIXME: Set to one for now to imply the display */
1037 TRACE_(d3d_caps)("(%p): Mostly stub, only returns primary display\n", This);
1038 return 1;
1039 }
1040
1041 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void* pInitializeFunction) {
1042 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1043 FIXME("(%p)->(%p): stub\n", This, pInitializeFunction);
1044 return WINED3D_OK;
1045 }
1046
1047 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
1048 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1049 POINT pt = { -1, -1 };
1050
1051 if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
1052 return NULL;
1053 }
1054
1055 FIXME_(d3d_caps)("(%p): returning the primary monitor for adapter %d\n", This, Adapter);
1056 return MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
1057 }
1058
1059 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1060 of the same bpp but different resolutions */
1061
1062 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1063 static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
1064 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1065 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
1066
1067 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1068 return 0;
1069 }
1070
1071 if (Adapter == 0) { /* Display */
1072 int i = 0;
1073 int j = 0;
1074 #if !defined( DEBUG_SINGLE_MODE )
1075 DEVMODEW DevModeW;
1076
1077 /* Work out the current screen bpp */
1078 HDC hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1079 int bpp = GetDeviceCaps(hdc, BITSPIXEL);
1080 DeleteDC(hdc);
1081
1082 while (EnumDisplaySettingsExW(NULL, j, &DevModeW, 0)) {
1083 j++;
1084 switch (Format)
1085 {
1086 case WINED3DFMT_UNKNOWN:
1087 i++;
1088 break;
1089 case WINED3DFMT_X8R8G8B8:
1090 case WINED3DFMT_A8R8G8B8:
1091 if (min(DevModeW.dmBitsPerPel, bpp) == 32) i++;
1092 if (min(DevModeW.dmBitsPerPel, bpp) == 24) i++;
1093 break;
1094 case WINED3DFMT_X1R5G5B5:
1095 case WINED3DFMT_A1R5G5B5:
1096 case WINED3DFMT_R5G6B5:
1097 if (min(DevModeW.dmBitsPerPel, bpp) == 16) i++;
1098 break;
1099 default:
1100 /* Skip other modes as they do not match the requested format */
1101 break;
1102 }
1103 }
1104 #else
1105 i = 1;
1106 j = 1;
1107 #endif
1108 TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
1109 return i;
1110 } else {
1111 FIXME_(d3d_caps)("Adapter not primary display\n");
1112 }
1113 return 0;
1114 }
1115
1116 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1117 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
1118 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1119 TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
1120
1121 /* Validate the parameters as much as possible */
1122 if (NULL == pMode ||
1123 Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
1124 Mode >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
1125 return WINED3DERR_INVALIDCALL;
1126 }
1127
1128 if (Adapter == 0) { /* Display */
1129 int bpp;
1130 #if !defined( DEBUG_SINGLE_MODE )
1131 DEVMODEW DevModeW;
1132 int ModeIdx = 0;
1133
1134 /* Work out the current screen bpp */
1135 HDC hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1136 bpp = GetDeviceCaps(hdc, BITSPIXEL);
1137 DeleteDC(hdc);
1138
1139 /* If we are filtering to a specific format, then need to skip all unrelated
1140 modes, but if mode is irrelevant, then we can use the index directly */
1141 if (Format == WINED3DFMT_UNKNOWN)
1142 {
1143 ModeIdx = Mode;
1144 } else {
1145 int i = 0;
1146 int j = 0;
1147 DEVMODEW DevModeWtmp;
1148
1149
1150 while (i<(Mode) && EnumDisplaySettingsExW(NULL, j, &DevModeWtmp, 0)) {
1151 j++;
1152 switch (Format)
1153 {
1154 case WINED3DFMT_UNKNOWN:
1155 i++;
1156 break;
1157 case WINED3DFMT_X8R8G8B8:
1158 case WINED3DFMT_A8R8G8B8:
1159 if (min(DevModeWtmp.dmBitsPerPel, bpp) == 32) i++;
1160 if (min(DevModeWtmp.dmBitsPerPel, bpp) == 24) i++;
1161 break;
1162 case WINED3DFMT_X1R5G5B5:
1163 case WINED3DFMT_A1R5G5B5:
1164 case WINED3DFMT_R5G6B5:
1165 if (min(DevModeWtmp.dmBitsPerPel, bpp) == 16) i++;
1166 break;
1167 default:
1168 /* Skip other modes as they do not match requested format */
1169 break;
1170 }
1171 }
1172 ModeIdx = j;
1173 }
1174
1175 /* Now get the display mode via the calculated index */
1176 if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0))
1177 {
1178 pMode->Width = DevModeW.dmPelsWidth;
1179 pMode->Height = DevModeW.dmPelsHeight;
1180 bpp = min(DevModeW.dmBitsPerPel, bpp);
1181 pMode->RefreshRate = D3DADAPTER_DEFAULT;
1182 if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
1183 {
1184 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1185 }
1186
1187 if (Format == WINED3DFMT_UNKNOWN)
1188 {
1189 switch (bpp) {
1190 case 8: pMode->Format = WINED3DFMT_R3G3B2; break;
1191 case 16: pMode->Format = WINED3DFMT_R5G6B5; break;
1192 case 24: /* Robots and EVE Online need 24 and 32 bit as A8R8G8B8 to start */
1193 case 32: pMode->Format = WINED3DFMT_A8R8G8B8; break;
1194 default: pMode->Format = WINED3DFMT_UNKNOWN;
1195 }
1196 } else {
1197 pMode->Format = Format;
1198 }
1199 }
1200 else
1201 {
1202 TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
1203 return WINED3DERR_INVALIDCALL;
1204 }
1205
1206 #else
1207 /* Return one setting of the format requested */
1208 if (Mode > 0) return WINED3DERR_INVALIDCALL;
1209 pMode->Width = 800;
1210 pMode->Height = 600;
1211 pMode->RefreshRate = D3DADAPTER_DEFAULT;
1212 pMode->Format = (Format == WINED3DFMT_UNKNOWN) ? WINED3DFMT_A8R8G8B8 : Format;
1213 bpp = 32;
1214 #endif
1215 TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
1216 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format), bpp);
1217
1218 } else {
1219 FIXME_(d3d_caps)("Adapter not primary display\n");
1220 }
1221
1222 return WINED3D_OK;
1223 }
1224
1225 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE* pMode) {
1226 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1227 TRACE_(d3d_caps)("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode);
1228
1229 if (NULL == pMode ||
1230 Adapter >= IWineD3D_GetAdapterCount(iface)) {
1231 return WINED3DERR_INVALIDCALL;
1232 }
1233
1234 if (Adapter == 0) { /* Display */
1235 int bpp = 0;
1236 DEVMODEW DevModeW;
1237
1238 EnumDisplaySettingsExW(NULL, (DWORD)-1, &DevModeW, 0);
1239 pMode->Width = DevModeW.dmPelsWidth;
1240 pMode->Height = DevModeW.dmPelsHeight;
1241 bpp = DevModeW.dmBitsPerPel;
1242 pMode->RefreshRate = D3DADAPTER_DEFAULT;
1243 if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
1244 {
1245 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1246 }
1247
1248 switch (bpp) {
1249 case 8: pMode->Format = WINED3DFMT_R3G3B2; break;
1250 case 16: pMode->Format = WINED3DFMT_R5G6B5; break;
1251 case 24: pMode->Format = WINED3DFMT_X8R8G8B8; break; /* Robots needs 24bit to be X8R8G8B8 */
1252 case 32: pMode->Format = WINED3DFMT_X8R8G8B8; break; /* EVE online and the Fur demo need 32bit AdapterDisplatMode to return X8R8G8B8 */
1253 default: pMode->Format = WINED3DFMT_UNKNOWN;
1254 }
1255
1256 } else {
1257 FIXME_(d3d_caps)("Adapter not primary display\n");
1258 }
1259
1260 TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
1261 pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
1262 return WINED3D_OK;
1263 }
1264
1265 static Display * WINAPI IWineD3DImpl_GetAdapterDisplay(IWineD3D *iface, UINT Adapter) {
1266 Display *display;
1267 HDC device_context;
1268 /* only works with one adapter at the moment... */
1269
1270 /* Get the display */
1271 device_context = GetDC(0);
1272 display = get_display(device_context);
1273 ReleaseDC(0, device_context);
1274 return display;
1275 }
1276
1277 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1278 and fields being inserted in the middle, a new structure is used in place */
1279 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
1280 WINED3DADAPTER_IDENTIFIER* pIdentifier) {
1281 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1282
1283 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
1284
1285 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1286 return WINED3DERR_INVALIDCALL;
1287 }
1288
1289 if (Adapter == 0) { /* Display - only device supported for now */
1290
1291 BOOL isGLInfoValid = This->isGLInfoValid;
1292
1293 /* FillGLCaps updates gl_info, but we only want to store and
1294 reuse the values once we have a context which is valid. Values from
1295 a temporary context may differ from the final ones */
1296 if (!isGLInfoValid) {
1297 WineD3D_Context *fake_ctx = NULL;
1298 if (glXGetCurrentContext() == NULL) fake_ctx = WineD3D_CreateFakeGLContext();
1299 /* If we don't know the device settings, go query them now */
1300 isGLInfoValid = IWineD3DImpl_FillGLCaps(iface, IWineD3DImpl_GetAdapterDisplay(iface, Adapter));
1301 if (fake_ctx != NULL) WineD3D_ReleaseFakeGLContext(fake_ctx);
1302 }
1303
1304 /* If it worked, return the information requested */
1305 if (isGLInfoValid) {
1306 TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
1307 strcpy(pIdentifier->Driver, "Display");
1308 strcpy(pIdentifier->Description, "Direct3D HAL");
1309
1310 /* Note dx8 doesn't supply a DeviceName */
1311 if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1312 /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
1313 pIdentifier->DriverVersion->u.HighPart = MAKEDWORD_VERSION(6, 14);
1314 pIdentifier->DriverVersion->u.LowPart = This->gl_info.gl_driver_version;
1315 *(pIdentifier->VendorId) = This->gl_info.gl_vendor;
1316 *(pIdentifier->DeviceId) = This->gl_info.gl_card;
1317 *(pIdentifier->SubSysId) = 0;
1318 *(pIdentifier->Revision) = 0;
1319
1320 } else {
1321
1322 /* If it failed, return dummy values from an NVidia driver */
1323 WARN_(d3d_caps)("Cannot get GLCaps for device/Vendor Name and Version detection using FillGLCaps, currently using NVIDIA identifiers\n");
1324 strcpy(pIdentifier->Driver, "Display");
1325 strcpy(pIdentifier->Description, "Direct3D HAL");
1326 if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1327 /* Current Windows Nvidia drivers have versions like e.g. 6.14.10.5672 */
1328 pIdentifier->DriverVersion->u.HighPart = MAKEDWORD_VERSION(6, 14);
1329 /* 71.74 is a current Linux Nvidia driver version */
1330 pIdentifier->DriverVersion->u.LowPart = MAKEDWORD_VERSION(10, (71*100+74));
1331 *(pIdentifier->VendorId) = VENDOR_NVIDIA;
1332 *(pIdentifier->DeviceId) = CARD_NVIDIA_GEFORCE4_TI4200;
1333 *(pIdentifier->SubSysId) = 0;
1334 *(pIdentifier->Revision) = 0;
1335 }
1336
1337 /*FIXME: memcpy(&pIdentifier->DeviceIdentifier, ??, sizeof(??GUID)); */
1338 if (Flags & D3DENUM_NO_WHQL_LEVEL) {
1339 *(pIdentifier->WHQLLevel) = 0;
1340 } else {
1341 *(pIdentifier->WHQLLevel) = 1;
1342 }
1343
1344 } else {
1345 FIXME_(d3d_caps)("Adapter not primary display\n");
1346 }
1347
1348 return WINED3D_OK;
1349 }
1350
1351 static BOOL IWineD3DImpl_IsGLXFBConfigCompatibleWithRenderFmt(Display *display, GLXFBConfig cfgs, WINED3DFORMAT Format) {
1352 #if 0 /* This code performs a strict test between the format and the current X11 buffer depth, which may give the best performance */
1353 int gl_test;
1354 int rb, gb, bb, ab, type, buf_sz;
1355
1356 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_RED_SIZE, &rb);
1357 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_GREEN_SIZE, &gb);
1358 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_BLUE_SIZE, &bb);
1359 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_ALPHA_SIZE, &ab);
1360 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_RENDER_TYPE, &type);
1361 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_BUFFER_SIZE, &buf_sz);
1362
1363 switch (Format) {
1364 case WINED3DFMT_X8R8G8B8:
1365 case WINED3DFMT_R8G8B8:
1366 if (8 == rb && 8 == gb && 8 == bb) return TRUE;
1367 break;
1368 case WINED3DFMT_A8R8G8B8:
1369 if (8 == rb && 8 == gb && 8 == bb && 8 == ab) return TRUE;
1370 break;
1371 case WINED3DFMT_A2R10G10B10:
1372 if (10 == rb && 10 == gb && 10 == bb && 2 == ab) return TRUE;
1373 break;
1374 case WINED3DFMT_X1R5G5B5:
1375 if (5 == rb && 5 == gb && 5 == bb) return TRUE;
1376 break;
1377 case WINED3DFMT_A1R5G5B5:
1378 if (5 == rb && 5 == gb && 5 == bb && 1 == ab) return TRUE;
1379 break;
1380 case WINED3DFMT_X4R4G4B4:
1381 if (16 == buf_sz && 4 == rb && 4 == gb && 4 == bb) return TRUE;
1382 break;
1383 case WINED3DFMT_R5G6B5:
1384 if (5 == rb && 6 == gb && 5 == bb) return TRUE;
1385 break;
1386 case WINED3DFMT_R3G3B2:
1387 if (3 == rb && 3 == gb && 2 == bb) return TRUE;
1388 break;
1389 case WINED3DFMT_A8P8:
1390 if (type & GLX_COLOR_INDEX_BIT && 8 == buf_sz && 8 == ab) return TRUE;
1391 break;
1392 case WINED3DFMT_P8:
1393 if (type & GLX_COLOR_INDEX_BIT && 8 == buf_sz) return TRUE;
1394 break;
1395 default:
1396 ERR("unsupported format %s\n", debug_d3dformat(Format));
1397 break;
1398 }
1399 return FALSE;
1400 #else /* Most of the time performance is less of an issue than compatibility, this code allows for most common opengl/d3d formats */
1401 switch (Format) {
1402 case WINED3DFMT_X8R8G8B8:
1403 case WINED3DFMT_R8G8B8:
1404 case WINED3DFMT_A8R8G8B8:
1405 case WINED3DFMT_A2R10G10B10:
1406 case WINED3DFMT_X1R5G5B5:
1407 case WINED3DFMT_A1R5G5B5:
1408 case WINED3DFMT_R5G6B5:
1409 case WINED3DFMT_R3G3B2:
1410 case WINED3DFMT_A8P8:
1411 case WINED3DFMT_P8:
1412 return TRUE;
1413 default:
1414 ERR("unsupported format %s\n", debug_d3dformat(Format));
1415 break;
1416 }
1417 return FALSE;
1418 #endif
1419 }
1420
1421 static BOOL IWineD3DImpl_IsGLXFBConfigCompatibleWithDepthFmt(Display *display, GLXFBConfig cfgs, WINED3DFORMAT Format) {
1422 #if 0/* This code performs a strict test between the format and the current X11 buffer depth, which may give the best performance */
1423 int gl_test;
1424 int db, sb;
1425
1426 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_DEPTH_SIZE, &db);
1427 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_STENCIL_SIZE, &sb);
1428
1429 switch (Format) {
1430 case WINED3DFMT_D16:
1431 case WINED3DFMT_D16_LOCKABLE:
1432 if (16 == db) return TRUE;
1433 break;
1434 case WINED3DFMT_D32:
1435 if (32 == db) return TRUE;
1436 break;
1437 case WINED3DFMT_D15S1:
1438 if (15 == db) return TRUE;
1439 break;
1440 case WINED3DFMT_D24S8:
1441 if (24 == db && 8 == sb) return TRUE;
1442 break;
1443 case WINED3DFMT_D24FS8:
1444 if (24 == db && 8 == sb) return TRUE;
1445 break;
1446 case WINED3DFMT_D24X8:
1447 if (24 == db) return TRUE;
1448 break;
1449 case WINED3DFMT_D24X4S4:
1450 if (24 == db && 4 == sb) return TRUE;
1451 break;
1452 case WINED3DFMT_D32F_LOCKABLE:
1453 if (32 == db) return TRUE;
1454 break;
1455 default:
1456 ERR("unsupported format %s\n", debug_d3dformat(Format));
1457 break;
1458 }
1459 return FALSE;
1460 #else /* Most of the time performance is less of an issue than compatibility, this code allows for most common opengl/d3d formats */
1461 switch (Format) {
1462 case WINED3DFMT_D16:
1463 case WINED3DFMT_D16_LOCKABLE:
1464 case WINED3DFMT_D32:
1465 case WINED3DFMT_D15S1:
1466 case WINED3DFMT_D24S8:
1467 case WINED3DFMT_D24FS8:
1468 case WINED3DFMT_D24X8:
1469 case WINED3DFMT_D24X4S4:
1470 case WINED3DFMT_D32F_LOCKABLE:
1471 return TRUE;
1472 default:
1473 ERR("unsupported format %s\n", debug_d3dformat(Format));
1474 break;
1475 }
1476 return FALSE;
1477 #endif
1478 }
1479
1480 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1481 WINED3DFORMAT AdapterFormat,
1482 WINED3DFORMAT RenderTargetFormat,
1483 WINED3DFORMAT DepthStencilFormat) {
1484 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1485 HRESULT hr = WINED3DERR_NOTAVAILABLE;
1486 WineD3D_Context* ctx = NULL;
1487 GLXFBConfig* cfgs = NULL;
1488 int nCfgs = 0;
1489 int it;
1490
1491 WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1492 This, Adapter,
1493 DeviceType, debug_d3ddevicetype(DeviceType),
1494 AdapterFormat, debug_d3dformat(AdapterFormat),
1495 RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
1496 DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
1497
1498 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1499 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
1500 return WINED3DERR_INVALIDCALL;
1501 }
1502 /* TODO: use the real context if it's available */
1503 ctx = WineD3D_CreateFakeGLContext();
1504 if(NULL != ctx) {
1505 cfgs = glXGetFBConfigs(ctx->display, DefaultScreen(ctx->display), &nCfgs);
1506 } else {
1507 TRACE_(d3d_caps)("(%p) : Unable to create a fake context at this time (there may already be an active context)\n", This);
1508 }
1509
1510 if (NULL != cfgs) {
1511 for (it = 0; it < nCfgs; ++it) {
1512 if (IWineD3DImpl_IsGLXFBConfigCompatibleWithRenderFmt(ctx->display, cfgs[it], RenderTargetFormat)) {
1513 if (IWineD3DImpl_IsGLXFBConfigCompatibleWithDepthFmt(ctx->display, cfgs[it], DepthStencilFormat)) {
1514 hr = WINED3D_OK;
1515 break ;
1516 }
1517 }
1518 }
1519 XFree(cfgs);
1520 cfgs = NULL;
1521 } else {
1522 /* If there's a current context then we cannot create a fake one so pass everything */
1523 hr = WINED3D_OK;
1524 }
1525
1526 if (ctx != NULL)
1527 WineD3D_ReleaseFakeGLContext(ctx);
1528
1529 if (hr != WINED3D_OK)
1530 TRACE_(d3d_caps)("Failed to match stencil format to device\n");
1531
1532 TRACE_(d3d_caps)("(%p) : Returning %x\n", This, hr);
1533 return hr;
1534 }
1535
1536 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1537 WINED3DFORMAT SurfaceFormat,
1538 BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) {
1539
1540 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1541 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1542 This,
1543 Adapter,
1544 DeviceType, debug_d3ddevicetype(DeviceType),
1545 SurfaceFormat, debug_d3dformat(SurfaceFormat),
1546 Windowed,
1547 MultiSampleType,
1548 pQualityLevels);
1549
1550 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1551 return WINED3DERR_INVALIDCALL;
1552 }
1553
1554 if (pQualityLevels != NULL) {
1555 static int s_single_shot = 0;
1556 if (!s_single_shot) {
1557 FIXME("Quality levels unsupported at present\n");
1558 s_single_shot = 1;
1559 }
1560 *pQualityLevels = 1; /* Guess at a value! */
1561 }
1562
1563 if (WINED3DMULTISAMPLE_NONE == MultiSampleType) return WINED3D_OK;
1564 return WINED3DERR_NOTAVAILABLE;
1565 }
1566
1567 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE CheckType,
1568 WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed) {
1569
1570 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1571 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1572 This,
1573 Adapter,
1574 CheckType, debug_d3ddevicetype(CheckType),
1575 DisplayFormat, debug_d3dformat(DisplayFormat),
1576 BackBufferFormat, debug_d3dformat(BackBufferFormat),
1577 Windowed);
1578
1579 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1580 WARN_(d3d_caps)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
1581 return WINED3DERR_INVALIDCALL;
1582 }
1583
1584 {
1585 GLXFBConfig* cfgs = NULL;
1586 int nCfgs = 0;
1587 int it;
1588 HRESULT hr = WINED3DERR_NOTAVAILABLE;
1589
1590 WineD3D_Context* ctx = WineD3D_CreateFakeGLContext();
1591 if (NULL != ctx) {
1592 cfgs = glXGetFBConfigs(ctx->display, DefaultScreen(ctx->display), &nCfgs);
1593 for (it = 0; it < nCfgs; ++it) {
1594 if (IWineD3DImpl_IsGLXFBConfigCompatibleWithRenderFmt(ctx->display, cfgs[it], DisplayFormat)) {
1595 hr = WINED3D_OK;
1596 break ;
1597 }
1598 }
1599 XFree(cfgs);
1600
1601 WineD3D_ReleaseFakeGLContext(ctx);
1602 return hr;
1603 }
1604 }
1605
1606 return WINED3DERR_NOTAVAILABLE;
1607 }
1608
1609 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1610 WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat) {
1611 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1612 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
1613 This,
1614 Adapter,
1615 DeviceType, debug_d3ddevicetype(DeviceType),
1616 AdapterFormat, debug_d3dformat(AdapterFormat),
1617 Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
1618 RType, debug_d3dresourcetype(RType),
1619 CheckFormat, debug_d3dformat(CheckFormat));
1620
1621 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1622 return WINED3DERR_INVALIDCALL;
1623 }
1624
1625 /* TODO: Check support against more of the WINED3DUSAGE_QUERY_* constants
1626 * See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/IDirect3D9__CheckDeviceFormat.asp
1627 * and http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/D3DUSAGE_QUERY.asp */
1628 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
1629 TRACE_(d3d_caps)("[FAILED]\n");
1630 return WINED3DERR_NOTAVAILABLE; /* Enable when fully supported */
1631 }
1632
1633 if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
1634 switch (CheckFormat) {
1635 case WINED3DFMT_D16_LOCKABLE:
1636 case WINED3DFMT_D32:
1637 case WINED3DFMT_D15S1:
1638 case WINED3DFMT_D24S8:
1639 case WINED3DFMT_D24X8:
1640 case WINED3DFMT_D24X4S4:
1641 case WINED3DFMT_D16:
1642 case WINED3DFMT_L16:
1643 case WINED3DFMT_D32F_LOCKABLE:
1644 case WINED3DFMT_D24FS8:
1645 TRACE_(d3d_caps)("[OK]\n");
1646 return WINED3D_OK;
1647 default:
1648 TRACE_(d3d_caps)("[FAILED]\n");
1649 return WINED3DERR_NOTAVAILABLE;
1650 }
1651 } else if(Usage & WINED3DUSAGE_RENDERTARGET) {
1652 switch (CheckFormat) {
1653 case WINED3DFMT_R8G8B8:
1654 case WINED3DFMT_A8R8G8B8:
1655 case WINED3DFMT_X8R8G8B8:
1656 case WINED3DFMT_R5G6B5:
1657 case WINED3DFMT_X1R5G5B5:
1658 case WINED3DFMT_A1R5G5B5:
1659 case WINED3DFMT_A4R4G4B4:
1660 case WINED3DFMT_R3G3B2:
1661 case WINED3DFMT_X4R4G4B4:
1662 case WINED3DFMT_A8B8G8R8:
1663 case WINED3DFMT_X8B8G8R8:
1664 case WINED3DFMT_P8:
1665 TRACE_(d3d_caps)("[OK]\n");
1666 return WINED3D_OK;
1667 default:
1668 TRACE_(d3d_caps)("[FAILED]\n");
1669 return WINED3DERR_NOTAVAILABLE;
1670 }
1671 }
1672
1673 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
1674 switch (CheckFormat) {
1675 case WINED3DFMT_DXT1:
1676 case WINED3DFMT_DXT2:
1677 case WINED3DFMT_DXT3:
1678 case WINED3DFMT_DXT4:
1679 case WINED3DFMT_DXT5:
1680 TRACE_(d3d_caps)("[OK]\n");
1681 return WINED3D_OK;
1682 default:
1683 break; /* Avoid compiler warnings */
1684 }
1685 }
1686
1687 if (GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
1688
1689 BOOL half_pixel_support = GL_SUPPORT(ARB_HALF_FLOAT_PIXEL);
1690
1691 switch (CheckFormat) {
1692 case WINED3DFMT_R16F:
1693 case WINED3DFMT_A16B16G16R16F:
1694 if (!half_pixel_support) break;
1695 case WINED3DFMT_R32F:
1696 case WINED3DFMT_A32B32G32R32F:
1697 TRACE_(d3d_caps)("[OK]\n");
1698 return WINED3D_OK;
1699 default:
1700 break; /* Avoid compiler warnings */
1701 }
1702 }
1703
1704 /* This format is nothing special and it is supported perfectly.
1705 * However, ati and nvidia driver on windows do not mark this format as
1706 * supported (tested with the dxCapsViewer) and pretending to
1707 * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
1708 * So do the same as Windows drivers and pretend not to support it on dx8 and 9
1709 * Enable it on dx7. It will need additional checking on dx10 when we support it.
1710 */
1711 if(This->dxVersion > 7 && CheckFormat == WINED3DFMT_R8G8B8) {
1712 TRACE_(d3d_caps)("[FAILED]\n");
1713 return WINED3DERR_NOTAVAILABLE;
1714 }
1715
1716 switch (CheckFormat) {
1717
1718 /*****
1719 * supported: RGB(A) formats
1720 */
1721 case WINED3DFMT_R8G8B8: /* Enable for dx7, blacklisted for 8 and 9 above */
1722 case WINED3DFMT_A8R8G8B8:
1723 case WINED3DFMT_X8R8G8B8:
1724 case WINED3DFMT_R5G6B5:
1725 case WINED3DFMT_X1R5G5B5:
1726 case WINED3DFMT_A1R5G5B5:
1727 case WINED3DFMT_A4R4G4B4:
1728 case WINED3DFMT_R3G3B2:
1729 case WINED3DFMT_A8:
1730 case WINED3DFMT_A8R3G3B2:
1731 case WINED3DFMT_X4R4G4B4:
1732 case WINED3DFMT_A8B8G8R8:
1733 case WINED3DFMT_X8B8G8R8:
1734 case WINED3DFMT_A2R10G10B10:
1735 case WINED3DFMT_A2B10G10R10:
1736 TRACE_(d3d_caps)("[OK]\n");
1737 return WINED3D_OK;
1738
1739 /*****
1740 * supported: Palettized
1741 */
1742 case WINED3DFMT_P8:
1743 TRACE_(d3d_caps)("[OK]\n");
1744 return WINED3D_OK;
1745
1746 /*****
1747 * Supported: (Alpha)-Luminance
1748 */
1749 case WINED3DFMT_L8:
1750 case WINED3DFMT_A8L8:
1751 case WINED3DFMT_A4L4:
1752 TRACE_(d3d_caps)("[OK]\n");
1753 return WINED3D_OK;
1754
1755 /*****
1756 * Not supported for now: Bump mapping formats
1757 * Enable some because games often fail when they are not available
1758 * and are still playable even without bump mapping
1759 */
1760 case WINED3DFMT_V8U8:
1761 case WINED3DFMT_V16U16:
1762 case WINED3DFMT_L6V5U5:
1763 case WINED3DFMT_X8L8V8U8:
1764 case WINED3DFMT_Q8W8V8U8:
1765 case WINED3DFMT_W11V11U10:
1766 case WINED3DFMT_A2W10V10U10:
1767 WARN_(d3d_caps)("[Not supported, but pretended to do]\n");
1768 return WINED3D_OK;
1769
1770 /*****
1771 * DXTN Formats: Handled above
1772 * WINED3DFMT_DXT1
1773 * WINED3DFMT_DXT2
1774 * WINED3DFMT_DXT3
1775 * WINED3DFMT_DXT4
1776 * WINED3DFMT_DXT5
1777 */
1778
1779 /*****
1780 * Odd formats - not supported
1781 */
1782 case WINED3DFMT_VERTEXDATA:
1783 case WINED3DFMT_INDEX16:
1784 case WINED3DFMT_INDEX32:
1785 case WINED3DFMT_Q16W16V16U16:
1786 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1787 return WINED3DERR_NOTAVAILABLE;
1788
1789 /*****
1790 * Float formats: Not supported right now
1791 */
1792 case WINED3DFMT_G16R16F:
1793 case WINED3DFMT_G32R32F:
1794 case WINED3DFMT_CxV8U8:
1795 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1796 return WINED3DERR_NOTAVAILABLE;
1797
1798 /* Not supported */
1799 case WINED3DFMT_G16R16:
1800 case WINED3DFMT_A16B16G16R16:
1801 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1802 return WINED3DERR_NOTAVAILABLE;
1803
1804 default:
1805 break;
1806 }
1807
1808 TRACE_(d3d_caps)("[FAILED]\n");
1809 return WINED3DERR_NOTAVAILABLE;
1810 }
1811
1812 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1813 WINED3DFORMAT SourceFormat, WINED3DFORMAT TargetFormat) {
1814 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1815
1816 FIXME_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
1817 This,
1818 Adapter,
1819 DeviceType, debug_d3ddevicetype(DeviceType),
1820 SourceFormat, debug_d3dformat(SourceFormat),
1821 TargetFormat, debug_d3dformat(TargetFormat));
1822 return WINED3D_OK;
1823 }
1824
1825 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
1826 subset of a D3DCAPS9 structure. However, it has to come via a void *
1827 as the d3d8 interface cannot import the d3d9 header */
1828 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
1829
1830 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1831 int vs_selected_mode;
1832 int ps_selected_mode;
1833
1834 TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
1835
1836 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1837 return WINED3DERR_INVALIDCALL;
1838 }
1839
1840 /* FIXME: GL info should be per adapter */
1841
1842 /* If we don't know the device settings, go query them now */
1843 if (!This->isGLInfoValid) {
1844 /* use the desktop window to fill gl caps */
1845 BOOL rc = IWineD3DImpl_FillGLCaps(iface, IWineD3DImpl_GetAdapterDisplay(iface, Adapter));
1846
1847 /* We are running off a real context, save the values */
1848 if (rc) This->isGLInfoValid = TRUE;
1849 }
1850 select_shader_mode(&This->gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
1851
1852 /* This function should *not* be modifying GL caps
1853 * TODO: move the functionality where it belongs */
1854 select_shader_max_constants(ps_selected_mode, vs_selected_mode, &This->gl_info);
1855
1856 /* ------------------------------------------------
1857 The following fields apply to both d3d8 and d3d9
1858 ------------------------------------------------ */
1859 *pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
1860 *pCaps->AdapterOrdinal = Adapter;
1861
1862 *pCaps->Caps = 0;
1863 *pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
1864 WINED3DCAPS2_FULLSCREENGAMMA;
1865 *pCaps->Caps3 = 0;
1866 *pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_IMMEDIATE;
1867
1868 *pCaps->CursorCaps = 0;
1869
1870
1871 *pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
1872 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
1873 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
1874 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
1875 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
1876 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
1877 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
1878 WINED3DDEVCAPS_PUREDEVICE |
1879 WINED3DDEVCAPS_HWRASTERIZATION |
1880 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
1881 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
1882 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
1883 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
1884 WINED3DDEVCAPS_DRAWPRIMITIVES2EX;
1885
1886 *pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_CULLNONE |
1887 D3DPMISCCAPS_CULLCCW |
1888 D3DPMISCCAPS_CULLCW |
1889 D3DPMISCCAPS_COLORWRITEENABLE |
1890 D3DPMISCCAPS_CLIPTLVERTS |
1891 D3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
1892 D3DPMISCCAPS_MASKZ |
1893 D3DPMISCCAPS_BLENDOP;
1894 /* TODO:
1895 D3DPMISCCAPS_NULLREFERENCE
1896 D3DPMISCCAPS_INDEPENDENTWRITEMASKS
1897 D3DPMISCCAPS_FOGANDSPECULARALPHA
1898 D3DPMISCCAPS_SEPARATEALPHABLEND
1899 D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
1900 D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING
1901 D3DPMISCCAPS_FOGVERTEXCLAMPED */
1902
1903 /* The caps below can be supported but aren't handled yet in utils.c 'd3dta_to_combiner_input', disable them until support is fixed */
1904 #if 0
1905 if (GL_SUPPORT(NV_REGISTER_COMBINERS))
1906 *pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_TSSARGTEMP;
1907 if (GL_SUPPORT(NV_REGISTER_COMBINERS2))
1908 *pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_PERSTAGECONSTANT;
1909 #endif
1910
1911 *pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
1912 WINED3DPRASTERCAPS_PAT |
1913 WINED3DPRASTERCAPS_WFOG |
1914 WINED3DPRASTERCAPS_ZFOG |
1915 WINED3DPRASTERCAPS_FOGVERTEX |
1916 WINED3DPRASTERCAPS_FOGTABLE |
1917 WINED3DPRASTERCAPS_FOGRANGE |
1918 WINED3DPRASTERCAPS_STIPPLE |
1919 WINED3DPRASTERCAPS_SUBPIXEL |
1920 WINED3DPRASTERCAPS_ZTEST |
1921 WINED3DPRASTERCAPS_SCISSORTEST |
1922 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
1923 WINED3DPRASTERCAPS_DEPTHBIAS;
1924
1925 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
1926 *pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
1927 WINED3DPRASTERCAPS_ZBIAS |
1928 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
1929 }
1930 /* FIXME Add:
1931 WINED3DPRASTERCAPS_COLORPERSPECTIVE
1932 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
1933 WINED3DPRASTERCAPS_ANTIALIASEDGES
1934 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
1935 WINED3DPRASTERCAPS_WBUFFER */
1936
1937 *pCaps->ZCmpCaps = D3DPCMPCAPS_ALWAYS |
1938 D3DPCMPCAPS_EQUAL |
1939 D3DPCMPCAPS_GREATER |
1940 D3DPCMPCAPS_GREATEREQUAL |
1941 D3DPCMPCAPS_LESS |
1942 D3DPCMPCAPS_LESSEQUAL |
1943 D3DPCMPCAPS_NEVER |
1944 D3DPCMPCAPS_NOTEQUAL;
1945
1946 *pCaps->SrcBlendCaps = D3DPBLENDCAPS_BLENDFACTOR |
1947 D3DPBLENDCAPS_BOTHINVSRCALPHA |
1948 D3DPBLENDCAPS_BOTHSRCALPHA |
1949 D3DPBLENDCAPS_DESTALPHA |
1950 D3DPBLENDCAPS_DESTCOLOR |
1951 D3DPBLENDCAPS_INVDESTALPHA |
1952 D3DPBLENDCAPS_INVDESTCOLOR |
1953 D3DPBLENDCAPS_INVSRCALPHA |
1954 D3DPBLENDCAPS_INVSRCCOLOR |
1955 D3DPBLENDCAPS_ONE |
1956 D3DPBLENDCAPS_SRCALPHA |
1957 D3DPBLENDCAPS_SRCALPHASAT |
1958 D3DPBLENDCAPS_SRCCOLOR |
1959 D3DPBLENDCAPS_ZERO;
1960
1961 *pCaps->DestBlendCaps = D3DPBLENDCAPS_BLENDFACTOR |
1962 D3DPBLENDCAPS_BOTHINVSRCALPHA |
1963 D3DPBLENDCAPS_BOTHSRCALPHA |
1964 D3DPBLENDCAPS_DESTALPHA |
1965 D3DPBLENDCAPS_DESTCOLOR |
1966 D3DPBLENDCAPS_INVDESTALPHA |
1967 D3DPBLENDCAPS_INVDESTCOLOR |
1968 D3DPBLENDCAPS_INVSRCALPHA |
1969 D3DPBLENDCAPS_INVSRCCOLOR |
1970 D3DPBLENDCAPS_ONE |
1971 D3DPBLENDCAPS_SRCALPHA |
1972 D3DPBLENDCAPS_SRCALPHASAT |
1973 D3DPBLENDCAPS_SRCCOLOR |
1974 D3DPBLENDCAPS_ZERO;
1975
1976 *pCaps->AlphaCmpCaps = D3DPCMPCAPS_ALWAYS |
1977 D3DPCMPCAPS_EQUAL |
1978 D3DPCMPCAPS_GREATER |
1979 D3DPCMPCAPS_GREATEREQUAL |
1980 D3DPCMPCAPS_LESS |
1981 D3DPCMPCAPS_LESSEQUAL |
1982 D3DPCMPCAPS_NEVER |
1983 D3DPCMPCAPS_NOTEQUAL;
1984
1985 *pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
1986 WINED3DPSHADECAPS_COLORGOURAUDRGB |
1987 WINED3DPSHADECAPS_ALPHAFLATBLEND |
1988 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
1989 WINED3DPSHADECAPS_COLORFLATRGB |
1990 WINED3DPSHADECAPS_FOGFLAT |
1991 WINED3DPSHADECAPS_FOGGOURAUD |
1992 WINED3DPSHADECAPS_SPECULARFLATRGB;
1993
1994 *pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
1995 WINED3DPTEXTURECAPS_ALPHAPALETTE |
1996 WINED3DPTEXTURECAPS_BORDER |
1997 WINED3DPTEXTURECAPS_MIPMAP |
1998 WINED3DPTEXTURECAPS_PROJECTED |
1999 WINED3DPTEXTURECAPS_PERSPECTIVE |
2000 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
2001
2002 if( GL_SUPPORT(EXT_TEXTURE3D)) {
2003 *pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
2004 WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
2005 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
2006 }
2007
2008 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2009 *pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
2010 WINED3DPTEXTURECAPS_MIPCUBEMAP |
2011 WINED3DPTEXTURECAPS_CUBEMAP_POW2;
2012
2013 }
2014
2015 *pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
2016 WINED3DPTFILTERCAPS_MAGFPOINT |
2017 WINED3DPTFILTERCAPS_MINFLINEAR |
2018 WINED3DPTFILTERCAPS_MINFPOINT |
2019 WINED3DPTFILTERCAPS_MIPFLINEAR |
2020 WINED3DPTFILTERCAPS_MIPFPOINT |
2021 WINED3DPTFILTERCAPS_LINEAR |
2022 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
2023 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2024 WINED3DPTFILTERCAPS_MIPLINEAR |
2025 WINED3DPTFILTERCAPS_MIPNEAREST |
2026 WINED3DPTFILTERCAPS_NEAREST;
2027
2028 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2029 *pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
2030 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
2031 }
2032
2033 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2034 *pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
2035 WINED3DPTFILTERCAPS_MAGFPOINT |
2036 WINED3DPTFILTERCAPS_MINFLINEAR |
2037 WINED3DPTFILTERCAPS_MINFPOINT |
2038 WINED3DPTFILTERCAPS_MIPFLINEAR |
2039 WINED3DPTFILTERCAPS_MIPFPOINT |
2040 WINED3DPTFILTERCAPS_LINEAR |
2041 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
2042 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2043 WINED3DPTFILTERCAPS_MIPLINEAR |
2044 WINED3DPTFILTERCAPS_MIPNEAREST |
2045 WINED3DPTFILTERCAPS_NEAREST;
2046
2047 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2048 *pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
2049 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
2050 }
2051 } else
2052 *pCaps->CubeTextureFilterCaps = 0;
2053
2054 if (GL_SUPPORT(EXT_TEXTURE3D)) {
2055 *pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
2056 WINED3DPTFILTERCAPS_MAGFPOINT |
2057 WINED3DPTFILTERCAPS_MINFLINEAR |
2058 WINED3DPTFILTERCAPS_MINFPOINT |
2059 WINED3DPTFILTERCAPS_MIPFLINEAR |
2060 WINED3DPTFILTERCAPS_MIPFPOINT |
2061 WINED3DPTFILTERCAPS_LINEAR |
2062 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
2063 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2064 WINED3DPTFILTERCAPS_MIPLINEAR |
2065 WINED3DPTFILTERCAPS_MIPNEAREST |
2066 WINED3DPTFILTERCAPS_NEAREST;
2067 } else
2068 *pCaps->VolumeTextureFilterCaps = 0;
2069
2070 *pCaps->TextureAddressCaps = D3DPTADDRESSCAPS_INDEPENDENTUV |
2071 D3DPTADDRESSCAPS_CLAMP |
2072 D3DPTADDRESSCAPS_WRAP;
2073
2074 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
2075 *pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_BORDER;
2076 }
2077 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
2078 *pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRROR;
2079 }
2080 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
2081 *pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
2082 }
2083
2084 if (GL_SUPPORT(EXT_TEXTURE3D)) {
2085 *pCaps->VolumeTextureAddressCaps = D3DPTADDRESSCAPS_INDEPENDENTUV |
2086 D3DPTADDRESSCAPS_CLAMP |
2087 D3DPTADDRESSCAPS_WRAP;
2088 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
2089 *pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_BORDER;
2090 }
2091 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
2092 *pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRROR;
2093 }
2094 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
2095 *pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
2096 }
2097 } else
2098 *pCaps->VolumeTextureAddressCaps = 0;
2099
2100 *pCaps->LineCaps = D3DLINECAPS_TEXTURE |
2101 D3DLINECAPS_ZTEST;
2102 /* FIXME: Add
2103 D3DLINECAPS_BLEND
2104 D3DLINECAPS_ALPHACMP
2105 D3DLINECAPS_FOG */
2106
2107 *pCaps->MaxTextureWidth = GL_LIMITS(texture_size);
2108 *pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
2109
2110 if(GL_SUPPORT(EXT_TEXTURE3D))
2111 *pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
2112 else
2113 *pCaps->MaxVolumeExtent = 0;
2114
2115 *pCaps->MaxTextureRepeat = 32768;
2116 *pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
2117 *pCaps->MaxVertexW = 1.0;
2118
2119 *pCaps->GuardBandLeft = 0;
2120 *pCaps->GuardBandTop = 0;
2121 *pCaps->GuardBandRight = 0;
2122 *pCaps->GuardBandBottom = 0;
2123
2124 *pCaps->ExtentsAdjust = 0;
2125
2126 *pCaps->StencilCaps = D3DSTENCILCAPS_DECRSAT |
2127 D3DSTENCILCAPS_INCRSAT |
2128 D3DSTENCILCAPS_INVERT |
2129 D3DSTENCILCAPS_KEEP |
2130 D3DSTENCILCAPS_REPLACE |
2131 D3DSTENCILCAPS_ZERO;
2132 if (GL_SUPPORT(EXT_STENCIL_WRAP)) {
2133 *pCaps->StencilCaps |= D3DSTENCILCAPS_DECR |
2134 D3DSTENCILCAPS_INCR;
2135 }
2136 if ( This->dxVersion > 8 &&
2137 ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE) ||
2138 GL_SUPPORT(ATI_SEPARATE_STENCIL) ) ) {
2139 *pCaps->StencilCaps |= D3DSTENCILCAPS_TWOSIDED;
2140 }
2141
2142 *pCaps->FVFCaps = D3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
2143
2144 *pCaps->TextureOpCaps = D3DTEXOPCAPS_ADD |
2145 D3DTEXOPCAPS_ADDSIGNED |
2146 D3DTEXOPCAPS_ADDSIGNED2X |
2147 D3DTEXOPCAPS_MODULATE |
2148 D3DTEXOPCAPS_MODULATE2X |
2149 D3DTEXOPCAPS_MODULATE4X |
2150 D3DTEXOPCAPS_SELECTARG1 |
2151 D3DTEXOPCAPS_SELECTARG2 |
2152 D3DTEXOPCAPS_DISABLE;
2153
2154 if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE) ||
2155 GL_SUPPORT(EXT_TEXTURE_ENV_COMBINE) ||
2156 GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2157 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_BLENDDIFFUSEALPHA |
2158 D3DTEXOPCAPS_BLENDTEXTUREALPHA |
2159 D3DTEXOPCAPS_BLENDFACTORALPHA |
2160 D3DTEXOPCAPS_BLENDCURRENTALPHA |
2161 D3DTEXOPCAPS_LERP |
2162 D3DTEXOPCAPS_SUBTRACT;
2163 }
2164 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2165 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_ADDSMOOTH |
2166 D3DTEXOPCAPS_MULTIPLYADD |
2167 D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
2168 D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
2169 D3DTEXOPCAPS_BLENDTEXTUREALPHAPM;
2170 }
2171 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3))
2172 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_DOTPRODUCT3;
2173
2174 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2175 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
2176 D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
2177 }
2178
2179
2180 #if 0
2181 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_BUMPENVMAP;
2182 /* FIXME: Add
2183 D3DTEXOPCAPS_BUMPENVMAPLUMINANCE
2184 D3DTEXOPCAPS_PREMODULATE */
2185 #endif
2186
2187 *pCaps->MaxTextureBlendStages = GL_LIMITS(texture_stages);
2188 *pCaps->MaxSimultaneousTextures = GL_LIMITS(textures);
2189 *pCaps->MaxUserClipPlanes = GL_LIMITS(clipplanes);
2190 *pCaps->MaxActiveLights = GL_LIMITS(lights);
2191
2192
2193
2194 #if 0 /* TODO: Blends support in drawprim */
2195 *pCaps->MaxVertexBlendMatrices = GL_LIMITS(blends);
2196 #else
2197 *pCaps->MaxVertexBlendMatrices = 0;
2198 #endif
2199 *pCaps->MaxVertexBlendMatrixIndex = 1;
2200
2201 *pCaps->MaxAnisotropy = GL_LIMITS(anisotropy);
2202 *pCaps->MaxPointSize = GL_LIMITS(pointsize);
2203
2204
2205 *pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
2206 WINED3DVTXPCAPS_MATERIALSOURCE7 |
2207 WINED3DVTXPCAPS_POSITIONALLIGHTS |
2208 WINED3DVTXPCAPS_LOCALVIEWER |
2209 WINED3DVTXPCAPS_VERTEXFOG |
2210 WINED3DVTXPCAPS_TEXGEN;
2211 /* FIXME: Add
2212 D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
2213
2214 *pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
2215 *pCaps->MaxVertexIndex = 0xFFFFF;
2216 *pCaps->MaxStreams = MAX_STREAMS;
2217 *pCaps->MaxStreamStride = 1024;
2218
2219 if (vs_selected_mode == SHADER_GLSL) {
2220 /* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
2221 models with GLSL support only support 2.0. In case of nvidia we can detect VS 2.0 support using
2222 vs_nv_version which is based on NV_vertex_program. For Ati cards there's no easy way, so for
2223 now only support 2.0/3.0 detection on Nvidia GeforceFX cards and default to 3.0 for everything else */
2224 if(This->gl_info.vs_nv_version == VS_VERSION_20)
2225 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
2226 else
2227 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
2228 TRACE_(d3d_caps)("Hardware vertex shader version 3.0 enabled (GLSL)\n");
2229 } else if (vs_selected_mode == SHADER_ARB) {
2230 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
2231 TRACE_(d3d_caps)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
2232 } else if (vs_selected_mode == SHADER_SW) {
2233 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
2234 TRACE_(d3d_caps)("Software vertex shader version 3.0 enabled\n");
2235 } else {
2236 *pCaps->VertexShaderVersion = 0;
2237 TRACE_(d3d_caps)("Vertex shader functionality not available\n");
2238 }
2239
2240 *pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
2241
2242 if (ps_selected_mode == SHADER_GLSL) {
2243 /* See the comment about VS2.0/VS3.0 detection as we do the same here but then based on NV_fragment_program
2244 in case of GeforceFX cards. */
2245 if(This->gl_info.ps_nv_version == PS_VERSION_20)
2246 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
2247 else
2248 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
2249 /* FIXME: The following line is card dependent. -1.0 to 1.0 is a safe default clamp range for now */
2250 *pCaps->PixelShader1xMaxValue = 1.0;
2251 TRACE_(d3d_caps)("Hardware pixel shader version 3.0 enabled (GLSL)\n");
2252 } else if (ps_selected_mode == SHADER_ARB) {
2253 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(1,4);
2254 *pCaps->PixelShader1xMaxValue = 1.0;
2255 TRACE_(d3d_caps)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
2256 /* FIXME: Uncomment this when there is support for software Pixel Shader 3.0 and PS_SW is defined
2257 } else if (ps_selected_mode = SHADER_SW) {
2258 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
2259 *pCaps->PixelShader1xMaxValue = 1.0;
2260 TRACE_(d3d_caps)("Software pixel shader version 3.0 enabled\n"); */
2261 } else {
2262 *pCaps->PixelShaderVersion = 0;
2263 *pCaps->PixelShader1xMaxValue = 0.0;
2264 TRACE_(d3d_caps)("Pixel shader functionality not available\n");
2265 }
2266
2267 /* ------------------------------------------------
2268 The following fields apply to d3d9 only
2269 ------------------------------------------------ */
2270 if (This->dxVersion > 8) {
2271 FIXME("Caps support for directx9 is nonexistent at the moment!\n");
2272 *pCaps->DevCaps2 = 0;
2273 /* TODO: D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES and VS3.0 needs at least D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET */
2274 *pCaps->MaxNpatchTessellationLevel = 0;
2275 *pCaps->MasterAdapterOrdinal = 0;
2276 *pCaps->AdapterOrdinalInGroup = 0;
2277 *pCaps->NumberOfAdaptersInGroup = 1;
2278
2279 if(*pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
2280 /* OpenGL supports all formats below, perhaps not always without conversion but it supports them.
2281 Further GLSL doesn't seem to have an official unsigned type as I'm not sure how we handle it
2282 don't advertise it yet. We might need to add some clamping in the shader engine to support it.
2283 TODO: D3DDTCAPS_USHORT2N, D3DDTCAPS_USHORT4N, D3DDTCAPS_UDEC3, D3DDTCAPS_DEC3N */
2284 *pCaps->DeclTypes = D3DDTCAPS_UBYTE4 |
2285 D3DDTCAPS_UBYTE4N |
2286 D3DDTCAPS_SHORT2N |
2287 D3DDTCAPS_SHORT4N |
2288 D3DDTCAPS_FLOAT16_2 |
2289 D3DDTCAPS_FLOAT16_4;
2290
2291 } else
2292 *pCaps->DeclTypes = 0;
2293
2294 #if 0 /* We don't properly support multiple render targets yet, so disable this for now */
2295 if (GL_SUPPORT(ARB_DRAWBUFFERS)) {
2296 *pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
2297 } else
2298 #endif
2299 *pCaps->NumSimultaneousRTs = 1;
2300
2301 *pCaps->StretchRectFilterCaps = 0;
2302 *pCaps->VertexTextureFilterCaps = 0;
2303
2304 if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
2305 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
2306 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
2307 *pCaps->VS20Caps.Caps = D3DVS20CAPS_PREDICATION;
2308 *pCaps->VS20Caps.DynamicFlowControlDepth = D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
2309 *pCaps->VS20Caps.NumTemps = max(32, This->gl_info.vs_arb_max_temps);
2310 *pCaps->VS20Caps.StaticFlowControlDepth = D3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
2311
2312 *pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
2313 *pCaps->MaxVertexShader30InstructionSlots = max(512, This->gl_info.vs_arb_max_instructions);
2314 } else if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
2315 *pCaps->VS20Caps.Caps = 0;
2316 *pCaps->VS20Caps.DynamicFlowControlDepth = D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
2317 *pCaps->VS20Caps.NumTemps = max(12, This->gl_info.vs_arb_max_temps);
2318 *pCaps->VS20Caps.StaticFlowControlDepth = 1;
2319
2320 *pCaps->MaxVShaderInstructionsExecuted = 65535;
2321 *pCaps->MaxVertexShader30InstructionSlots = 0;
2322 } else { /* VS 1.x */
2323 *pCaps->VS20Caps.Caps = 0;
2324 *pCaps->VS20Caps.DynamicFlowControlDepth = 0;
2325 *pCaps->VS20Caps.NumTemps = 0;
2326 *pCaps->VS20Caps.StaticFlowControlDepth = 0;
2327
2328 *pCaps->MaxVShaderInstructionsExecuted = 0;
2329 *pCaps->MaxVertexShader30InstructionSlots = 0;
2330 }
2331
2332 if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
2333 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
2334 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
2335
2336 /* Caps is more or less undocumented on MSDN but it appears to be used for PS20Caps based on results from R9600/FX5900/Geforce6800 cards from Windows */
2337 *pCaps->PS20Caps.Caps = D3DPS20CAPS_ARBITRARYSWIZZLE |
2338 D3DPS20CAPS_GRADIENTINSTRUCTIONS |
2339 D3DPS20CAPS_PREDICATION |
2340 D3DPS20CAPS_NODEPENDENTREADLIMIT |
2341 D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
2342 *pCaps->PS20Caps.DynamicFlowControlDepth = D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
2343 *pCaps->PS20Caps.NumTemps = max(32, This->gl_info.ps_arb_max_temps);
2344 *pCaps->PS20Caps.StaticFlowControlDepth = D3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
2345 *pCaps->PS20Caps.NumInstructionSlots = D3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
2346
2347 *pCaps->MaxPShaderInstructionsExecuted = 65535;
2348 *pCaps->MaxPixelShader30InstructionSlots = max(D3DMIN30SHADERINSTRUCTIONS, This->gl_info.ps_arb_max_instructions);
2349 } else if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
2350 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
2351 *pCaps->PS20Caps.Caps = 0;
2352 *pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
2353 *pCaps->PS20Caps.NumTemps = max(12, This->gl_info.ps_arb_max_temps);
2354 *pCaps->PS20Caps.StaticFlowControlDepth = D3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minumum: 1 */
2355 *pCaps->PS20Caps.NumInstructionSlots = D3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
2356
2357 *pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
2358 *pCaps->MaxPixelShader30InstructionSlots = 0;
2359 } else { /* PS 1.x */
2360 *pCaps->PS20Caps.Caps = 0;
2361 *pCaps->PS20Caps.DynamicFlowControlDepth = 0;
2362 *pCaps->PS20Caps.NumTemps = 0;
2363 *pCaps->PS20Caps.StaticFlowControlDepth = 0;
2364 *pCaps->PS20Caps.NumInstructionSlots = 0;
2365
2366 *pCaps->MaxPShaderInstructionsExecuted = 0;
2367 *pCaps->MaxPixelShader30InstructionSlots = 0;
2368 }
2369 }
2370
2371 return WINED3D_OK;
2372 }
2373
2374
2375 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
2376 and fields being inserted in the middle, a new structure is used in place */
2377 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, HWND hFocusWindow,
2378 DWORD BehaviourFlags, IWineD3DDevice** ppReturnedDeviceInterface,
2379 IUnknown *parent) {
2380
2381 IWineD3DDeviceImpl *object = NULL;
2382 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2383 HDC hDC;
2384 HRESULT temp_result;
2385
2386 /* Validate the adapter number */
2387 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2388 return WINED3DERR_INVALIDCALL;
2389 }
2390
2391 /* Create a WineD3DDevice object */
2392 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DDeviceImpl));
2393 *ppReturnedDeviceInterface = (IWineD3DDevice *)object;
2394 TRACE("Created WineD3DDevice object @ %p\n", object);
2395 if (NULL == object) {
2396 return WINED3DERR_OUTOFVIDEOMEMORY;
2397 }
2398
2399 /* Set up initial COM information */
2400 object->lpVtbl = &IWineD3DDevice_Vtbl;
2401 object->ref = 1;
2402 object->wineD3D = iface;
2403 IWineD3D_AddRef(object->wineD3D);
2404 object->parent = parent;
2405
2406 /* Set the state up as invalid until the device is fully created */
2407 object->state = WINED3DERR_DRIVERINTERNALERROR;
2408
2409 TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This, Adapter, DeviceType,
2410 hFocusWindow, BehaviourFlags, ppReturnedDeviceInterface);
2411
2412 /* Save the creation parameters */
2413 object->createParms.AdapterOrdinal = Adapter;
2414 object->createParms.DeviceType = DeviceType;
2415 object->createParms.hFocusWindow = hFocusWindow;
2416 object->createParms.BehaviorFlags = BehaviourFlags;
2417
2418 /* Initialize other useful values */
2419 object->adapterNo = Adapter;
2420 object->devType = DeviceType;
2421
2422 TRACE("(%p) : Creating stateblock\n", This);
2423 /* Creating the startup stateBlock - Note Special Case: 0 => Don't fill in yet! */
2424 if (WINED3D_OK != IWineD3DDevice_CreateStateBlock((IWineD3DDevice *)object,
2425 WINED3DSBT_INIT,
2426 (IWineD3DStateBlock **)&object->stateBlock,
2427 NULL) || NULL == object->stateBlock) { /* Note: No parent needed for initial internal stateblock */
2428 WARN("Failed to create stateblock\n");
2429 goto create_device_error;
2430 }
2431 TRACE("(%p) : Created stateblock (%p)\n", This, object->stateBlock);
2432 object->updateStateBlock = object->stateBlock;
2433 IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)object->updateStateBlock);
2434 /* Setup surfaces for the backbuffer, frontbuffer and depthstencil buffer */
2435
2436 /* Setup some defaults for creating the implicit swapchain */
2437 ENTER_GL();
2438 /* FIXME: GL info should be per adapter */
2439 IWineD3DImpl_FillGLCaps(iface, IWineD3DImpl_GetAdapterDisplay(iface, Adapter));
2440 LEAVE_GL();
2441 select_shader_mode(&This->gl_info, DeviceType, &object->ps_selected_mode, &object->vs_selected_mode);
2442 if (object->ps_selected_mode == SHADER_GLSL || object->vs_selected_mode == SHADER_GLSL) {
2443 object->shader_backend = &glsl_shader_backend;
2444 } else if (object->ps_selected_mode == SHADER_ARB || object->vs_selected_mode == SHADER_ARB) {
2445 object->shader_backend = &arb_program_shader_backend;
2446 } else {
2447 object->shader_backend = &none_shader_backend;
2448 }
2449
2450 /* This function should *not* be modifying GL caps
2451 * TODO: move the functionality where it belongs */
2452 select_shader_max_constants(object->ps_selected_mode, object->vs_selected_mode, &This->gl_info);
2453
2454 temp_result = allocate_shader_constants(object->updateStateBlock);
2455 if (WINED3D_OK != temp_result)
2456 return temp_result;
2457
2458 /* set the state of the device to valid */
2459 object->state = WINED3D_OK;
2460
2461 /* Get the initial screen setup for ddraw */
2462 object->ddraw_width = GetSystemMetrics(SM_CXSCREEN);
2463 object->ddraw_height = GetSystemMetrics(SM_CYSCREEN);
2464 hDC = CreateDCA("DISPLAY", NULL, NULL, NULL);
2465 object->ddraw_format = pixelformat_for_depth(GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES));
2466 DeleteDC(hDC);
2467
2468 return WINED3D_OK;
2469 create_device_error:
2470
2471 /* Set the device state to error */
2472 object->state = WINED3DERR_DRIVERINTERNALERROR;
2473
2474 if (object->updateStateBlock != NULL) {
2475 IWineD3DStateBlock_Release((IWineD3DStateBlock *)object->updateStateBlock);
2476 object->updateStateBlock = NULL;
2477 }
2478 if (object->stateBlock != NULL) {
2479 IWineD3DStateBlock_Release((IWineD3DStateBlock *)object->stateBlock);
2480 object->stateBlock = NULL;
2481 }
2482 if (object->renderTarget != NULL) {
2483 IWineD3DSurface_Release(object->renderTarget);
2484 object->renderTarget = NULL;
2485 }
2486 if (object->stencilBufferTarget != NULL) {
2487 IWineD3DSurface_Release(object->stencilBufferTarget);
2488 object->stencilBufferTarget = NULL;
2489 }
2490 HeapFree(GetProcessHeap(), 0, object);
2491 *ppReturnedDeviceInterface = NULL;
2492 return WINED3DERR_INVALIDCALL;
2493
2494 }
2495
2496 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
2497 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2498 IUnknown_AddRef(This->parent);
2499 *pParent = This->parent;
2500 return WINED3D_OK;
2501 }
2502
2503 /**********************************************************
2504 * IWineD3D VTbl follows
2505 **********************************************************/
2506
2507 const IWineD3DVtbl IWineD3D_Vtbl =
2508 {
2509 /* IUnknown */
2510 IWineD3DImpl_QueryInterface,
2511 IWineD3DImpl_AddRef,
2512 IWineD3DImpl_Release,
2513 /* IWineD3D */
2514 IWineD3DImpl_GetParent,
2515 IWineD3DImpl_GetAdapterCount,
2516 IWineD3DImpl_RegisterSoftwareDevice,
2517 IWineD3DImpl_GetAdapterMonitor,
2518 IWineD3DImpl_GetAdapterModeCount,
2519 IWineD3DImpl_EnumAdapterModes,
2520 IWineD3DImpl_GetAdapterDisplayMode,
2521 IWineD3DImpl_GetAdapterIdentifier,
2522 IWineD3DImpl_CheckDeviceMultiSampleType,
2523 IWineD3DImpl_CheckDepthStencilMatch,
2524 IWineD3DImpl_CheckDeviceType,
2525 IWineD3DImpl_CheckDeviceFormat,
2526 IWineD3DImpl_CheckDeviceFormatConversion,
2527 IWineD3DImpl_GetDeviceCaps,
2528 IWineD3DImpl_CreateDevice
2529 };
useful hacks and other patches not (yet) suitable for mainline