?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Rename renderUpsideDown to render_offscreen.
[wine/testsucceed.git] / dlls / wined3d / directx.c
blob00c95cd102eaa05e2e5d7a9a94ba7c636a88a7d4
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 /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
795 * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
796 * in case of the latest videocards in the number of pixel/vertex pipelines.
797 *
798 * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
799 * rendering. Various games use this information to get a rough estimation of the features of the card
800 * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
801 * games might even use it to work around bugs which happen on certain videocards/driver combinations.
802 * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
803 * not the PCI id.
804 *
805 * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
806 * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
807 * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
808 * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
809 * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
810 * is used for rendering which is not always the case). This would work but it is not very portable. Second
811 * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
812 * is limited.
813 *
814 * As said most games only use the PCI id to get an indication of the capabilities of the card.
815 * It doesn't really matter if the given id is the correct one if we return the id of a card with
816 * similar 3d features.
817 *
818 * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
819 * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
820 * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
821 * won't pass we return a default card. This way is better than maintaining a full card database as even
822 * without a full database we can return a card with similar features. Second the size of the database
823 * can be made quite small because when you know what type of 3d functionality a card has, you know to which
824 * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
825 * to distinguishes between different models from that family.
826 */
827 switch (gl_info->gl_vendor) {
828 case VENDOR_NVIDIA:
829 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
830 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
831 */
832 if(WINE_D3D9_CAPABLE(gl_info) && (gl_info->vs_nv_version == VS_VERSION_30)) {
833 if (strstr(gl_info->gl_renderer, "7800") ||
834 strstr(gl_info->gl_renderer, "7900") ||
835 strstr(gl_info->gl_renderer, "7950") ||
836 strstr(gl_info->gl_renderer, "Quadro FX 4") ||
837 strstr(gl_info->gl_renderer, "Quadro FX 5"))
838 gl_info->gl_card = CARD_NVIDIA_GEFORCE_7800GT;
839 else if(strstr(gl_info->gl_renderer, "6800") ||
840 strstr(gl_info->gl_renderer, "7600"))
841 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6800;
842 else if(strstr(gl_info->gl_renderer, "6600") ||
843 strstr(gl_info->gl_renderer, "6610") ||
844 strstr(gl_info->gl_renderer, "6700"))
845 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6600GT;
846 else
847 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400 */
848 } else if(WINE_D3D9_CAPABLE(gl_info)) {
849 if (strstr(gl_info->gl_renderer, "5800") ||
850 strstr(gl_info->gl_renderer, "5900") ||
851 strstr(gl_info->gl_renderer, "5950") ||
852 strstr(gl_info->gl_renderer, "Quadro FX"))
853 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5800;
854 else if(strstr(gl_info->gl_renderer, "5600") ||
855 strstr(gl_info->gl_renderer, "5650") ||
856 strstr(gl_info->gl_renderer, "5700") ||
857 strstr(gl_info->gl_renderer, "5750"))
858 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
859 else
860 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
861 } else if(WINE_D3D8_CAPABLE(gl_info)) {
862 if (strstr(gl_info->gl_renderer, "GeForce4 Ti") || strstr(gl_info->gl_renderer, "Quadro4"))
863 gl_info->gl_card = CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
864 else
865 gl_info->gl_card = CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
866 } else if(WINE_D3D7_CAPABLE(gl_info)) {
867 if (strstr(gl_info->gl_renderer, "GeForce4 MX"))
868 gl_info->gl_card = CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
869 else if(strstr(gl_info->gl_renderer, "GeForce2 MX") || strstr(gl_info->gl_renderer, "Quadro2 MXR"))
870 gl_info->gl_card = CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
871 else if(strstr(gl_info->gl_renderer, "GeForce2") || strstr(gl_info->gl_renderer, "Quadro2"))
872 gl_info->gl_card = CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
873 else
874 gl_info->gl_card = CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
875 } else {
876 if (strstr(gl_info->gl_renderer, "TNT2"))
877 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
878 else
879 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
880 }
881 break;
882 case VENDOR_ATI:
883 if(WINE_D3D9_CAPABLE(gl_info)) {
884 /* Radeon R5xx */
885 if (strstr(gl_info->gl_renderer, "X1600") ||
886 strstr(gl_info->gl_renderer, "X1800") ||
887 strstr(gl_info->gl_renderer, "X1900") ||
888 strstr(gl_info->gl_renderer, "X1950"))
889 gl_info->gl_card = CARD_ATI_RADEON_X1600;
890 /* Radeon R4xx + X1300/X1400 (lowend R5xx) */
891 else if(strstr(gl_info->gl_renderer, "X700") ||
892 strstr(gl_info->gl_renderer, "X800") ||
893 strstr(gl_info->gl_renderer, "X850") ||
894 strstr(gl_info->gl_renderer, "X1300") ||
895 strstr(gl_info->gl_renderer, "X1400"))
896 gl_info->gl_card = CARD_ATI_RADEON_X700;
897 /* Radeon R3xx */
898 else
899 gl_info->gl_card = CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
900 } else if(WINE_D3D8_CAPABLE(gl_info)) {
901 gl_info->gl_card = CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
902 } else if(WINE_D3D7_CAPABLE(gl_info)) {
903 gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
904 } else
905 gl_info->gl_card = CARD_ATI_RAGE_128PRO;
906 break;
907 case VENDOR_INTEL:
908 if (strstr(gl_info->gl_renderer, "915GM")) {
909 gl_info->gl_card = CARD_INTEL_I915GM;
910 } else if (strstr(gl_info->gl_renderer, "915G")) {
911 gl_info->gl_card = CARD_INTEL_I915G;
912 } else if (strstr(gl_info->gl_renderer, "865G")) {
913 gl_info->gl_card = CARD_INTEL_I865G;
914 } else if (strstr(gl_info->gl_renderer, "855G")) {
915 gl_info->gl_card = CARD_INTEL_I855G;
916 } else if (strstr(gl_info->gl_renderer, "830G")) {
917 gl_info->gl_card = CARD_INTEL_I830G;
918 } else {
919 gl_info->gl_card = CARD_INTEL_I915G;
920 }
921 break;
922 case VENDOR_MESA:
923 case VENDOR_WINE:
924 default:
925 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
926 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
927 * them a good generic choice.
928 */
929 gl_info->gl_vendor = VENDOR_NVIDIA;
930 if(WINE_D3D9_CAPABLE(gl_info))
931 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
932 else if(WINE_D3D8_CAPABLE(gl_info))
933 gl_info->gl_card = CARD_NVIDIA_GEFORCE3;
934 else if(WINE_D3D7_CAPABLE(gl_info))
935 gl_info->gl_card = CARD_NVIDIA_GEFORCE;
936 else if(WINE_D3D6_CAPABLE(gl_info))
937 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT;
938 else
939 gl_info->gl_card = CARD_NVIDIA_RIVA_128;
940 }
941 TRACE("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info->gl_vendor, gl_info->gl_card);
942
943 /* Load all the lookup tables
944 TODO: It may be a good idea to make minLookup and maxLookup const and populate them in wined3d_private.h where they are declared */
945 minLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_WRAP;
946 maxLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_MIRRORONCE;
947
948 minLookup[WINELOOKUP_MAGFILTER] = WINED3DTEXF_NONE;
949 maxLookup[WINELOOKUP_MAGFILTER] = WINED3DTEXF_ANISOTROPIC;
950
951
952 for (i = 0; i < MAX_LOOKUPS; i++) {
953 stateLookup[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup[i]) * (1 + maxLookup[i] - minLookup[i]) );
954 }
955
956 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_WRAP - minLookup[WINELOOKUP_WARPPARAM]] = GL_REPEAT;
957 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_CLAMP - minLookup[WINELOOKUP_WARPPARAM]] = GL_CLAMP_TO_EDGE;
958 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
959 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
960 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
961 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
962 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRROR - minLookup[WINELOOKUP_WARPPARAM]] =
963 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
964 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRRORONCE - minLookup[WINELOOKUP_WARPPARAM]] =
965 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
966
967 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_NONE - minLookup[WINELOOKUP_MAGFILTER]] = GL_NEAREST;
968 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_POINT - minLookup[WINELOOKUP_MAGFILTER]] = GL_NEAREST;
969 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_LINEAR - minLookup[WINELOOKUP_MAGFILTER]] = GL_LINEAR;
970 stateLookup[WINELOOKUP_MAGFILTER][WINED3DTEXF_ANISOTROPIC - minLookup[WINELOOKUP_MAGFILTER]] =
971 gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR : GL_NEAREST;
972
973
974 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_NONE] = GL_LINEAR;
975 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_POINT] = GL_LINEAR;
976 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_LINEAR] = GL_LINEAR;
977 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_NONE] = GL_NEAREST;
978 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_POINT] = GL_NEAREST_MIPMAP_NEAREST;
979 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_LINEAR] = GL_NEAREST_MIPMAP_LINEAR;
980 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_NONE] = GL_LINEAR;
981 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_POINT] = GL_LINEAR_MIPMAP_NEAREST;
982 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_LINEAR] = GL_LINEAR_MIPMAP_LINEAR;
983 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_NONE] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ?
984 GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
985 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_POINT] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
986 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_LINEAR] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
987
988 /* TODO: config lookups */
989
990 if (display != NULL) {
991 GLX_Extensions = glXQueryExtensionsString(display, DefaultScreen(display));
992 TRACE_(d3d_caps)("GLX_Extensions reported:\n");
993
994 if (NULL == GLX_Extensions) {
995 ERR(" GLX_Extensions returns NULL\n");
996 } else {
997 while (*GLX_Extensions != 0x00) {
998 const char *Start = GLX_Extensions;
999 char ThisExtn[256];
1000
1001 memset(ThisExtn, 0x00, sizeof(ThisExtn));
1002 while (*GLX_Extensions != ' ' && *GLX_Extensions != 0x00) {
1003 GLX_Extensions++;
1004 }
1005 memcpy(ThisExtn, Start, (GLX_Extensions - Start));
1006 TRACE_(d3d_caps)("- %s\n", ThisExtn);
1007 if (*GLX_Extensions == ' ') GLX_Extensions++;
1008 }
1009 }
1010 }
1011
1012 /* If we created a dummy context, throw it away */
1013 if (NULL != fake_ctx) WineD3D_ReleaseFakeGLContext(fake_ctx);
1014
1015 /* Only save the values obtained when a display is provided */
1016 if (fake_ctx == NULL) {
1017 return TRUE;
1018 } else {
1019 return FALSE;
1020 }
1021 }
1022
1023 /**********************************************************
1024 * IWineD3D implementation follows
1025 **********************************************************/
1026
1027 static UINT WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
1028 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1029
1030 /* FIXME: Set to one for now to imply the display */
1031 TRACE_(d3d_caps)("(%p): Mostly stub, only returns primary display\n", This);
1032 return 1;
1033 }
1034
1035 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void* pInitializeFunction) {
1036 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1037 FIXME("(%p)->(%p): stub\n", This, pInitializeFunction);
1038 return WINED3D_OK;
1039 }
1040
1041 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
1042 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1043 POINT pt = { -1, -1 };
1044
1045 if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
1046 return NULL;
1047 }
1048
1049 FIXME_(d3d_caps)("(%p): returning the primary monitor for adapter %d\n", This, Adapter);
1050 return MonitorFromPoint(pt, MONITOR_DEFAULTTOPRIMARY);
1051 }
1052
1053 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1054 of the same bpp but different resolutions */
1055
1056 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1057 static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
1058 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1059 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
1060
1061 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1062 return 0;
1063 }
1064
1065 if (Adapter == 0) { /* Display */
1066 int i = 0;
1067 int j = 0;
1068 #if !defined( DEBUG_SINGLE_MODE )
1069 DEVMODEW DevModeW;
1070
1071 /* Work out the current screen bpp */
1072 HDC hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1073 int bpp = GetDeviceCaps(hdc, BITSPIXEL);
1074 DeleteDC(hdc);
1075
1076 while (EnumDisplaySettingsExW(NULL, j, &DevModeW, 0)) {
1077 j++;
1078 switch (Format)
1079 {
1080 case WINED3DFMT_UNKNOWN:
1081 i++;
1082 break;
1083 case WINED3DFMT_X8R8G8B8:
1084 case WINED3DFMT_A8R8G8B8:
1085 if (min(DevModeW.dmBitsPerPel, bpp) == 32) i++;
1086 if (min(DevModeW.dmBitsPerPel, bpp) == 24) i++;
1087 break;
1088 case WINED3DFMT_X1R5G5B5:
1089 case WINED3DFMT_A1R5G5B5:
1090 case WINED3DFMT_R5G6B5:
1091 if (min(DevModeW.dmBitsPerPel, bpp) == 16) i++;
1092 break;
1093 default:
1094 /* Skip other modes as they do not match the requested format */
1095 break;
1096 }
1097 }
1098 #else
1099 i = 1;
1100 j = 1;
1101 #endif
1102 TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
1103 return i;
1104 } else {
1105 FIXME_(d3d_caps)("Adapter not primary display\n");
1106 }
1107 return 0;
1108 }
1109
1110 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1111 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
1112 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1113 TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
1114
1115 /* Validate the parameters as much as possible */
1116 if (NULL == pMode ||
1117 Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
1118 Mode >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
1119 return WINED3DERR_INVALIDCALL;
1120 }
1121
1122 if (Adapter == 0) { /* Display */
1123 int bpp;
1124 #if !defined( DEBUG_SINGLE_MODE )
1125 DEVMODEW DevModeW;
1126 int ModeIdx = 0;
1127
1128 /* Work out the current screen bpp */
1129 HDC hdc = CreateDCA("DISPLAY", NULL, NULL, NULL);
1130 bpp = GetDeviceCaps(hdc, BITSPIXEL);
1131 DeleteDC(hdc);
1132
1133 /* If we are filtering to a specific format, then need to skip all unrelated
1134 modes, but if mode is irrelevant, then we can use the index directly */
1135 if (Format == WINED3DFMT_UNKNOWN)
1136 {
1137 ModeIdx = Mode;
1138 } else {
1139 int i = 0;
1140 int j = 0;
1141 DEVMODEW DevModeWtmp;
1142
1143
1144 while (i<(Mode) && EnumDisplaySettingsExW(NULL, j, &DevModeWtmp, 0)) {
1145 j++;
1146 switch (Format)
1147 {
1148 case WINED3DFMT_UNKNOWN:
1149 i++;
1150 break;
1151 case WINED3DFMT_X8R8G8B8:
1152 case WINED3DFMT_A8R8G8B8:
1153 if (min(DevModeWtmp.dmBitsPerPel, bpp) == 32) i++;
1154 if (min(DevModeWtmp.dmBitsPerPel, bpp) == 24) i++;
1155 break;
1156 case WINED3DFMT_X1R5G5B5:
1157 case WINED3DFMT_A1R5G5B5:
1158 case WINED3DFMT_R5G6B5:
1159 if (min(DevModeWtmp.dmBitsPerPel, bpp) == 16) i++;
1160 break;
1161 default:
1162 /* Skip other modes as they do not match requested format */
1163 break;
1164 }
1165 }
1166 ModeIdx = j;
1167 }
1168
1169 /* Now get the display mode via the calculated index */
1170 if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0))
1171 {
1172 pMode->Width = DevModeW.dmPelsWidth;
1173 pMode->Height = DevModeW.dmPelsHeight;
1174 bpp = min(DevModeW.dmBitsPerPel, bpp);
1175 pMode->RefreshRate = D3DADAPTER_DEFAULT;
1176 if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
1177 {
1178 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1179 }
1180
1181 if (Format == WINED3DFMT_UNKNOWN)
1182 {
1183 switch (bpp) {
1184 case 8: pMode->Format = WINED3DFMT_R3G3B2; break;
1185 case 16: pMode->Format = WINED3DFMT_R5G6B5; break;
1186 case 24: /* Robots and EVE Online need 24 and 32 bit as A8R8G8B8 to start */
1187 case 32: pMode->Format = WINED3DFMT_A8R8G8B8; break;
1188 default: pMode->Format = WINED3DFMT_UNKNOWN;
1189 }
1190 } else {
1191 pMode->Format = Format;
1192 }
1193 }
1194 else
1195 {
1196 TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
1197 return WINED3DERR_INVALIDCALL;
1198 }
1199
1200 #else
1201 /* Return one setting of the format requested */
1202 if (Mode > 0) return WINED3DERR_INVALIDCALL;
1203 pMode->Width = 800;
1204 pMode->Height = 600;
1205 pMode->RefreshRate = D3DADAPTER_DEFAULT;
1206 pMode->Format = (Format == WINED3DFMT_UNKNOWN) ? WINED3DFMT_A8R8G8B8 : Format;
1207 bpp = 32;
1208 #endif
1209 TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
1210 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format), bpp);
1211
1212 } else {
1213 FIXME_(d3d_caps)("Adapter not primary display\n");
1214 }
1215
1216 return WINED3D_OK;
1217 }
1218
1219 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE* pMode) {
1220 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1221 TRACE_(d3d_caps)("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode);
1222
1223 if (NULL == pMode ||
1224 Adapter >= IWineD3D_GetAdapterCount(iface)) {
1225 return WINED3DERR_INVALIDCALL;
1226 }
1227
1228 if (Adapter == 0) { /* Display */
1229 int bpp = 0;
1230 DEVMODEW DevModeW;
1231
1232 EnumDisplaySettingsExW(NULL, (DWORD)-1, &DevModeW, 0);
1233 pMode->Width = DevModeW.dmPelsWidth;
1234 pMode->Height = DevModeW.dmPelsHeight;
1235 bpp = DevModeW.dmBitsPerPel;
1236 pMode->RefreshRate = D3DADAPTER_DEFAULT;
1237 if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
1238 {
1239 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1240 }
1241
1242 switch (bpp) {
1243 case 8: pMode->Format = WINED3DFMT_R3G3B2; break;
1244 case 16: pMode->Format = WINED3DFMT_R5G6B5; break;
1245 case 24: pMode->Format = WINED3DFMT_X8R8G8B8; break; /* Robots needs 24bit to be X8R8G8B8 */
1246 case 32: pMode->Format = WINED3DFMT_X8R8G8B8; break; /* EVE online and the Fur demo need 32bit AdapterDisplatMode to return X8R8G8B8 */
1247 default: pMode->Format = WINED3DFMT_UNKNOWN;
1248 }
1249
1250 } else {
1251 FIXME_(d3d_caps)("Adapter not primary display\n");
1252 }
1253
1254 TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
1255 pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
1256 return WINED3D_OK;
1257 }
1258
1259 static Display * WINAPI IWineD3DImpl_GetAdapterDisplay(IWineD3D *iface, UINT Adapter) {
1260 Display *display;
1261 HDC device_context;
1262 /* only works with one adapter at the moment... */
1263
1264 /* Get the display */
1265 device_context = GetDC(0);
1266 display = get_display(device_context);
1267 ReleaseDC(0, device_context);
1268 return display;
1269 }
1270
1271 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1272 and fields being inserted in the middle, a new structure is used in place */
1273 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
1274 WINED3DADAPTER_IDENTIFIER* pIdentifier) {
1275 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1276
1277 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
1278
1279 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1280 return WINED3DERR_INVALIDCALL;
1281 }
1282
1283 if (Adapter == 0) { /* Display - only device supported for now */
1284
1285 BOOL isGLInfoValid = This->isGLInfoValid;
1286
1287 /* FillGLCaps updates gl_info, but we only want to store and
1288 reuse the values once we have a context which is valid. Values from
1289 a temporary context may differ from the final ones */
1290 if (!isGLInfoValid) {
1291 WineD3D_Context *fake_ctx = NULL;
1292 if (glXGetCurrentContext() == NULL) fake_ctx = WineD3D_CreateFakeGLContext();
1293 /* If we don't know the device settings, go query them now */
1294 isGLInfoValid = IWineD3DImpl_FillGLCaps(iface, IWineD3DImpl_GetAdapterDisplay(iface, Adapter));
1295 if (fake_ctx != NULL) WineD3D_ReleaseFakeGLContext(fake_ctx);
1296 }
1297
1298 /* If it worked, return the information requested */
1299 if (isGLInfoValid) {
1300 TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
1301 strcpy(pIdentifier->Driver, "Display");
1302 strcpy(pIdentifier->Description, "Direct3D HAL");
1303
1304 /* Note dx8 doesn't supply a DeviceName */
1305 if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1306 /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
1307 pIdentifier->DriverVersion->u.HighPart = MAKEDWORD_VERSION(6, 14);
1308 pIdentifier->DriverVersion->u.LowPart = This->gl_info.gl_driver_version;
1309 *(pIdentifier->VendorId) = This->gl_info.gl_vendor;
1310 *(pIdentifier->DeviceId) = This->gl_info.gl_card;
1311 *(pIdentifier->SubSysId) = 0;
1312 *(pIdentifier->Revision) = 0;
1313
1314 } else {
1315
1316 /* If it failed, return dummy values from an NVidia driver */
1317 WARN_(d3d_caps)("Cannot get GLCaps for device/Vendor Name and Version detection using FillGLCaps, currently using NVIDIA identifiers\n");
1318 strcpy(pIdentifier->Driver, "Display");
1319 strcpy(pIdentifier->Description, "Direct3D HAL");
1320 if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1321 /* Current Windows Nvidia drivers have versions like e.g. 6.14.10.5672 */
1322 pIdentifier->DriverVersion->u.HighPart = MAKEDWORD_VERSION(6, 14);
1323 /* 71.74 is a current Linux Nvidia driver version */
1324 pIdentifier->DriverVersion->u.LowPart = MAKEDWORD_VERSION(10, (71*100+74));
1325 *(pIdentifier->VendorId) = VENDOR_NVIDIA;
1326 *(pIdentifier->DeviceId) = CARD_NVIDIA_GEFORCE4_TI4200;
1327 *(pIdentifier->SubSysId) = 0;
1328 *(pIdentifier->Revision) = 0;
1329 }
1330
1331 /*FIXME: memcpy(&pIdentifier->DeviceIdentifier, ??, sizeof(??GUID)); */
1332 if (Flags & D3DENUM_NO_WHQL_LEVEL) {
1333 *(pIdentifier->WHQLLevel) = 0;
1334 } else {
1335 *(pIdentifier->WHQLLevel) = 1;
1336 }
1337
1338 } else {
1339 FIXME_(d3d_caps)("Adapter not primary display\n");
1340 }
1341
1342 return WINED3D_OK;
1343 }
1344
1345 static BOOL IWineD3DImpl_IsGLXFBConfigCompatibleWithRenderFmt(Display *display, GLXFBConfig cfgs, WINED3DFORMAT Format) {
1346 #if 0 /* This code performs a strict test between the format and the current X11 buffer depth, which may give the best performance */
1347 int gl_test;
1348 int rb, gb, bb, ab, type, buf_sz;
1349
1350 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_RED_SIZE, &rb);
1351 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_GREEN_SIZE, &gb);
1352 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_BLUE_SIZE, &bb);
1353 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_ALPHA_SIZE, &ab);
1354 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_RENDER_TYPE, &type);
1355 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_BUFFER_SIZE, &buf_sz);
1356
1357 switch (Format) {
1358 case WINED3DFMT_X8R8G8B8:
1359 case WINED3DFMT_R8G8B8:
1360 if (8 == rb && 8 == gb && 8 == bb) return TRUE;
1361 break;
1362 case WINED3DFMT_A8R8G8B8:
1363 if (8 == rb && 8 == gb && 8 == bb && 8 == ab) return TRUE;
1364 break;
1365 case WINED3DFMT_A2R10G10B10:
1366 if (10 == rb && 10 == gb && 10 == bb && 2 == ab) return TRUE;
1367 break;
1368 case WINED3DFMT_X1R5G5B5:
1369 if (5 == rb && 5 == gb && 5 == bb) return TRUE;
1370 break;
1371 case WINED3DFMT_A1R5G5B5:
1372 if (5 == rb && 5 == gb && 5 == bb && 1 == ab) return TRUE;
1373 break;
1374 case WINED3DFMT_X4R4G4B4:
1375 if (16 == buf_sz && 4 == rb && 4 == gb && 4 == bb) return TRUE;
1376 break;
1377 case WINED3DFMT_R5G6B5:
1378 if (5 == rb && 6 == gb && 5 == bb) return TRUE;
1379 break;
1380 case WINED3DFMT_R3G3B2:
1381 if (3 == rb && 3 == gb && 2 == bb) return TRUE;
1382 break;
1383 case WINED3DFMT_A8P8:
1384 if (type & GLX_COLOR_INDEX_BIT && 8 == buf_sz && 8 == ab) return TRUE;
1385 break;
1386 case WINED3DFMT_P8:
1387 if (type & GLX_COLOR_INDEX_BIT && 8 == buf_sz) return TRUE;
1388 break;
1389 default:
1390 ERR("unsupported format %s\n", debug_d3dformat(Format));
1391 break;
1392 }
1393 return FALSE;
1394 #else /* Most of the time performance is less of an issue than compatibility, this code allows for most common opengl/d3d formats */
1395 switch (Format) {
1396 case WINED3DFMT_X8R8G8B8:
1397 case WINED3DFMT_R8G8B8:
1398 case WINED3DFMT_A8R8G8B8:
1399 case WINED3DFMT_A2R10G10B10:
1400 case WINED3DFMT_X1R5G5B5:
1401 case WINED3DFMT_A1R5G5B5:
1402 case WINED3DFMT_R5G6B5:
1403 case WINED3DFMT_R3G3B2:
1404 case WINED3DFMT_A8P8:
1405 case WINED3DFMT_P8:
1406 return TRUE;
1407 default:
1408 ERR("unsupported format %s\n", debug_d3dformat(Format));
1409 break;
1410 }
1411 return FALSE;
1412 #endif
1413 }
1414
1415 static BOOL IWineD3DImpl_IsGLXFBConfigCompatibleWithDepthFmt(Display *display, GLXFBConfig cfgs, WINED3DFORMAT Format) {
1416 #if 0/* This code performs a strict test between the format and the current X11 buffer depth, which may give the best performance */
1417 int gl_test;
1418 int db, sb;
1419
1420 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_DEPTH_SIZE, &db);
1421 gl_test = glXGetFBConfigAttrib(display, cfgs, GLX_STENCIL_SIZE, &sb);
1422
1423 switch (Format) {
1424 case WINED3DFMT_D16:
1425 case WINED3DFMT_D16_LOCKABLE:
1426 if (16 == db) return TRUE;
1427 break;
1428 case WINED3DFMT_D32:
1429 if (32 == db) return TRUE;
1430 break;
1431 case WINED3DFMT_D15S1:
1432 if (15 == db) return TRUE;
1433 break;
1434 case WINED3DFMT_D24S8:
1435 if (24 == db && 8 == sb) return TRUE;
1436 break;
1437 case WINED3DFMT_D24FS8:
1438 if (24 == db && 8 == sb) return TRUE;
1439 break;
1440 case WINED3DFMT_D24X8:
1441 if (24 == db) return TRUE;
1442 break;
1443 case WINED3DFMT_D24X4S4:
1444 if (24 == db && 4 == sb) return TRUE;
1445 break;
1446 case WINED3DFMT_D32F_LOCKABLE:
1447 if (32 == db) return TRUE;
1448 break;
1449 default:
1450 ERR("unsupported format %s\n", debug_d3dformat(Format));
1451 break;
1452 }
1453 return FALSE;
1454 #else /* Most of the time performance is less of an issue than compatibility, this code allows for most common opengl/d3d formats */
1455 switch (Format) {
1456 case WINED3DFMT_D16:
1457 case WINED3DFMT_D16_LOCKABLE:
1458 case WINED3DFMT_D32:
1459 case WINED3DFMT_D15S1:
1460 case WINED3DFMT_D24S8:
1461 case WINED3DFMT_D24FS8:
1462 case WINED3DFMT_D24X8:
1463 case WINED3DFMT_D24X4S4:
1464 case WINED3DFMT_D32F_LOCKABLE:
1465 return TRUE;
1466 default:
1467 ERR("unsupported format %s\n", debug_d3dformat(Format));
1468 break;
1469 }
1470 return FALSE;
1471 #endif
1472 }
1473
1474 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1475 WINED3DFORMAT AdapterFormat,
1476 WINED3DFORMAT RenderTargetFormat,
1477 WINED3DFORMAT DepthStencilFormat) {
1478 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1479 HRESULT hr = WINED3DERR_NOTAVAILABLE;
1480 WineD3D_Context* ctx = NULL;
1481 GLXFBConfig* cfgs = NULL;
1482 int nCfgs = 0;
1483 int it;
1484
1485 WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1486 This, Adapter,
1487 DeviceType, debug_d3ddevicetype(DeviceType),
1488 AdapterFormat, debug_d3dformat(AdapterFormat),
1489 RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
1490 DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
1491
1492 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1493 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
1494 return WINED3DERR_INVALIDCALL;
1495 }
1496 /* TODO: use the real context if it's available */
1497 ctx = WineD3D_CreateFakeGLContext();
1498 if(NULL != ctx) {
1499 cfgs = glXGetFBConfigs(ctx->display, DefaultScreen(ctx->display), &nCfgs);
1500 } else {
1501 TRACE_(d3d_caps)("(%p) : Unable to create a fake context at this time (there may already be an active context)\n", This);
1502 }
1503
1504 if (NULL != cfgs) {
1505 for (it = 0; it < nCfgs; ++it) {
1506 if (IWineD3DImpl_IsGLXFBConfigCompatibleWithRenderFmt(ctx->display, cfgs[it], RenderTargetFormat)) {
1507 if (IWineD3DImpl_IsGLXFBConfigCompatibleWithDepthFmt(ctx->display, cfgs[it], DepthStencilFormat)) {
1508 hr = WINED3D_OK;
1509 break ;
1510 }
1511 }
1512 }
1513 XFree(cfgs);
1514 cfgs = NULL;
1515 } else {
1516 /* If there's a current context then we cannot create a fake one so pass everything */
1517 hr = WINED3D_OK;
1518 }
1519
1520 if (ctx != NULL)
1521 WineD3D_ReleaseFakeGLContext(ctx);
1522
1523 if (hr != WINED3D_OK)
1524 TRACE_(d3d_caps)("Failed to match stencil format to device\n");
1525
1526 TRACE_(d3d_caps)("(%p) : Returning %x\n", This, hr);
1527 return hr;
1528 }
1529
1530 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1531 WINED3DFORMAT SurfaceFormat,
1532 BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) {
1533
1534 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1535 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1536 This,
1537 Adapter,
1538 DeviceType, debug_d3ddevicetype(DeviceType),
1539 SurfaceFormat, debug_d3dformat(SurfaceFormat),
1540 Windowed,
1541 MultiSampleType,
1542 pQualityLevels);
1543
1544 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1545 return WINED3DERR_INVALIDCALL;
1546 }
1547
1548 if (pQualityLevels != NULL) {
1549 static int s_single_shot = 0;
1550 if (!s_single_shot) {
1551 FIXME("Quality levels unsupported at present\n");
1552 s_single_shot = 1;
1553 }
1554 *pQualityLevels = 1; /* Guess at a value! */
1555 }
1556
1557 if (WINED3DMULTISAMPLE_NONE == MultiSampleType) return WINED3D_OK;
1558 return WINED3DERR_NOTAVAILABLE;
1559 }
1560
1561 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE CheckType,
1562 WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed) {
1563
1564 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1565 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1566 This,
1567 Adapter,
1568 CheckType, debug_d3ddevicetype(CheckType),
1569 DisplayFormat, debug_d3dformat(DisplayFormat),
1570 BackBufferFormat, debug_d3dformat(BackBufferFormat),
1571 Windowed);
1572
1573 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1574 return WINED3DERR_INVALIDCALL;
1575 }
1576
1577 {
1578 GLXFBConfig* cfgs = NULL;
1579 int nCfgs = 0;
1580 int it;
1581 HRESULT hr = WINED3DERR_NOTAVAILABLE;
1582
1583 WineD3D_Context* ctx = WineD3D_CreateFakeGLContext();
1584 if (NULL != ctx) {
1585 cfgs = glXGetFBConfigs(ctx->display, DefaultScreen(ctx->display), &nCfgs);
1586 for (it = 0; it < nCfgs; ++it) {
1587 if (IWineD3DImpl_IsGLXFBConfigCompatibleWithRenderFmt(ctx->display, cfgs[it], DisplayFormat)) {
1588 hr = WINED3D_OK;
1589 break ;
1590 }
1591 }
1592 XFree(cfgs);
1593
1594 WineD3D_ReleaseFakeGLContext(ctx);
1595 return hr;
1596 }
1597 }
1598
1599 return WINED3DERR_NOTAVAILABLE;
1600 }
1601
1602 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1603 WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat) {
1604 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1605 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
1606 This,
1607 Adapter,
1608 DeviceType, debug_d3ddevicetype(DeviceType),
1609 AdapterFormat, debug_d3dformat(AdapterFormat),
1610 Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
1611 RType, debug_d3dresourcetype(RType),
1612 CheckFormat, debug_d3dformat(CheckFormat));
1613
1614 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1615 return WINED3DERR_INVALIDCALL;
1616 }
1617
1618 /* TODO: Check support against more of the WINED3DUSAGE_QUERY_* constants
1619 * See http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/IDirect3D9__CheckDeviceFormat.asp
1620 * and http://msdn.microsoft.com/library/default.asp?url=/library/en-us/directx9_c/D3DUSAGE_QUERY.asp */
1621 if (Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
1622 TRACE_(d3d_caps)("[FAILED]\n");
1623 return WINED3DERR_NOTAVAILABLE; /* Enable when fully supported */
1624 }
1625
1626 if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
1627 switch (CheckFormat) {
1628 case WINED3DFMT_D16_LOCKABLE:
1629 case WINED3DFMT_D32:
1630 case WINED3DFMT_D15S1:
1631 case WINED3DFMT_D24S8:
1632 case WINED3DFMT_D24X8:
1633 case WINED3DFMT_D24X4S4:
1634 case WINED3DFMT_D16:
1635 case WINED3DFMT_L16:
1636 case WINED3DFMT_D32F_LOCKABLE:
1637 case WINED3DFMT_D24FS8:
1638 TRACE_(d3d_caps)("[OK]\n");
1639 return WINED3D_OK;
1640 default:
1641 TRACE_(d3d_caps)("[FAILED]\n");
1642 return WINED3DERR_NOTAVAILABLE;
1643 }
1644 } else if(Usage & WINED3DUSAGE_RENDERTARGET) {
1645 switch (CheckFormat) {
1646 case WINED3DFMT_R8G8B8:
1647 case WINED3DFMT_A8R8G8B8:
1648 case WINED3DFMT_X8R8G8B8:
1649 case WINED3DFMT_R5G6B5:
1650 case WINED3DFMT_X1R5G5B5:
1651 case WINED3DFMT_A1R5G5B5:
1652 case WINED3DFMT_A4R4G4B4:
1653 case WINED3DFMT_R3G3B2:
1654 case WINED3DFMT_X4R4G4B4:
1655 case WINED3DFMT_A8B8G8R8:
1656 case WINED3DFMT_X8B8G8R8:
1657 case WINED3DFMT_P8:
1658 TRACE_(d3d_caps)("[OK]\n");
1659 return WINED3D_OK;
1660 default:
1661 TRACE_(d3d_caps)("[FAILED]\n");
1662 return WINED3DERR_NOTAVAILABLE;
1663 }
1664 }
1665
1666 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
1667 switch (CheckFormat) {
1668 case WINED3DFMT_DXT1:
1669 case WINED3DFMT_DXT2:
1670 case WINED3DFMT_DXT3:
1671 case WINED3DFMT_DXT4:
1672 case WINED3DFMT_DXT5:
1673 TRACE_(d3d_caps)("[OK]\n");
1674 return WINED3D_OK;
1675 default:
1676 break; /* Avoid compiler warnings */
1677 }
1678 }
1679
1680 if (GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
1681
1682 BOOL half_pixel_support = GL_SUPPORT(ARB_HALF_FLOAT_PIXEL);
1683
1684 switch (CheckFormat) {
1685 case WINED3DFMT_R16F:
1686 case WINED3DFMT_A16B16G16R16F:
1687 if (!half_pixel_support) break;
1688 case WINED3DFMT_R32F:
1689 case WINED3DFMT_A32B32G32R32F:
1690 TRACE_(d3d_caps)("[OK]\n");
1691 return WINED3D_OK;
1692 default:
1693 break; /* Avoid compiler warnings */
1694 }
1695 }
1696
1697 /* This format is nothing special and it is supported perfectly.
1698 * However, ati and nvidia driver on windows do not mark this format as
1699 * supported (tested with the dxCapsViewer) and pretending to
1700 * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
1701 * So do the same as Windows drivers and pretend not to support it on dx8 and 9
1702 * Enable it on dx7. It will need additional checking on dx10 when we support it.
1703 */
1704 if(This->dxVersion > 7 && CheckFormat == WINED3DFMT_R8G8B8) {
1705 TRACE_(d3d_caps)("[FAILED]\n");
1706 return WINED3DERR_NOTAVAILABLE;
1707 }
1708
1709 switch (CheckFormat) {
1710
1711 /*****
1712 * supported: RGB(A) formats
1713 */
1714 case WINED3DFMT_R8G8B8: /* Enable for dx7, blacklisted for 8 and 9 above */
1715 case WINED3DFMT_A8R8G8B8:
1716 case WINED3DFMT_X8R8G8B8:
1717 case WINED3DFMT_R5G6B5:
1718 case WINED3DFMT_X1R5G5B5:
1719 case WINED3DFMT_A1R5G5B5:
1720 case WINED3DFMT_A4R4G4B4:
1721 case WINED3DFMT_R3G3B2:
1722 case WINED3DFMT_A8:
1723 case WINED3DFMT_A8R3G3B2:
1724 case WINED3DFMT_X4R4G4B4:
1725 case WINED3DFMT_A8B8G8R8:
1726 case WINED3DFMT_X8B8G8R8:
1727 case WINED3DFMT_A2R10G10B10:
1728 case WINED3DFMT_A2B10G10R10:
1729 TRACE_(d3d_caps)("[OK]\n");
1730 return WINED3D_OK;
1731
1732 /*****
1733 * supported: Palettized
1734 */
1735 case WINED3DFMT_P8:
1736 TRACE_(d3d_caps)("[OK]\n");
1737 return WINED3D_OK;
1738
1739 /*****
1740 * Supported: (Alpha)-Luminance
1741 */
1742 case WINED3DFMT_L8:
1743 case WINED3DFMT_A8L8:
1744 case WINED3DFMT_A4L4:
1745 TRACE_(d3d_caps)("[OK]\n");
1746 return WINED3D_OK;
1747
1748 /*****
1749 * Not supported for now: Bump mapping formats
1750 * Enable some because games often fail when they are not available
1751 * and are still playable even without bump mapping
1752 */
1753 case WINED3DFMT_V8U8:
1754 case WINED3DFMT_V16U16:
1755 case WINED3DFMT_L6V5U5:
1756 case WINED3DFMT_X8L8V8U8:
1757 case WINED3DFMT_Q8W8V8U8:
1758 case WINED3DFMT_W11V11U10:
1759 case WINED3DFMT_A2W10V10U10:
1760 WARN_(d3d_caps)("[Not supported, but pretended to do]\n");
1761 return WINED3D_OK;
1762
1763 /*****
1764 * DXTN Formats: Handled above
1765 * WINED3DFMT_DXT1
1766 * WINED3DFMT_DXT2
1767 * WINED3DFMT_DXT3
1768 * WINED3DFMT_DXT4
1769 * WINED3DFMT_DXT5
1770 */
1771
1772 /*****
1773 * Odd formats - not supported
1774 */
1775 case WINED3DFMT_VERTEXDATA:
1776 case WINED3DFMT_INDEX16:
1777 case WINED3DFMT_INDEX32:
1778 case WINED3DFMT_Q16W16V16U16:
1779 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1780 return WINED3DERR_NOTAVAILABLE;
1781
1782 /*****
1783 * Float formats: Not supported right now
1784 */
1785 case WINED3DFMT_G16R16F:
1786 case WINED3DFMT_G32R32F:
1787 case WINED3DFMT_CxV8U8:
1788 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1789 return WINED3DERR_NOTAVAILABLE;
1790
1791 /* Not supported */
1792 case WINED3DFMT_G16R16:
1793 case WINED3DFMT_A16B16G16R16:
1794 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
1795 return WINED3DERR_NOTAVAILABLE;
1796
1797 default:
1798 break;
1799 }
1800
1801 TRACE_(d3d_caps)("[FAILED]\n");
1802 return WINED3DERR_NOTAVAILABLE;
1803 }
1804
1805 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1806 WINED3DFORMAT SourceFormat, WINED3DFORMAT TargetFormat) {
1807 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1808
1809 FIXME_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
1810 This,
1811 Adapter,
1812 DeviceType, debug_d3ddevicetype(DeviceType),
1813 SourceFormat, debug_d3dformat(SourceFormat),
1814 TargetFormat, debug_d3dformat(TargetFormat));
1815 return WINED3D_OK;
1816 }
1817
1818 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
1819 subset of a D3DCAPS9 structure. However, it has to come via a void *
1820 as the d3d8 interface cannot import the d3d9 header */
1821 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
1822
1823 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1824 int vs_selected_mode;
1825 int ps_selected_mode;
1826
1827 TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
1828
1829 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1830 return WINED3DERR_INVALIDCALL;
1831 }
1832
1833 /* FIXME: GL info should be per adapter */
1834
1835 /* If we don't know the device settings, go query them now */
1836 if (!This->isGLInfoValid) {
1837 /* use the desktop window to fill gl caps */
1838 BOOL rc = IWineD3DImpl_FillGLCaps(iface, IWineD3DImpl_GetAdapterDisplay(iface, Adapter));
1839
1840 /* We are running off a real context, save the values */
1841 if (rc) This->isGLInfoValid = TRUE;
1842 }
1843 select_shader_mode(&This->gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
1844
1845 /* This function should *not* be modifying GL caps
1846 * TODO: move the functionality where it belongs */
1847 select_shader_max_constants(ps_selected_mode, vs_selected_mode, &This->gl_info);
1848
1849 /* ------------------------------------------------
1850 The following fields apply to both d3d8 and d3d9
1851 ------------------------------------------------ */
1852 *pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
1853 *pCaps->AdapterOrdinal = Adapter;
1854
1855 *pCaps->Caps = 0;
1856 *pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
1857 WINED3DCAPS2_FULLSCREENGAMMA;
1858 *pCaps->Caps3 = 0;
1859 *pCaps->PresentationIntervals = D3DPRESENT_INTERVAL_IMMEDIATE;
1860
1861 *pCaps->CursorCaps = 0;
1862
1863
1864 *pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
1865 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
1866 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
1867 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
1868 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
1869 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
1870 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
1871 WINED3DDEVCAPS_PUREDEVICE |
1872 WINED3DDEVCAPS_HWRASTERIZATION |
1873 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
1874 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
1875 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
1876 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
1877 WINED3DDEVCAPS_DRAWPRIMITIVES2EX;
1878
1879 *pCaps->PrimitiveMiscCaps = D3DPMISCCAPS_CULLNONE |
1880 D3DPMISCCAPS_CULLCCW |
1881 D3DPMISCCAPS_CULLCW |
1882 D3DPMISCCAPS_COLORWRITEENABLE |
1883 D3DPMISCCAPS_CLIPTLVERTS |
1884 D3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
1885 D3DPMISCCAPS_MASKZ |
1886 D3DPMISCCAPS_BLENDOP;
1887 /* TODO:
1888 D3DPMISCCAPS_NULLREFERENCE
1889 D3DPMISCCAPS_INDEPENDENTWRITEMASKS
1890 D3DPMISCCAPS_FOGANDSPECULARALPHA
1891 D3DPMISCCAPS_SEPARATEALPHABLEND
1892 D3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
1893 D3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING
1894 D3DPMISCCAPS_FOGVERTEXCLAMPED */
1895
1896 /* The caps below can be supported but aren't handled yet in utils.c 'd3dta_to_combiner_input', disable them until support is fixed */
1897 #if 0
1898 if (GL_SUPPORT(NV_REGISTER_COMBINERS))
1899 *pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_TSSARGTEMP;
1900 if (GL_SUPPORT(NV_REGISTER_COMBINERS2))
1901 *pCaps->PrimitiveMiscCaps |= D3DPMISCCAPS_PERSTAGECONSTANT;
1902 #endif
1903
1904 *pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
1905 WINED3DPRASTERCAPS_PAT |
1906 WINED3DPRASTERCAPS_WFOG |
1907 WINED3DPRASTERCAPS_ZFOG |
1908 WINED3DPRASTERCAPS_FOGVERTEX |
1909 WINED3DPRASTERCAPS_FOGTABLE |
1910 WINED3DPRASTERCAPS_FOGRANGE |
1911 WINED3DPRASTERCAPS_STIPPLE |
1912 WINED3DPRASTERCAPS_SUBPIXEL |
1913 WINED3DPRASTERCAPS_ZTEST |
1914 WINED3DPRASTERCAPS_SCISSORTEST |
1915 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
1916 WINED3DPRASTERCAPS_DEPTHBIAS;
1917
1918 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
1919 *pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
1920 WINED3DPRASTERCAPS_ZBIAS |
1921 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
1922 }
1923 /* FIXME Add:
1924 WINED3DPRASTERCAPS_COLORPERSPECTIVE
1925 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
1926 WINED3DPRASTERCAPS_ANTIALIASEDGES
1927 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
1928 WINED3DPRASTERCAPS_WBUFFER */
1929
1930 *pCaps->ZCmpCaps = D3DPCMPCAPS_ALWAYS |
1931 D3DPCMPCAPS_EQUAL |
1932 D3DPCMPCAPS_GREATER |
1933 D3DPCMPCAPS_GREATEREQUAL |
1934 D3DPCMPCAPS_LESS |
1935 D3DPCMPCAPS_LESSEQUAL |
1936 D3DPCMPCAPS_NEVER |
1937 D3DPCMPCAPS_NOTEQUAL;
1938
1939 *pCaps->SrcBlendCaps = D3DPBLENDCAPS_BLENDFACTOR |
1940 D3DPBLENDCAPS_BOTHINVSRCALPHA |
1941 D3DPBLENDCAPS_BOTHSRCALPHA |
1942 D3DPBLENDCAPS_DESTALPHA |
1943 D3DPBLENDCAPS_DESTCOLOR |
1944 D3DPBLENDCAPS_INVDESTALPHA |
1945 D3DPBLENDCAPS_INVDESTCOLOR |
1946 D3DPBLENDCAPS_INVSRCALPHA |
1947 D3DPBLENDCAPS_INVSRCCOLOR |
1948 D3DPBLENDCAPS_ONE |
1949 D3DPBLENDCAPS_SRCALPHA |
1950 D3DPBLENDCAPS_SRCALPHASAT |
1951 D3DPBLENDCAPS_SRCCOLOR |
1952 D3DPBLENDCAPS_ZERO;
1953
1954 *pCaps->DestBlendCaps = D3DPBLENDCAPS_BLENDFACTOR |
1955 D3DPBLENDCAPS_BOTHINVSRCALPHA |
1956 D3DPBLENDCAPS_BOTHSRCALPHA |
1957 D3DPBLENDCAPS_DESTALPHA |
1958 D3DPBLENDCAPS_DESTCOLOR |
1959 D3DPBLENDCAPS_INVDESTALPHA |
1960 D3DPBLENDCAPS_INVDESTCOLOR |
1961 D3DPBLENDCAPS_INVSRCALPHA |
1962 D3DPBLENDCAPS_INVSRCCOLOR |
1963 D3DPBLENDCAPS_ONE |
1964 D3DPBLENDCAPS_SRCALPHA |
1965 D3DPBLENDCAPS_SRCALPHASAT |
1966 D3DPBLENDCAPS_SRCCOLOR |
1967 D3DPBLENDCAPS_ZERO;
1968
1969 *pCaps->AlphaCmpCaps = D3DPCMPCAPS_ALWAYS |
1970 D3DPCMPCAPS_EQUAL |
1971 D3DPCMPCAPS_GREATER |
1972 D3DPCMPCAPS_GREATEREQUAL |
1973 D3DPCMPCAPS_LESS |
1974 D3DPCMPCAPS_LESSEQUAL |
1975 D3DPCMPCAPS_NEVER |
1976 D3DPCMPCAPS_NOTEQUAL;
1977
1978 *pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
1979 WINED3DPSHADECAPS_COLORGOURAUDRGB |
1980 WINED3DPSHADECAPS_ALPHAFLATBLEND |
1981 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
1982 WINED3DPSHADECAPS_COLORFLATRGB |
1983 WINED3DPSHADECAPS_FOGFLAT |
1984 WINED3DPSHADECAPS_FOGGOURAUD |
1985 WINED3DPSHADECAPS_SPECULARFLATRGB;
1986
1987 *pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
1988 WINED3DPTEXTURECAPS_ALPHAPALETTE |
1989 WINED3DPTEXTURECAPS_BORDER |
1990 WINED3DPTEXTURECAPS_MIPMAP |
1991 WINED3DPTEXTURECAPS_PROJECTED |
1992 WINED3DPTEXTURECAPS_PERSPECTIVE |
1993 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
1994
1995 if( GL_SUPPORT(EXT_TEXTURE3D)) {
1996 *pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
1997 WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
1998 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
1999 }
2000
2001 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2002 *pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
2003 WINED3DPTEXTURECAPS_MIPCUBEMAP |
2004 WINED3DPTEXTURECAPS_CUBEMAP_POW2;
2005
2006 }
2007
2008 *pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
2009 WINED3DPTFILTERCAPS_MAGFPOINT |
2010 WINED3DPTFILTERCAPS_MINFLINEAR |
2011 WINED3DPTFILTERCAPS_MINFPOINT |
2012 WINED3DPTFILTERCAPS_MIPFLINEAR |
2013 WINED3DPTFILTERCAPS_MIPFPOINT |
2014 WINED3DPTFILTERCAPS_LINEAR |
2015 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
2016 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2017 WINED3DPTFILTERCAPS_MIPLINEAR |
2018 WINED3DPTFILTERCAPS_MIPNEAREST |
2019 WINED3DPTFILTERCAPS_NEAREST;
2020
2021 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2022 *pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
2023 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
2024 }
2025
2026 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2027 *pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
2028 WINED3DPTFILTERCAPS_MAGFPOINT |
2029 WINED3DPTFILTERCAPS_MINFLINEAR |
2030 WINED3DPTFILTERCAPS_MINFPOINT |
2031 WINED3DPTFILTERCAPS_MIPFLINEAR |
2032 WINED3DPTFILTERCAPS_MIPFPOINT |
2033 WINED3DPTFILTERCAPS_LINEAR |
2034 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
2035 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2036 WINED3DPTFILTERCAPS_MIPLINEAR |
2037 WINED3DPTFILTERCAPS_MIPNEAREST |
2038 WINED3DPTFILTERCAPS_NEAREST;
2039
2040 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
2041 *pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
2042 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
2043 }
2044 } else
2045 *pCaps->CubeTextureFilterCaps = 0;
2046
2047 if (GL_SUPPORT(EXT_TEXTURE3D)) {
2048 *pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
2049 WINED3DPTFILTERCAPS_MAGFPOINT |
2050 WINED3DPTFILTERCAPS_MINFLINEAR |
2051 WINED3DPTFILTERCAPS_MINFPOINT |
2052 WINED3DPTFILTERCAPS_MIPFLINEAR |
2053 WINED3DPTFILTERCAPS_MIPFPOINT |
2054 WINED3DPTFILTERCAPS_LINEAR |
2055 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
2056 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
2057 WINED3DPTFILTERCAPS_MIPLINEAR |
2058 WINED3DPTFILTERCAPS_MIPNEAREST |
2059 WINED3DPTFILTERCAPS_NEAREST;
2060 } else
2061 *pCaps->VolumeTextureFilterCaps = 0;
2062
2063 *pCaps->TextureAddressCaps = D3DPTADDRESSCAPS_INDEPENDENTUV |
2064 D3DPTADDRESSCAPS_CLAMP |
2065 D3DPTADDRESSCAPS_WRAP;
2066
2067 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
2068 *pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_BORDER;
2069 }
2070 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
2071 *pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRROR;
2072 }
2073 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
2074 *pCaps->TextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
2075 }
2076
2077 if (GL_SUPPORT(EXT_TEXTURE3D)) {
2078 *pCaps->VolumeTextureAddressCaps = D3DPTADDRESSCAPS_INDEPENDENTUV |
2079 D3DPTADDRESSCAPS_CLAMP |
2080 D3DPTADDRESSCAPS_WRAP;
2081 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
2082 *pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_BORDER;
2083 }
2084 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
2085 *pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRROR;
2086 }
2087 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
2088 *pCaps->VolumeTextureAddressCaps |= D3DPTADDRESSCAPS_MIRRORONCE;
2089 }
2090 } else
2091 *pCaps->VolumeTextureAddressCaps = 0;
2092
2093 *pCaps->LineCaps = D3DLINECAPS_TEXTURE |
2094 D3DLINECAPS_ZTEST;
2095 /* FIXME: Add
2096 D3DLINECAPS_BLEND
2097 D3DLINECAPS_ALPHACMP
2098 D3DLINECAPS_FOG */
2099
2100 *pCaps->MaxTextureWidth = GL_LIMITS(texture_size);
2101 *pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
2102
2103 if(GL_SUPPORT(EXT_TEXTURE3D))
2104 *pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
2105 else
2106 *pCaps->MaxVolumeExtent = 0;
2107
2108 *pCaps->MaxTextureRepeat = 32768;
2109 *pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
2110 *pCaps->MaxVertexW = 1.0;
2111
2112 *pCaps->GuardBandLeft = 0;
2113 *pCaps->GuardBandTop = 0;
2114 *pCaps->GuardBandRight = 0;
2115 *pCaps->GuardBandBottom = 0;
2116
2117 *pCaps->ExtentsAdjust = 0;
2118
2119 *pCaps->StencilCaps = D3DSTENCILCAPS_DECRSAT |
2120 D3DSTENCILCAPS_INCRSAT |
2121 D3DSTENCILCAPS_INVERT |
2122 D3DSTENCILCAPS_KEEP |
2123 D3DSTENCILCAPS_REPLACE |
2124 D3DSTENCILCAPS_ZERO;
2125 if (GL_SUPPORT(EXT_STENCIL_WRAP)) {
2126 *pCaps->StencilCaps |= D3DSTENCILCAPS_DECR |
2127 D3DSTENCILCAPS_INCR;
2128 }
2129 if ( This->dxVersion > 8 &&
2130 ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE) ||
2131 GL_SUPPORT(ATI_SEPARATE_STENCIL) ) ) {
2132 *pCaps->StencilCaps |= D3DSTENCILCAPS_TWOSIDED;
2133 }
2134
2135 *pCaps->FVFCaps = D3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
2136
2137 *pCaps->TextureOpCaps = D3DTEXOPCAPS_ADD |
2138 D3DTEXOPCAPS_ADDSIGNED |
2139 D3DTEXOPCAPS_ADDSIGNED2X |
2140 D3DTEXOPCAPS_MODULATE |
2141 D3DTEXOPCAPS_MODULATE2X |
2142 D3DTEXOPCAPS_MODULATE4X |
2143 D3DTEXOPCAPS_SELECTARG1 |
2144 D3DTEXOPCAPS_SELECTARG2 |
2145 D3DTEXOPCAPS_DISABLE;
2146
2147 if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE) ||
2148 GL_SUPPORT(EXT_TEXTURE_ENV_COMBINE) ||
2149 GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2150 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_BLENDDIFFUSEALPHA |
2151 D3DTEXOPCAPS_BLENDTEXTUREALPHA |
2152 D3DTEXOPCAPS_BLENDFACTORALPHA |
2153 D3DTEXOPCAPS_BLENDCURRENTALPHA |
2154 D3DTEXOPCAPS_LERP |
2155 D3DTEXOPCAPS_SUBTRACT;
2156 }
2157 if (GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4)) {
2158 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_ADDSMOOTH |
2159 D3DTEXOPCAPS_MULTIPLYADD |
2160 D3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR |
2161 D3DTEXOPCAPS_MODULATECOLOR_ADDALPHA |
2162 D3DTEXOPCAPS_BLENDTEXTUREALPHAPM;
2163 }
2164 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3))
2165 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_DOTPRODUCT3;
2166
2167 if (GL_SUPPORT(NV_REGISTER_COMBINERS)) {
2168 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR |
2169 D3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA;
2170 }
2171
2172
2173 #if 0
2174 *pCaps->TextureOpCaps |= D3DTEXOPCAPS_BUMPENVMAP;
2175 /* FIXME: Add
2176 D3DTEXOPCAPS_BUMPENVMAPLUMINANCE
2177 D3DTEXOPCAPS_PREMODULATE */
2178 #endif
2179
2180 *pCaps->MaxTextureBlendStages = GL_LIMITS(texture_stages);
2181 *pCaps->MaxSimultaneousTextures = GL_LIMITS(textures);
2182 *pCaps->MaxUserClipPlanes = GL_LIMITS(clipplanes);
2183 *pCaps->MaxActiveLights = GL_LIMITS(lights);
2184
2185
2186
2187 #if 0 /* TODO: Blends support in drawprim */
2188 *pCaps->MaxVertexBlendMatrices = GL_LIMITS(blends);
2189 #else
2190 *pCaps->MaxVertexBlendMatrices = 0;
2191 #endif
2192 *pCaps->MaxVertexBlendMatrixIndex = 1;
2193
2194 *pCaps->MaxAnisotropy = GL_LIMITS(anisotropy);
2195 *pCaps->MaxPointSize = GL_LIMITS(pointsize);
2196
2197
2198 *pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
2199 WINED3DVTXPCAPS_MATERIALSOURCE7 |
2200 WINED3DVTXPCAPS_POSITIONALLIGHTS |
2201 WINED3DVTXPCAPS_LOCALVIEWER |
2202 WINED3DVTXPCAPS_VERTEXFOG |
2203 WINED3DVTXPCAPS_TEXGEN;
2204 /* FIXME: Add
2205 D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
2206
2207 *pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
2208 *pCaps->MaxVertexIndex = 0xFFFFF;
2209 *pCaps->MaxStreams = MAX_STREAMS;
2210 *pCaps->MaxStreamStride = 1024;
2211
2212 if (vs_selected_mode == SHADER_GLSL) {
2213 /* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
2214 models with GLSL support only support 2.0. In case of nvidia we can detect VS 2.0 support using
2215 vs_nv_version which is based on NV_vertex_program. For Ati cards there's no easy way, so for
2216 now only support 2.0/3.0 detection on Nvidia GeforceFX cards and default to 3.0 for everything else */
2217 if(This->gl_info.vs_nv_version == VS_VERSION_20)
2218 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(2,0);
2219 else
2220 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
2221 TRACE_(d3d_caps)("Hardware vertex shader version 3.0 enabled (GLSL)\n");
2222 } else if (vs_selected_mode == SHADER_ARB) {
2223 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(1,1);
2224 TRACE_(d3d_caps)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
2225 } else if (vs_selected_mode == SHADER_SW) {
2226 *pCaps->VertexShaderVersion = WINED3DVS_VERSION(3,0);
2227 TRACE_(d3d_caps)("Software vertex shader version 3.0 enabled\n");
2228 } else {
2229 *pCaps->VertexShaderVersion = 0;
2230 TRACE_(d3d_caps)("Vertex shader functionality not available\n");
2231 }
2232
2233 *pCaps->MaxVertexShaderConst = GL_LIMITS(vshader_constantsF);
2234
2235 if (ps_selected_mode == SHADER_GLSL) {
2236 /* See the comment about VS2.0/VS3.0 detection as we do the same here but then based on NV_fragment_program
2237 in case of GeforceFX cards. */
2238 if(This->gl_info.ps_nv_version == PS_VERSION_20)
2239 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(2,0);
2240 else
2241 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
2242 /* FIXME: The following line is card dependent. -1.0 to 1.0 is a safe default clamp range for now */
2243 *pCaps->PixelShader1xMaxValue = 1.0;
2244 TRACE_(d3d_caps)("Hardware pixel shader version 3.0 enabled (GLSL)\n");
2245 } else if (ps_selected_mode == SHADER_ARB) {
2246 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(1,4);
2247 *pCaps->PixelShader1xMaxValue = 1.0;
2248 TRACE_(d3d_caps)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
2249 /* FIXME: Uncomment this when there is support for software Pixel Shader 3.0 and PS_SW is defined
2250 } else if (ps_selected_mode = SHADER_SW) {
2251 *pCaps->PixelShaderVersion = WINED3DPS_VERSION(3,0);
2252 *pCaps->PixelShader1xMaxValue = 1.0;
2253 TRACE_(d3d_caps)("Software pixel shader version 3.0 enabled\n"); */
2254 } else {
2255 *pCaps->PixelShaderVersion = 0;
2256 *pCaps->PixelShader1xMaxValue = 0.0;
2257 TRACE_(d3d_caps)("Pixel shader functionality not available\n");
2258 }
2259
2260 /* ------------------------------------------------
2261 The following fields apply to d3d9 only
2262 ------------------------------------------------ */
2263 if (This->dxVersion > 8) {
2264 FIXME("Caps support for directx9 is nonexistent at the moment!\n");
2265 *pCaps->DevCaps2 = 0;
2266 /* TODO: D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES and VS3.0 needs at least D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET */
2267 *pCaps->MaxNpatchTessellationLevel = 0;
2268 *pCaps->MasterAdapterOrdinal = 0;
2269 *pCaps->AdapterOrdinalInGroup = 0;
2270 *pCaps->NumberOfAdaptersInGroup = 1;
2271
2272 if(*pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
2273 /* OpenGL supports all formats below, perhaps not always without conversion but it supports them.
2274 Further GLSL doesn't seem to have an official unsigned type as I'm not sure how we handle it
2275 don't advertise it yet. We might need to add some clamping in the shader engine to support it.
2276 TODO: D3DDTCAPS_USHORT2N, D3DDTCAPS_USHORT4N, D3DDTCAPS_UDEC3, D3DDTCAPS_DEC3N */
2277 *pCaps->DeclTypes = D3DDTCAPS_UBYTE4 |
2278 D3DDTCAPS_UBYTE4N |
2279 D3DDTCAPS_SHORT2N |
2280 D3DDTCAPS_SHORT4N |
2281 D3DDTCAPS_FLOAT16_2 |
2282 D3DDTCAPS_FLOAT16_4;
2283
2284 } else
2285 *pCaps->DeclTypes = 0;
2286
2287 #if 0 /* We don't properly support multiple render targets yet, so disable this for now */
2288 if (GL_SUPPORT(ARB_DRAWBUFFERS)) {
2289 *pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
2290 } else
2291 #endif
2292 *pCaps->NumSimultaneousRTs = 1;
2293
2294 *pCaps->StretchRectFilterCaps = 0;
2295 *pCaps->VertexTextureFilterCaps = 0;
2296
2297 if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
2298 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
2299 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
2300 *pCaps->VS20Caps.Caps = D3DVS20CAPS_PREDICATION;
2301 *pCaps->VS20Caps.DynamicFlowControlDepth = D3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
2302 *pCaps->VS20Caps.NumTemps = max(32, This->gl_info.vs_arb_max_temps);
2303 *pCaps->VS20Caps.StaticFlowControlDepth = D3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
2304
2305 *pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
2306 *pCaps->MaxVertexShader30InstructionSlots = max(512, This->gl_info.vs_arb_max_instructions);
2307 } else if(*pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
2308 *pCaps->VS20Caps.Caps = 0;
2309 *pCaps->VS20Caps.DynamicFlowControlDepth = D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
2310 *pCaps->VS20Caps.NumTemps = max(12, This->gl_info.vs_arb_max_temps);
2311 *pCaps->VS20Caps.StaticFlowControlDepth = 1;
2312
2313 *pCaps->MaxVShaderInstructionsExecuted = 65535;
2314 *pCaps->MaxVertexShader30InstructionSlots = 0;
2315 } else { /* VS 1.x */
2316 *pCaps->VS20Caps.Caps = 0;
2317 *pCaps->VS20Caps.DynamicFlowControlDepth = 0;
2318 *pCaps->VS20Caps.NumTemps = 0;
2319 *pCaps->VS20Caps.StaticFlowControlDepth = 0;
2320
2321 *pCaps->MaxVShaderInstructionsExecuted = 0;
2322 *pCaps->MaxVertexShader30InstructionSlots = 0;
2323 }
2324
2325 if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
2326 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
2327 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
2328
2329 /* 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 */
2330 *pCaps->PS20Caps.Caps = D3DPS20CAPS_ARBITRARYSWIZZLE |
2331 D3DPS20CAPS_GRADIENTINSTRUCTIONS |
2332 D3DPS20CAPS_PREDICATION |
2333 D3DPS20CAPS_NODEPENDENTREADLIMIT |
2334 D3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
2335 *pCaps->PS20Caps.DynamicFlowControlDepth = D3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
2336 *pCaps->PS20Caps.NumTemps = max(32, This->gl_info.ps_arb_max_temps);
2337 *pCaps->PS20Caps.StaticFlowControlDepth = D3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
2338 *pCaps->PS20Caps.NumInstructionSlots = D3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
2339
2340 *pCaps->MaxPShaderInstructionsExecuted = 65535;
2341 *pCaps->MaxPixelShader30InstructionSlots = max(D3DMIN30SHADERINSTRUCTIONS, This->gl_info.ps_arb_max_instructions);
2342 } else if(*pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
2343 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
2344 *pCaps->PS20Caps.Caps = 0;
2345 *pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* D3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
2346 *pCaps->PS20Caps.NumTemps = max(12, This->gl_info.ps_arb_max_temps);
2347 *pCaps->PS20Caps.StaticFlowControlDepth = D3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minumum: 1 */
2348 *pCaps->PS20Caps.NumInstructionSlots = D3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
2349
2350 *pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
2351 *pCaps->MaxPixelShader30InstructionSlots = 0;
2352 } else { /* PS 1.x */
2353 *pCaps->PS20Caps.Caps = 0;
2354 *pCaps->PS20Caps.DynamicFlowControlDepth = 0;
2355 *pCaps->PS20Caps.NumTemps = 0;
2356 *pCaps->PS20Caps.StaticFlowControlDepth = 0;
2357 *pCaps->PS20Caps.NumInstructionSlots = 0;
2358
2359 *pCaps->MaxPShaderInstructionsExecuted = 0;
2360 *pCaps->MaxPixelShader30InstructionSlots = 0;
2361 }
2362 }
2363
2364 return WINED3D_OK;
2365 }
2366
2367
2368 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
2369 and fields being inserted in the middle, a new structure is used in place */
2370 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, HWND hFocusWindow,
2371 DWORD BehaviourFlags, IWineD3DDevice** ppReturnedDeviceInterface,
2372 IUnknown *parent) {
2373
2374 IWineD3DDeviceImpl *object = NULL;
2375 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2376 HDC hDC;
2377 HRESULT temp_result;
2378
2379 /* Validate the adapter number */
2380 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2381 return WINED3DERR_INVALIDCALL;
2382 }
2383
2384 /* Create a WineD3DDevice object */
2385 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DDeviceImpl));
2386 *ppReturnedDeviceInterface = (IWineD3DDevice *)object;
2387 TRACE("Created WineD3DDevice object @ %p\n", object);
2388 if (NULL == object) {
2389 return WINED3DERR_OUTOFVIDEOMEMORY;
2390 }
2391
2392 /* Set up initial COM information */
2393 object->lpVtbl = &IWineD3DDevice_Vtbl;
2394 object->ref = 1;
2395 object->wineD3D = iface;
2396 IWineD3D_AddRef(object->wineD3D);
2397 object->parent = parent;
2398
2399 /* Set the state up as invalid until the device is fully created */
2400 object->state = WINED3DERR_DRIVERINTERNALERROR;
2401
2402 TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This, Adapter, DeviceType,
2403 hFocusWindow, BehaviourFlags, ppReturnedDeviceInterface);
2404
2405 /* Save the creation parameters */
2406 object->createParms.AdapterOrdinal = Adapter;
2407 object->createParms.DeviceType = DeviceType;
2408 object->createParms.hFocusWindow = hFocusWindow;
2409 object->createParms.BehaviorFlags = BehaviourFlags;
2410
2411 /* Initialize other useful values */
2412 object->adapterNo = Adapter;
2413 object->devType = DeviceType;
2414
2415 TRACE("(%p) : Creating stateblock\n", This);
2416 /* Creating the startup stateBlock - Note Special Case: 0 => Don't fill in yet! */
2417 if (WINED3D_OK != IWineD3DDevice_CreateStateBlock((IWineD3DDevice *)object,
2418 WINED3DSBT_INIT,
2419 (IWineD3DStateBlock **)&object->stateBlock,
2420 NULL) || NULL == object->stateBlock) { /* Note: No parent needed for initial internal stateblock */
2421 WARN("Failed to create stateblock\n");
2422 goto create_device_error;
2423 }
2424 TRACE("(%p) : Created stateblock (%p)\n", This, object->stateBlock);
2425 object->updateStateBlock = object->stateBlock;
2426 IWineD3DStateBlock_AddRef((IWineD3DStateBlock*)object->updateStateBlock);
2427 /* Setup surfaces for the backbuffer, frontbuffer and depthstencil buffer */
2428
2429 /* Setup some defaults for creating the implicit swapchain */
2430 ENTER_GL();
2431 /* FIXME: GL info should be per adapter */
2432 IWineD3DImpl_FillGLCaps(iface, IWineD3DImpl_GetAdapterDisplay(iface, Adapter));
2433 LEAVE_GL();
2434 select_shader_mode(&This->gl_info, DeviceType, &object->ps_selected_mode, &object->vs_selected_mode);
2435
2436 /* This function should *not* be modifying GL caps
2437 * TODO: move the functionality where it belongs */
2438 select_shader_max_constants(object->ps_selected_mode, object->vs_selected_mode, &This->gl_info);
2439
2440 temp_result = allocate_shader_constants(object->updateStateBlock);
2441 if (WINED3D_OK != temp_result)
2442 return temp_result;
2443
2444 /* set the state of the device to valid */
2445 object->state = WINED3D_OK;
2446
2447 /* Get the initial screen setup for ddraw */
2448 object->ddraw_width = GetSystemMetrics(SM_CXSCREEN);
2449 object->ddraw_height = GetSystemMetrics(SM_CYSCREEN);
2450 hDC = CreateDCA("DISPLAY", NULL, NULL, NULL);
2451 object->ddraw_format = pixelformat_for_depth(GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES));
2452 DeleteDC(hDC);
2453
2454 return WINED3D_OK;
2455 create_device_error:
2456
2457 /* Set the device state to error */
2458 object->state = WINED3DERR_DRIVERINTERNALERROR;
2459
2460 if (object->updateStateBlock != NULL) {
2461 IWineD3DStateBlock_Release((IWineD3DStateBlock *)object->updateStateBlock);
2462 object->updateStateBlock = NULL;
2463 }
2464 if (object->stateBlock != NULL) {
2465 IWineD3DStateBlock_Release((IWineD3DStateBlock *)object->stateBlock);
2466 object->stateBlock = NULL;
2467 }
2468 if (object->renderTarget != NULL) {
2469 IWineD3DSurface_Release(object->renderTarget);
2470 object->renderTarget = NULL;
2471 }
2472 if (object->stencilBufferTarget != NULL) {
2473 IWineD3DSurface_Release(object->stencilBufferTarget);
2474 object->stencilBufferTarget = NULL;
2475 }
2476 if (object->stencilBufferTarget != NULL) {
2477 IWineD3DSurface_Release(object->stencilBufferTarget);
2478 object->stencilBufferTarget = NULL;
2479 }
2480 HeapFree(GetProcessHeap(), 0, object);
2481 *ppReturnedDeviceInterface = NULL;
2482 return WINED3DERR_INVALIDCALL;
2483
2484 }
2485
2486 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
2487 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2488 IUnknown_AddRef(This->parent);
2489 *pParent = This->parent;
2490 return WINED3D_OK;
2491 }
2492
2493 /**********************************************************
2494 * IWineD3D VTbl follows
2495 **********************************************************/
2496
2497 const IWineD3DVtbl IWineD3D_Vtbl =
2498 {
2499 /* IUnknown */
2500 IWineD3DImpl_QueryInterface,
2501 IWineD3DImpl_AddRef,
2502 IWineD3DImpl_Release,
2503 /* IWineD3D */
2504 IWineD3DImpl_GetParent,
2505 IWineD3DImpl_GetAdapterCount,
2506 IWineD3DImpl_RegisterSoftwareDevice,
2507 IWineD3DImpl_GetAdapterMonitor,
2508 IWineD3DImpl_GetAdapterModeCount,
2509 IWineD3DImpl_EnumAdapterModes,
2510 IWineD3DImpl_GetAdapterDisplayMode,
2511 IWineD3DImpl_GetAdapterIdentifier,
2512 IWineD3DImpl_CheckDeviceMultiSampleType,
2513 IWineD3DImpl_CheckDepthStencilMatch,
2514 IWineD3DImpl_CheckDeviceType,
2515 IWineD3DImpl_CheckDeviceFormat,
2516 IWineD3DImpl_CheckDeviceFormatConversion,
2517 IWineD3DImpl_GetDeviceCaps,
2518 IWineD3DImpl_CreateDevice
2519 };
Quick hack tree for wine patches julliard doesn't want to commit