?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 9bfdf186dc6a237cd7f58f0ee2ef677e81617b1d
[wine/hacks.git] / dlls / wined3d / directx.c
blob9cdc957334a485ff2086ff0b0502bfe5fb20d4c3
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 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
23 */
24
25 /* Compile time diagnostics: */
26
27 #ifndef DEBUG_SINGLE_MODE
28 /* Set to 1 to force only a single display mode to be exposed: */
29 #define DEBUG_SINGLE_MODE 0
30 #endif
31
32 #include "config.h"
33 #include <assert.h>
34 #include "wined3d_private.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
37 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps);
38
39 /* The d3d device ID */
40 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
41
42 /* Extension detection */
43 static const struct {
44 const char *extension_string;
45 GL_SupportedExt extension;
46 DWORD version;
47 } EXTENSION_MAP[] = {
48 /* APPLE */
49 {"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE, 0 },
50 {"GL_APPLE_fence", APPLE_FENCE, 0 },
51 {"GL_APPLE_flush_render", APPLE_FLUSH_RENDER, 0 },
52 {"GL_APPLE_ycbcr_422", APPLE_YCBCR_422, 0 },
53 {"GL_APPLE_float_pixels", APPLE_FLOAT_PIXELS, 0 },
54
55 /* ATI */
56 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL, 0 },
57 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3, 0 },
58 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE, 0 },
59 {"GL_ATI_envmap_bumpmap", ATI_ENVMAP_BUMPMAP, 0 },
60 {"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER, 0 },
61 {"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC, 0 },
62
63 /* ARB */
64 {"GL_ARB_color_buffer_float", ARB_COLOR_BUFFER_FLOAT, 0 },
65 {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS, 0 },
66 {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM, 0 },
67 {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER, 0 },
68 {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL, 0 },
69 {"GL_ARB_imaging", ARB_IMAGING, 0 },
70 {"GL_ARB_multisample", ARB_MULTISAMPLE, 0 }, /* needs GLX_ARB_MULTISAMPLE as well */
71 {"GL_ARB_multitexture", ARB_MULTITEXTURE, 0 },
72 {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY, 0 },
73 {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT, 0 },
74 {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS, 0 },
75 {"GL_ARB_point_sprite", ARB_POINT_SPRITE, 0 },
76 {"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP, 0 },
77 {"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION, 0 },
78 {"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP, 0 },
79 {"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD, 0 },
80 {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE, 0 },
81 {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3, 0 },
82 {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT, 0 },
83 {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT, 0 },
84 {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO, MAKEDWORD_VERSION(2, 0) },
85 {"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE, 0 },
86 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND, 0 },
87 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT, 0 },
88 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM, 0 },
89 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER, 0 },
90 {"GL_ARB_shader_objects", ARB_SHADER_OBJECTS, 0 },
91
92 /* EXT */
93 {"GL_EXT_blend_color", EXT_BLEND_COLOR, 0 },
94 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX, 0 },
95 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE, 0 },
96 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE, 0 },
97 {"GL_EXT_fog_coord", EXT_FOG_COORD, 0 },
98 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT, 0 },
99 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE, 0 },
100 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT, 0 },
101 {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE, 0 },
102 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS, 0 },
103 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR, 0 },
104 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE, 0 },
105 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP, 0 },
106 {"GL_EXT_texture3D", EXT_TEXTURE3D, MAKEDWORD_VERSION(1, 2) },
107 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC, 0 },
108 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC, 0 },
109 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD, 0 },
110 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE, 0 },
111 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3, 0 },
112 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB, 0 },
113 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC, 0 },
114 {"GL_EXT_texture_lod", EXT_TEXTURE_LOD, 0 },
115 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS, 0 },
116 {"GL_EXT_vertex_shader", EXT_VERTEX_SHADER, 0 },
117 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS, 0 },
118
119 /* NV */
120 {"GL_NV_half_float", NV_HALF_FLOAT, 0 },
121 {"GL_NV_fence", NV_FENCE, 0 },
122 {"GL_NV_fog_distance", NV_FOG_DISTANCE, 0 },
123 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM, 0 },
124 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2, 0 },
125 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS, 0 },
126 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2, 0 },
127 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION, 0 },
128 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4, 0 },
129 {"GL_NV_texture_shader", NV_TEXTURE_SHADER, 0 },
130 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2, 0 },
131 {"GL_NV_texture_shader3", NV_TEXTURE_SHADER3, 0 },
132 {"GL_NV_occlusion_query", NV_OCCLUSION_QUERY, 0 },
133 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM, 0 },
134 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1, 0 },
135 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2, 0 },
136 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3, 0 },
137 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP, 0 },
138 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT, 0 },
139
140 /* SGI */
141 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP, 0 },
142 };
143
144 /**********************************************************
145 * Utility functions follow
146 **********************************************************/
147
148 /* Adapters */
149 static int numAdapters = 0;
150 static struct WineD3DAdapter Adapters[1];
151
152 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat, WINED3DSURFTYPE SurfaceType);
153 static const struct fragment_pipeline *select_fragment_implementation(UINT Adapter, WINED3DDEVTYPE DeviceType);
154 static const shader_backend_t *select_shader_backend(UINT Adapter, WINED3DDEVTYPE DeviceType);
155 static const struct blit_shader *select_blit_implementation(UINT Adapter, WINED3DDEVTYPE DeviceType);
156
157 /* lookup tables */
158 int minLookup[MAX_LOOKUPS];
159 int maxLookup[MAX_LOOKUPS];
160 DWORD *stateLookup[MAX_LOOKUPS];
161
162 DWORD minMipLookup[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1];
163 DWORD minMipLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1][WINED3DTEXF_LINEAR + 1] = {
164 {GL_NEAREST, GL_NEAREST, GL_NEAREST},
165 {GL_NEAREST, GL_NEAREST, GL_NEAREST},
166 {GL_NEAREST, GL_NEAREST, GL_NEAREST},
167 {GL_NEAREST, GL_NEAREST, GL_NEAREST},
168 };
169
170 DWORD magLookup[WINED3DTEXF_ANISOTROPIC + 1];
171 DWORD magLookup_noFilter[WINED3DTEXF_ANISOTROPIC + 1] = {
172 GL_NEAREST, GL_NEAREST, GL_NEAREST, GL_NEAREST
173 };
174
175 /* drawStridedSlow attributes */
176 glAttribFunc position_funcs[WINED3DDECLTYPE_UNUSED];
177 glAttribFunc diffuse_funcs[WINED3DDECLTYPE_UNUSED];
178 glAttribFunc specular_funcs[WINED3DDECLTYPE_UNUSED];
179 glAttribFunc normal_funcs[WINED3DDECLTYPE_UNUSED];
180 glMultiTexCoordFunc multi_texcoord_funcs[WINED3DDECLTYPE_UNUSED];
181 glAttribFunc texcoord_funcs[WINED3DDECLTYPE_UNUSED];
182
183 /**
184 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
185 * i.e., there is no GL Context - Get a default rendering context to enable the
186 * function query some info from GL.
187 */
188
189 static int wined3d_fake_gl_context_ref = 0;
190 static BOOL wined3d_fake_gl_context_foreign;
191 static BOOL wined3d_fake_gl_context_available = FALSE;
192 static HDC wined3d_fake_gl_context_hdc = NULL;
193 static HWND wined3d_fake_gl_context_hwnd = NULL;
194
195 static CRITICAL_SECTION wined3d_fake_gl_context_cs;
196 static CRITICAL_SECTION_DEBUG wined3d_fake_gl_context_cs_debug =
197 {
198 0, 0, &wined3d_fake_gl_context_cs,
199 { &wined3d_fake_gl_context_cs_debug.ProcessLocksList,
200 &wined3d_fake_gl_context_cs_debug.ProcessLocksList },
201 0, 0, { (DWORD_PTR)(__FILE__ ": wined3d_fake_gl_context_cs") }
202 };
203 static CRITICAL_SECTION wined3d_fake_gl_context_cs = { &wined3d_fake_gl_context_cs_debug, -1, 0, 0, 0, 0 };
204
205 static void WineD3D_ReleaseFakeGLContext(void) {
206 HGLRC glCtx;
207
208 EnterCriticalSection(&wined3d_fake_gl_context_cs);
209
210 if(!wined3d_fake_gl_context_available) {
211 TRACE_(d3d_caps)("context not available\n");
212 LeaveCriticalSection(&wined3d_fake_gl_context_cs);
213 return;
214 }
215
216 glCtx = pwglGetCurrentContext();
217
218 TRACE_(d3d_caps)("decrementing ref from %i\n", wined3d_fake_gl_context_ref);
219 if (0 == (--wined3d_fake_gl_context_ref) ) {
220 if(!wined3d_fake_gl_context_foreign && glCtx) {
221 TRACE_(d3d_caps)("destroying fake GL context\n");
222 pwglMakeCurrent(NULL, NULL);
223 pwglDeleteContext(glCtx);
224 }
225 if(wined3d_fake_gl_context_hdc)
226 ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
227 wined3d_fake_gl_context_hdc = NULL; /* Make sure we don't think that it is still around */
228 if(wined3d_fake_gl_context_hwnd)
229 DestroyWindow(wined3d_fake_gl_context_hwnd);
230 wined3d_fake_gl_context_hwnd = NULL;
231 wined3d_fake_gl_context_available = FALSE;
232 }
233 assert(wined3d_fake_gl_context_ref >= 0);
234
235 LeaveCriticalSection(&wined3d_fake_gl_context_cs);
236 }
237
238 static BOOL WineD3D_CreateFakeGLContext(void) {
239 HGLRC glCtx = NULL;
240
241 EnterCriticalSection(&wined3d_fake_gl_context_cs);
242
243 TRACE("getting context...\n");
244 if(wined3d_fake_gl_context_ref > 0) goto ret;
245 assert(0 == wined3d_fake_gl_context_ref);
246
247 wined3d_fake_gl_context_foreign = TRUE;
248
249 glCtx = pwglGetCurrentContext();
250 if (!glCtx) {
251 PIXELFORMATDESCRIPTOR pfd;
252 int iPixelFormat;
253
254 wined3d_fake_gl_context_foreign = FALSE;
255
256 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes */
257 wined3d_fake_gl_context_hwnd = CreateWindowA("WineD3D_OpenGL", "WineD3D fake window", WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL);
258 if(!wined3d_fake_gl_context_hwnd) {
259 ERR("HWND creation failed!\n");
260 goto fail;
261 }
262 wined3d_fake_gl_context_hdc = GetDC(wined3d_fake_gl_context_hwnd);
263 if(!wined3d_fake_gl_context_hdc) {
264 ERR("GetDC failed!\n");
265 goto fail;
266 }
267
268 /* PixelFormat selection */
269 ZeroMemory(&pfd, sizeof(pfd));
270 pfd.nSize = sizeof(pfd);
271 pfd.nVersion = 1;
272 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW;/*PFD_GENERIC_ACCELERATED*/
273 pfd.iPixelType = PFD_TYPE_RGBA;
274 pfd.cColorBits = 32;
275 pfd.iLayerType = PFD_MAIN_PLANE;
276
277 iPixelFormat = ChoosePixelFormat(wined3d_fake_gl_context_hdc, &pfd);
278 if(!iPixelFormat) {
279 /* If this happens something is very wrong as ChoosePixelFormat barely fails */
280 ERR("Can't find a suitable iPixelFormat\n");
281 goto fail;
282 }
283 DescribePixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, sizeof(pfd), &pfd);
284 SetPixelFormat(wined3d_fake_gl_context_hdc, iPixelFormat, &pfd);
285
286 /* Create a GL context */
287 glCtx = pwglCreateContext(wined3d_fake_gl_context_hdc);
288 if (!glCtx) {
289 WARN_(d3d_caps)("Error creating default context for capabilities initialization\n");
290 goto fail;
291 }
292
293 /* Make it the current GL context */
294 if (!pwglMakeCurrent(wined3d_fake_gl_context_hdc, glCtx)) {
295 WARN_(d3d_caps)("Error setting default context as current for capabilities initialization\n");
296 goto fail;
297 }
298 }
299
300 ret:
301 TRACE("incrementing ref from %i\n", wined3d_fake_gl_context_ref);
302 wined3d_fake_gl_context_ref++;
303 wined3d_fake_gl_context_available = TRUE;
304 LeaveCriticalSection(&wined3d_fake_gl_context_cs);
305 return TRUE;
306 fail:
307 if(wined3d_fake_gl_context_hdc)
308 ReleaseDC(wined3d_fake_gl_context_hwnd, wined3d_fake_gl_context_hdc);
309 wined3d_fake_gl_context_hdc = NULL;
310 if(wined3d_fake_gl_context_hwnd)
311 DestroyWindow(wined3d_fake_gl_context_hwnd);
312 wined3d_fake_gl_context_hwnd = NULL;
313 if(glCtx) pwglDeleteContext(glCtx);
314 LeaveCriticalSection(&wined3d_fake_gl_context_cs);
315 return FALSE;
316 }
317
318 /* Adjust the amount of used texture memory */
319 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl *D3DDevice, long glram){
320 UINT Adapter = D3DDevice->adapterNo;
321
322 Adapters[Adapter].UsedTextureRam += glram;
323 TRACE("Adjusted gl ram by %ld to %d\n", glram, Adapters[Adapter].UsedTextureRam);
324 return Adapters[Adapter].UsedTextureRam;
325 }
326
327 /**********************************************************
328 * IUnknown parts follows
329 **********************************************************/
330
331 static HRESULT WINAPI IWineD3DImpl_QueryInterface(IWineD3D *iface,REFIID riid,LPVOID *ppobj)
332 {
333 IWineD3DDeviceImpl *This = (IWineD3DDeviceImpl *)iface;
334
335 TRACE("(%p)->(%s,%p)\n",This,debugstr_guid(riid),ppobj);
336 if (IsEqualGUID(riid, &IID_IUnknown)
337 || IsEqualGUID(riid, &IID_IWineD3DBase)
338 || IsEqualGUID(riid, &IID_IWineD3DDevice)) {
339 IUnknown_AddRef(iface);
340 *ppobj = This;
341 return S_OK;
342 }
343 *ppobj = NULL;
344 return E_NOINTERFACE;
345 }
346
347 static ULONG WINAPI IWineD3DImpl_AddRef(IWineD3D *iface) {
348 IWineD3DImpl *This = (IWineD3DImpl *)iface;
349 ULONG refCount = InterlockedIncrement(&This->ref);
350
351 TRACE("(%p) : AddRef increasing from %d\n", This, refCount - 1);
352 return refCount;
353 }
354
355 static ULONG WINAPI IWineD3DImpl_Release(IWineD3D *iface) {
356 IWineD3DImpl *This = (IWineD3DImpl *)iface;
357 ULONG ref;
358 TRACE("(%p) : Releasing from %d\n", This, This->ref);
359 ref = InterlockedDecrement(&This->ref);
360 if (ref == 0) {
361 HeapFree(GetProcessHeap(), 0, This);
362 }
363
364 return ref;
365 }
366
367 /* Set the shader type for this device, depending on the given capabilities,
368 * the device type, and the user preferences in wined3d_settings */
369
370 void select_shader_mode(
371 WineD3D_GL_Info *gl_info,
372 WINED3DDEVTYPE DeviceType,
373 int* ps_selected,
374 int* vs_selected) {
375
376 if (wined3d_settings.vs_mode == VS_NONE) {
377 *vs_selected = SHADER_NONE;
378 } else if (gl_info->supported[ARB_VERTEX_SHADER] && wined3d_settings.glslRequested) {
379 /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
380 * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
381 * shaders only on this card. */
382 if(gl_info->vs_nv_version && gl_info->vs_nv_version < VS_VERSION_20)
383 *vs_selected = SHADER_ARB;
384 else
385 *vs_selected = SHADER_GLSL;
386 } else if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
387 *vs_selected = SHADER_ARB;
388 } else {
389 *vs_selected = SHADER_NONE;
390 }
391
392 if (wined3d_settings.ps_mode == PS_NONE) {
393 *ps_selected = SHADER_NONE;
394 } else if (gl_info->supported[ARB_FRAGMENT_SHADER] && wined3d_settings.glslRequested) {
395 *ps_selected = SHADER_GLSL;
396 } else if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
397 *ps_selected = SHADER_ARB;
398 } else if (gl_info->supported[ATI_FRAGMENT_SHADER]) {
399 *ps_selected = SHADER_ATI;
400 } else {
401 *ps_selected = SHADER_NONE;
402 }
403 }
404
405 /** Select the number of report maximum shader constants based on the selected shader modes */
406 static void select_shader_max_constants(
407 int ps_selected_mode,
408 int vs_selected_mode,
409 WineD3D_GL_Info *gl_info) {
410
411 switch (vs_selected_mode) {
412 case SHADER_GLSL:
413 /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
414 gl_info->max_vshader_constantsF = gl_info->vs_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 1;
415 break;
416 case SHADER_ARB:
417 /* We have to subtract any other PARAMs that we might use in our shader programs.
418 * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
419 * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
420 gl_info->max_vshader_constantsF = gl_info->vs_arb_constantsF - 3;
421 break;
422 default:
423 gl_info->max_vshader_constantsF = 0;
424 break;
425 }
426
427 switch (ps_selected_mode) {
428 case SHADER_GLSL:
429 /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
430 * In theory the texbem instruction may need one more shader constant too. But lets assume
431 * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
432 * and lets not take away a uniform needlessly from all other shaders.
433 */
434 gl_info->max_pshader_constantsF = gl_info->ps_glsl_constantsF - (MAX_CONST_B / 4) - MAX_CONST_I - 2;
435 break;
436 case SHADER_ARB:
437 /* The arb shader only loads the bump mapping environment matrix into the shader if it finds
438 * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
439 */
440 gl_info->max_pshader_constantsF = gl_info->ps_arb_constantsF - 2;
441 break;
442 default:
443 gl_info->max_pshader_constantsF = 0;
444 break;
445 }
446 }
447
448 /**********************************************************
449 * IWineD3D parts follows
450 **********************************************************/
451
452 #define GLINFO_LOCATION (*gl_info)
453 static inline BOOL test_arb_vs_offset_limit(WineD3D_GL_Info *gl_info) {
454 GLuint prog;
455 BOOL ret = FALSE;
456 const char *testcode =
457 "!!ARBvp1.0\n"
458 "PARAM C[66] = { program.env[0..65] };\n"
459 "ADDRESS A0;"
460 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
461 "ARL A0.x, zero.x;\n"
462 "MOV result.position, C[A0.x + 65];\n"
463 "END\n";
464
465 while(glGetError());
466 GL_EXTCALL(glGenProgramsARB(1, &prog));
467 if(!prog) {
468 ERR("Failed to create an ARB offset limit test program\n");
469 }
470 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
471 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
472 strlen(testcode), testcode));
473 if(glGetError() != 0) {
474 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
475 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
476 ret = TRUE;
477 } else TRACE("OpenGL implementation allows offsets > 63\n");
478
479 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
480 GL_EXTCALL(glDeleteProgramsARB(1, &prog));
481 checkGLcall("ARB vp offset limit test cleanup\n");
482
483 return ret;
484 }
485
486 static DWORD ver_for_ext(GL_SupportedExt ext)
487 {
488 unsigned int i;
489 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
490 if(EXTENSION_MAP[i].extension == ext) {
491 return EXTENSION_MAP[i].version;
492 }
493 }
494 return 0;
495 }
496
497 BOOL IWineD3DImpl_FillGLCaps(WineD3D_GL_Info *gl_info) {
498 const char *GL_Extensions = NULL;
499 const char *WGL_Extensions = NULL;
500 const char *gl_string = NULL;
501 const char *gl_string_cursor = NULL;
502 GLint gl_max;
503 GLfloat gl_floatv[2];
504 int major = 1, minor = 0;
505 BOOL return_value = TRUE;
506 unsigned i;
507 HDC hdc;
508 unsigned int vidmem=0;
509
510 TRACE_(d3d_caps)("(%p)\n", gl_info);
511
512 ENTER_GL();
513
514 gl_string = (const char *) glGetString(GL_RENDERER);
515 if (NULL == gl_string)
516 gl_string = "None";
517 strcpy(gl_info->gl_renderer, gl_string);
518
519 gl_string = (const char *) glGetString(GL_VENDOR);
520 TRACE_(d3d_caps)("Filling vendor string %s\n", gl_string);
521 if (gl_string != NULL) {
522 /* Fill in the GL vendor */
523 if (strstr(gl_string, "NVIDIA")) {
524 gl_info->gl_vendor = VENDOR_NVIDIA;
525 } else if (strstr(gl_string, "ATI")) {
526 gl_info->gl_vendor = VENDOR_ATI;
527 } else if (strstr(gl_string, "Intel(R)") ||
528 strstr(gl_info->gl_renderer, "Intel(R)") ||
529 strstr(gl_string, "Intel Inc.")) {
530 gl_info->gl_vendor = VENDOR_INTEL;
531 } else if (strstr(gl_string, "Mesa")) {
532 gl_info->gl_vendor = VENDOR_MESA;
533 } else {
534 gl_info->gl_vendor = VENDOR_WINE;
535 }
536 } else {
537 gl_info->gl_vendor = VENDOR_WINE;
538 }
539
540
541 TRACE_(d3d_caps)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string), gl_info->gl_vendor);
542
543 /* Parse the GL_VERSION field into major and minor information */
544 gl_string = (const char *) glGetString(GL_VERSION);
545 if (gl_string != NULL) {
546
547 /* First, parse the generic opengl version. This is supposed not to be convoluted with
548 * driver specific information
549 */
550 gl_string_cursor = gl_string;
551 major = atoi(gl_string_cursor);
552 if(major <= 0) {
553 ERR("Invalid opengl major version: %d\n", major);
554 }
555 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
556 ++gl_string_cursor;
557 }
558 if (*gl_string_cursor++ != '.') {
559 ERR_(d3d_caps)("Invalid opengl version string: %s\n", debugstr_a(gl_string));
560 }
561 minor = atoi(gl_string_cursor);
562 TRACE_(d3d_caps)("Found OpenGL version: %d.%d\n", major, minor);
563 gl_info->gl_version = MAKEDWORD_VERSION(major, minor);
564
565 /* Now parse the driver specific string which we'll report to the app */
566 switch (gl_info->gl_vendor) {
567 case VENDOR_NVIDIA:
568 gl_string_cursor = strstr(gl_string, "NVIDIA");
569 if (!gl_string_cursor) {
570 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
571 break;
572 }
573
574 gl_string_cursor = strstr(gl_string_cursor, " ");
575 if (!gl_string_cursor) {
576 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
577 break;
578 }
579
580 while (*gl_string_cursor == ' ') {
581 ++gl_string_cursor;
582 }
583
584 if (!*gl_string_cursor) {
585 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
586 break;
587 }
588
589 major = atoi(gl_string_cursor);
590 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
591 ++gl_string_cursor;
592 }
593
594 if (*gl_string_cursor++ != '.') {
595 ERR_(d3d_caps)("Invalid nVidia version string: %s\n", debugstr_a(gl_string));
596 break;
597 }
598
599 minor = atoi(gl_string_cursor);
600 minor = major*100+minor;
601 major = 10;
602
603 break;
604
605 case VENDOR_ATI:
606 major = minor = 0;
607 gl_string_cursor = strchr(gl_string, '-');
608 if (gl_string_cursor) {
609 int error = 0;
610 gl_string_cursor++;
611
612 /* Check if version number is of the form x.y.z */
613 if (*gl_string_cursor > '9' && *gl_string_cursor < '0')
614 error = 1;
615 if (!error && *(gl_string_cursor+2) > '9' && *(gl_string_cursor+2) < '0')
616 error = 1;
617 if (!error && *(gl_string_cursor+4) > '9' && *(gl_string_cursor+4) < '0')
618 error = 1;
619 if (!error && *(gl_string_cursor+1) != '.' && *(gl_string_cursor+3) != '.')
620 error = 1;
621
622 /* Mark version number as malformed */
623 if (error)
624 gl_string_cursor = 0;
625 }
626
627 if (!gl_string_cursor)
628 WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
629 else {
630 major = *gl_string_cursor - '0';
631 minor = (*(gl_string_cursor+2) - '0') * 256 + (*(gl_string_cursor+4) - '0');
632 }
633 break;
634
635 case VENDOR_INTEL:
636 /* Apple and Mesa version strings look differently, but both provide intel drivers */
637 if(strstr(gl_string, "APPLE")) {
638 /* [0-9]+.[0-9]+ APPLE-[0-9]+.[0.9]+.[0.9]+
639 * We only need the first part, and use the APPLE as identification
640 * "1.2 APPLE-1.4.56"
641 */
642 gl_string_cursor = gl_string;
643 major = atoi(gl_string_cursor);
644 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
645 ++gl_string_cursor;
646 }
647
648 if (*gl_string_cursor++ != '.') {
649 ERR_(d3d_caps)("Invalid MacOS-Intel version string: %s\n", debugstr_a(gl_string));
650 break;
651 }
652
653 minor = atoi(gl_string_cursor);
654 break;
655 }
656
657 case VENDOR_MESA:
658 gl_string_cursor = strstr(gl_string, "Mesa");
659 gl_string_cursor = strstr(gl_string_cursor, " ");
660 while (*gl_string_cursor && ' ' == *gl_string_cursor) ++gl_string_cursor;
661 if (*gl_string_cursor) {
662 char tmp[16];
663 int cursor = 0;
664
665 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
666 tmp[cursor++] = *gl_string_cursor;
667 ++gl_string_cursor;
668 }
669 tmp[cursor] = 0;
670 major = atoi(tmp);
671
672 if (*gl_string_cursor != '.') WARN_(d3d_caps)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string));
673 ++gl_string_cursor;
674
675 cursor = 0;
676 while (*gl_string_cursor <= '9' && *gl_string_cursor >= '0') {
677 tmp[cursor++] = *gl_string_cursor;
678 ++gl_string_cursor;
679 }
680 tmp[cursor] = 0;
681 minor = atoi(tmp);
682 }
683 break;
684
685 default:
686 major = 0;
687 minor = 9;
688 }
689 gl_info->driver_version = MAKEDWORD_VERSION(major, minor);
690 TRACE_(d3d_caps)("found driver version (%s)->%i.%i->(0x%08x)\n", debugstr_a(gl_string), major, minor, gl_info->driver_version);
691 /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
692 gl_info->driver_version_hipart = MAKEDWORD_VERSION(6, 14);
693 } else {
694 FIXME("OpenGL driver did not return version information\n");
695 gl_info->driver_version = MAKEDWORD_VERSION(0, 0);
696 gl_info->driver_version_hipart = MAKEDWORD_VERSION(6, 14);
697 }
698
699 TRACE_(d3d_caps)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(gl_info->gl_renderer), gl_info->gl_card);
700
701 /*
702 * Initialize openGL extension related variables
703 * with Default values
704 */
705 memset(gl_info->supported, 0, sizeof(gl_info->supported));
706 gl_info->max_buffers = 1;
707 gl_info->max_textures = 1;
708 gl_info->max_texture_stages = 1;
709 gl_info->max_fragment_samplers = 1;
710 gl_info->max_vertex_samplers = 0;
711 gl_info->max_combined_samplers = 0;
712 gl_info->max_sampler_stages = 1;
713 gl_info->ps_arb_version = PS_VERSION_NOT_SUPPORTED;
714 gl_info->ps_arb_max_temps = 0;
715 gl_info->ps_arb_max_instructions = 0;
716 gl_info->vs_arb_version = VS_VERSION_NOT_SUPPORTED;
717 gl_info->vs_arb_max_temps = 0;
718 gl_info->vs_arb_max_instructions = 0;
719 gl_info->vs_nv_version = VS_VERSION_NOT_SUPPORTED;
720 gl_info->vs_ati_version = VS_VERSION_NOT_SUPPORTED;
721 gl_info->vs_glsl_constantsF = 0;
722 gl_info->ps_glsl_constantsF = 0;
723 gl_info->vs_arb_constantsF = 0;
724 gl_info->ps_arb_constantsF = 0;
725
726 /* Retrieve opengl defaults */
727 glGetIntegerv(GL_MAX_CLIP_PLANES, &gl_max);
728 gl_info->max_clipplanes = min(WINED3DMAXUSERCLIPPLANES, gl_max);
729 TRACE_(d3d_caps)("ClipPlanes support - num Planes=%d\n", gl_max);
730
731 glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
732 gl_info->max_lights = gl_max;
733 TRACE_(d3d_caps)("Lights support - max lights=%d\n", gl_max);
734
735 glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
736 gl_info->max_texture_size = gl_max;
737 TRACE_(d3d_caps)("Maximum texture size support - max texture size=%d\n", gl_max);
738
739 glGetFloatv(GL_POINT_SIZE_RANGE, gl_floatv);
740 gl_info->max_pointsizemin = gl_floatv[0];
741 gl_info->max_pointsize = gl_floatv[1];
742 TRACE_(d3d_caps)("Maximum point size support - max point size=%f\n", gl_floatv[1]);
743
744 /* Parse the gl supported features, in theory enabling parts of our code appropriately */
745 GL_Extensions = (const char *) glGetString(GL_EXTENSIONS);
746 TRACE_(d3d_caps)("GL_Extensions reported:\n");
747
748 if (NULL == GL_Extensions) {
749 ERR(" GL_Extensions returns NULL\n");
750 } else {
751 while (*GL_Extensions != 0x00) {
752 const char *Start;
753 char ThisExtn[256];
754 size_t len;
755
756 while (isspace(*GL_Extensions)) GL_Extensions++;
757 Start = GL_Extensions;
758 while (!isspace(*GL_Extensions) && *GL_Extensions != 0x00) {
759 GL_Extensions++;
760 }
761
762 len = GL_Extensions - Start;
763 if (len == 0 || len >= sizeof(ThisExtn))
764 continue;
765
766 memcpy(ThisExtn, Start, len);
767 ThisExtn[len] = '\0';
768 TRACE_(d3d_caps)("- %s\n", ThisExtn);
769
770 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
771 if (!strcmp(ThisExtn, EXTENSION_MAP[i].extension_string)) {
772 TRACE_(d3d_caps)(" FOUND: %s support\n", EXTENSION_MAP[i].extension_string);
773 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
774 break;
775 }
776 }
777 }
778
779 LEAVE_GL();
780
781 /* Now work out what GL support this card really has */
782 #define USE_GL_FUNC(type, pfn, ext, replace) { \
783 DWORD ver = ver_for_ext(ext); \
784 if(gl_info->supported[ext]) gl_info->pfn = (type) pwglGetProcAddress(#pfn); \
785 else if(ver && ver <= gl_info->gl_version) gl_info->pfn = (type) pwglGetProcAddress(#replace); \
786 else gl_info->pfn = NULL; \
787 }
788 GL_EXT_FUNCS_GEN;
789 #undef USE_GL_FUNC
790
791 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
792 WGL_EXT_FUNCS_GEN;
793 #undef USE_GL_FUNC
794
795 ENTER_GL();
796 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
797 * loading the functions, otherwise the code above will load the extension entry points instead of the
798 * core functions, which may not work
799 */
800 for (i = 0; i < (sizeof(EXTENSION_MAP) / sizeof(*EXTENSION_MAP)); ++i) {
801 if (gl_info->supported[EXTENSION_MAP[i].extension] == FALSE &&
802 EXTENSION_MAP[i].version <= gl_info->gl_version && EXTENSION_MAP[i].version) {
803 TRACE_(d3d_caps)(" GL CORE: %s support\n", EXTENSION_MAP[i].extension_string);
804 gl_info->supported[EXTENSION_MAP[i].extension] = TRUE;
805 }
806 }
807
808 if (gl_info->supported[APPLE_FENCE]) {
809 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
810 * The apple extension interacts with some other apple exts. Disable the NV
811 * extension if the apple one is support to prevent confusion in other parts
812 * of the code
813 */
814 gl_info->supported[NV_FENCE] = FALSE;
815 }
816 if (gl_info->supported[APPLE_FLOAT_PIXELS]) {
817 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
818 *
819 * The enums are the same:
820 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
821 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
822 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
823 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
824 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
825 */
826 if(!gl_info->supported[ARB_TEXTURE_FLOAT]) {
827 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels\n");
828 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
829 }
830 if(!gl_info->supported[ARB_HALF_FLOAT_PIXEL]) {
831 TRACE_(d3d_caps)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels\n");
832 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
833 }
834 }
835 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) {
836 TRACE_(d3d_caps)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
837 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
838 }
839 if (gl_info->supported[NV_TEXTURE_SHADER2]) {
840 /* GL_ATI_envmap_bumpmap won't play nice with texture shaders, so disable it
841 * Won't occur in any real world situation though
842 */
843 gl_info->supported[ATI_ENVMAP_BUMPMAP] = FALSE;
844 if(gl_info->supported[NV_REGISTER_COMBINERS]) {
845 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
846 * are supported. The nv extensions provide the same functionality as the
847 * ATI one, and a bit more(signed pixelformats)
848 */
849 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
850 }
851 }
852 if (gl_info->supported[ARB_DRAW_BUFFERS]) {
853 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
854 gl_info->max_buffers = gl_max;
855 TRACE_(d3d_caps)("Max draw buffers: %u\n", gl_max);
856 }
857 if (gl_info->supported[ARB_MULTITEXTURE]) {
858 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
859 gl_info->max_textures = min(MAX_TEXTURES, gl_max);
860 TRACE_(d3d_caps)("Max textures: %d\n", gl_info->max_textures);
861
862 if (gl_info->supported[NV_REGISTER_COMBINERS]) {
863 GLint tmp;
864 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &tmp);
865 gl_info->max_texture_stages = min(MAX_TEXTURES, tmp);
866 } else {
867 gl_info->max_texture_stages = min(MAX_TEXTURES, gl_max);
868 }
869 TRACE_(d3d_caps)("Max texture stages: %d\n", gl_info->max_texture_stages);
870
871 if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
872 GLint tmp;
873 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
874 gl_info->max_fragment_samplers = min(MAX_FRAGMENT_SAMPLERS, tmp);
875 } else {
876 gl_info->max_fragment_samplers = max(gl_info->max_fragment_samplers, gl_max);
877 }
878 TRACE_(d3d_caps)("Max fragment samplers: %d\n", gl_info->max_fragment_samplers);
879
880 if (gl_info->supported[ARB_VERTEX_SHADER]) {
881 GLint tmp;
882 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &tmp);
883 gl_info->max_vertex_samplers = tmp;
884 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &tmp);
885 gl_info->max_combined_samplers = tmp;
886
887 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
888 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
889 * an issue because then the sampler setup only depends on the two shaders. If a pixel
890 * shader is used with fixed function vertex processing we're fine too because fixed function
891 * vertex processing doesn't use any samplers. If fixed function fragment processing is
892 * used we have to make sure that all vertex sampler setups are valid together with all
893 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
894 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
895 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
896 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
897 * a fixed function pipeline anymore.
898 *
899 * So this is just a check to check that our assumption holds true. If not, write a warning
900 * and reduce the number of vertex samplers or probably disable vertex texture fetch.
901 */
902 if(gl_info->max_vertex_samplers &&
903 MAX_TEXTURES + gl_info->max_vertex_samplers > gl_info->max_combined_samplers) {
904 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers\n",
905 gl_info->max_vertex_samplers, gl_info->max_combined_samplers);
906 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers\n");
907 if( gl_info->max_combined_samplers > MAX_TEXTURES )
908 gl_info->max_vertex_samplers =
909 gl_info->max_combined_samplers - MAX_TEXTURES;
910 else
911 gl_info->max_vertex_samplers = 0;
912 }
913 } else {
914 gl_info->max_combined_samplers = gl_info->max_fragment_samplers;
915 }
916 TRACE_(d3d_caps)("Max vertex samplers: %u\n", gl_info->max_vertex_samplers);
917 TRACE_(d3d_caps)("Max combined samplers: %u\n", gl_info->max_combined_samplers);
918 }
919 if (gl_info->supported[ARB_VERTEX_BLEND]) {
920 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max);
921 gl_info->max_blends = gl_max;
922 TRACE_(d3d_caps)("Max blends: %u\n", gl_info->max_blends);
923 }
924 if (gl_info->supported[EXT_TEXTURE3D]) {
925 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
926 gl_info->max_texture3d_size = gl_max;
927 TRACE_(d3d_caps)("Max texture3D size: %d\n", gl_info->max_texture3d_size);
928 }
929 if (gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC]) {
930 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &gl_max);
931 gl_info->max_anisotropy = gl_max;
932 TRACE_(d3d_caps)("Max anisotropy: %d\n", gl_info->max_anisotropy);
933 }
934 if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) {
935 gl_info->ps_arb_version = PS_VERSION_11;
936 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
937 gl_info->ps_arb_constantsF = gl_max;
938 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM float constants: %d\n", gl_info->ps_arb_constantsF);
939 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
940 gl_info->ps_arb_max_temps = gl_max;
941 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d\n", gl_info->ps_arb_max_temps);
942 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
943 gl_info->ps_arb_max_instructions = gl_max;
944 TRACE_(d3d_caps)("Max ARB_FRAGMENT_PROGRAM native instructions: %d\n", gl_info->ps_arb_max_instructions);
945 }
946 if (gl_info->supported[ARB_VERTEX_PROGRAM]) {
947 gl_info->vs_arb_version = VS_VERSION_11;
948 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
949 gl_info->vs_arb_constantsF = gl_max;
950 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM float constants: %d\n", gl_info->vs_arb_constantsF);
951 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
952 gl_info->vs_arb_max_temps = gl_max;
953 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native temporaries: %d\n", gl_info->vs_arb_max_temps);
954 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
955 gl_info->vs_arb_max_instructions = gl_max;
956 TRACE_(d3d_caps)("Max ARB_VERTEX_PROGRAM native instructions: %d\n", gl_info->vs_arb_max_instructions);
957
958 gl_info->arb_vs_offset_limit = test_arb_vs_offset_limit(gl_info);
959 }
960 if (gl_info->supported[ARB_VERTEX_SHADER]) {
961 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
962 gl_info->vs_glsl_constantsF = gl_max / 4;
963 TRACE_(d3d_caps)("Max ARB_VERTEX_SHADER float constants: %u\n", gl_info->vs_glsl_constantsF);
964 }
965 if (gl_info->supported[ARB_FRAGMENT_SHADER]) {
966 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
967 gl_info->ps_glsl_constantsF = gl_max / 4;
968 TRACE_(d3d_caps)("Max ARB_FRAGMENT_SHADER float constants: %u\n", gl_info->ps_glsl_constantsF);
969 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
970 gl_info->max_glsl_varyings = gl_max;
971 TRACE_(d3d_caps)("Max GLSL varyings: %u (%u 4 component varyings)\n", gl_max, gl_max / 4);
972 }
973 if (gl_info->supported[EXT_VERTEX_SHADER]) {
974 gl_info->vs_ati_version = VS_VERSION_11;
975 }
976 if (gl_info->supported[NV_VERTEX_PROGRAM3]) {
977 gl_info->vs_nv_version = VS_VERSION_30;
978 } else if (gl_info->supported[NV_VERTEX_PROGRAM2]) {
979 gl_info->vs_nv_version = VS_VERSION_20;
980 } else if (gl_info->supported[NV_VERTEX_PROGRAM1_1]) {
981 gl_info->vs_nv_version = VS_VERSION_11;
982 } else if (gl_info->supported[NV_VERTEX_PROGRAM]) {
983 gl_info->vs_nv_version = VS_VERSION_10;
984 }
985 if (gl_info->supported[NV_FRAGMENT_PROGRAM2]) {
986 gl_info->ps_nv_version = PS_VERSION_30;
987 } else if (gl_info->supported[NV_FRAGMENT_PROGRAM]) {
988 gl_info->ps_nv_version = PS_VERSION_20;
989 }
990 if (gl_info->supported[NV_LIGHT_MAX_EXPONENT]) {
991 glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->max_shininess);
992 } else {
993 gl_info->max_shininess = 128.0;
994 }
995 if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) {
996 /* If we have full NP2 texture support, disable GL_ARB_texture_rectangle because we will never use it.
997 * This saves a few redundant glDisable calls
998 */
999 gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
1000 }
1001 if(gl_info->supported[ATI_FRAGMENT_SHADER]) {
1002 /* Disable NV_register_combiners and fragment shader if this is supported.
1003 * generally the NV extensions are preferred over the ATI ones, and this
1004 * extension is disabled if register_combiners and texture_shader2 are both
1005 * supported. So we reach this place only if we have incomplete NV dxlevel 8
1006 * fragment processing support
1007 */
1008 gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
1009 gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
1010 gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
1011 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
1012 gl_info->supported[NV_TEXTURE_SHADER3] = FALSE;
1013 }
1014
1015 }
1016 checkGLcall("extension detection\n");
1017
1018 /* In some cases the number of texture stages can be larger than the number
1019 * of samplers. The GF4 for example can use only 2 samplers (no fragment
1020 * shaders), but 8 texture stages (register combiners). */
1021 gl_info->max_sampler_stages = max(gl_info->max_fragment_samplers, gl_info->max_texture_stages);
1022
1023 /* We can only use ORM_FBO when the hardware supports it. */
1024 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO && !gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) {
1025 WARN_(d3d_caps)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
1026 wined3d_settings.offscreen_rendering_mode = ORM_PBUFFER;
1027 }
1028
1029 /* MRTs are currently only supported when FBOs are used. */
1030 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) {
1031 gl_info->max_buffers = 1;
1032 }
1033
1034 /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
1035 * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
1036 * in case of the latest videocards in the number of pixel/vertex pipelines.
1037 *
1038 * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
1039 * rendering. Various games use this information to get a rough estimation of the features of the card
1040 * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
1041 * games might even use it to work around bugs which happen on certain videocards/driver combinations.
1042 * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
1043 * not the PCI id.
1044 *
1045 * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
1046 * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
1047 * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
1048 * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
1049 * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
1050 * is used for rendering which is not always the case). This would work but it is not very portable. Second
1051 * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
1052 * is limited.
1053 *
1054 * As said most games only use the PCI id to get an indication of the capabilities of the card.
1055 * It doesn't really matter if the given id is the correct one if we return the id of a card with
1056 * similar 3d features.
1057 *
1058 * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
1059 * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
1060 * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
1061 * won't pass we return a default card. This way is better than maintaining a full card database as even
1062 * without a full database we can return a card with similar features. Second the size of the database
1063 * can be made quite small because when you know what type of 3d functionality a card has, you know to which
1064 * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
1065 * to distinguishes between different models from that family.
1066 *
1067 * The code also selects a default amount of video memory which we will use for an estimation of the amount
1068 * of free texture memory. In case of real D3D the amount of texture memory includes video memory and system
1069 * memory (to be specific AGP memory or in case of PCIE TurboCache/HyperMemory). We don't know how much
1070 * system memory can be addressed by the system but we can make a reasonable estimation about the amount of
1071 * video memory. If the value is slightly wrong it doesn't matter as we didn't include AGP-like memory which
1072 * makes the amount of addressable memory higher and second OpenGL isn't that critical it moves to system
1073 * memory behind our backs if really needed.
1074 * Note that the amount of video memory can be overruled using a registry setting.
1075 */
1076 switch (gl_info->gl_vendor) {
1077 case VENDOR_NVIDIA:
1078 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1079 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1080 */
1081 if(WINE_D3D9_CAPABLE(gl_info) && (gl_info->vs_nv_version == VS_VERSION_30)) {
1082 /* Geforce9 - highend */
1083 if(strstr(gl_info->gl_renderer, "9800")) {
1084 gl_info->gl_card = CARD_NVIDIA_GEFORCE_9800GT;
1085 vidmem = 512;
1086 }
1087 /* Geforce9 - midend */
1088 else if(strstr(gl_info->gl_renderer, "9600")) {
1089 gl_info->gl_card = CARD_NVIDIA_GEFORCE_9600GT;
1090 vidmem = 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1091 }
1092 /* Geforce8 - highend */
1093 else if (strstr(gl_info->gl_renderer, "8800")) {
1094 gl_info->gl_card = CARD_NVIDIA_GEFORCE_8800GTS;
1095 vidmem = 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1096 }
1097 /* Geforce8 - midend mobile */
1098 else if(strstr(gl_info->gl_renderer, "8600 M")) {
1099 gl_info->gl_card = CARD_NVIDIA_GEFORCE_8600MGT;
1100 vidmem = 512;
1101 }
1102 /* Geforce8 - midend */
1103 else if(strstr(gl_info->gl_renderer, "8600") ||
1104 strstr(gl_info->gl_renderer, "8700"))
1105 {
1106 gl_info->gl_card = CARD_NVIDIA_GEFORCE_8600GT;
1107 vidmem = 256;
1108 }
1109 /* Geforce8 - lowend */
1110 else if(strstr(gl_info->gl_renderer, "8300") ||
1111 strstr(gl_info->gl_renderer, "8400") ||
1112 strstr(gl_info->gl_renderer, "8500"))
1113 {
1114 gl_info->gl_card = CARD_NVIDIA_GEFORCE_8300GS;
1115 vidmem = 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1116 }
1117 /* Geforce7 - highend */
1118 else if(strstr(gl_info->gl_renderer, "7800") ||
1119 strstr(gl_info->gl_renderer, "7900") ||
1120 strstr(gl_info->gl_renderer, "7950") ||
1121 strstr(gl_info->gl_renderer, "Quadro FX 4") ||
1122 strstr(gl_info->gl_renderer, "Quadro FX 5"))
1123 {
1124 gl_info->gl_card = CARD_NVIDIA_GEFORCE_7800GT;
1125 vidmem = 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1126 }
1127 /* Geforce7 midend */
1128 else if(strstr(gl_info->gl_renderer, "7600") ||
1129 strstr(gl_info->gl_renderer, "7700")) {
1130 gl_info->gl_card = CARD_NVIDIA_GEFORCE_7600;
1131 vidmem = 256; /* The 7600 uses 256-512MB */
1132 /* Geforce7 lower medium */
1133 } else if(strstr(gl_info->gl_renderer, "7400")) {
1134 gl_info->gl_card = CARD_NVIDIA_GEFORCE_7400;
1135 vidmem = 256; /* The 7400 uses 256-512MB */
1136 }
1137 /* Geforce7 lowend */
1138 else if(strstr(gl_info->gl_renderer, "7300")) {
1139 gl_info->gl_card = CARD_NVIDIA_GEFORCE_7300;
1140 vidmem = 256; /* Mac Pros with this card have 256 MB */
1141 }
1142 /* Geforce6 highend */
1143 else if(strstr(gl_info->gl_renderer, "6800"))
1144 {
1145 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6800;
1146 vidmem = 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1147 }
1148 /* Geforce6 - midend */
1149 else if(strstr(gl_info->gl_renderer, "6600") ||
1150 strstr(gl_info->gl_renderer, "6610") ||
1151 strstr(gl_info->gl_renderer, "6700"))
1152 {
1153 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6600GT;
1154 vidmem = 128; /* A 6600GT has 128-256MB */
1155 }
1156 /* Geforce6/7 lowend */
1157 else {
1158 gl_info->gl_card = CARD_NVIDIA_GEFORCE_6200; /* Geforce 6100/6150/6200/7300/7400/7500 */
1159 vidmem = 64; /* */
1160 }
1161 } else if(WINE_D3D9_CAPABLE(gl_info)) {
1162 /* GeforceFX - highend */
1163 if (strstr(gl_info->gl_renderer, "5800") ||
1164 strstr(gl_info->gl_renderer, "5900") ||
1165 strstr(gl_info->gl_renderer, "5950") ||
1166 strstr(gl_info->gl_renderer, "Quadro FX"))
1167 {
1168 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5800;
1169 vidmem = 256; /* 5800-5900 cards use 256MB */
1170 }
1171 /* GeforceFX - midend */
1172 else if(strstr(gl_info->gl_renderer, "5600") ||
1173 strstr(gl_info->gl_renderer, "5650") ||
1174 strstr(gl_info->gl_renderer, "5700") ||
1175 strstr(gl_info->gl_renderer, "5750"))
1176 {
1177 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
1178 vidmem = 128; /* A 5600 uses 128-256MB */
1179 }
1180 /* GeforceFX - lowend */
1181 else {
1182 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5200; /* GeforceFX 5100/5200/5250/5300/5500 */
1183 vidmem = 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1184 }
1185 } else if(WINE_D3D8_CAPABLE(gl_info)) {
1186 if (strstr(gl_info->gl_renderer, "GeForce4 Ti") || strstr(gl_info->gl_renderer, "Quadro4")) {
1187 gl_info->gl_card = CARD_NVIDIA_GEFORCE4_TI4200; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1188 vidmem = 64; /* Geforce4 Ti cards have 64-128MB */
1189 }
1190 else {
1191 gl_info->gl_card = CARD_NVIDIA_GEFORCE3; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1192 vidmem = 64; /* Geforce3 cards have 64-128MB */
1193 }
1194 } else if(WINE_D3D7_CAPABLE(gl_info)) {
1195 if (strstr(gl_info->gl_renderer, "GeForce4 MX")) {
1196 gl_info->gl_card = CARD_NVIDIA_GEFORCE4_MX; /* MX420/MX440/MX460/MX4000 */
1197 vidmem = 64; /* Most Geforce4MX GPUs have at least 64MB of memory, some early models had 32MB but most have 64MB or even 128MB */
1198 }
1199 else if(strstr(gl_info->gl_renderer, "GeForce2 MX") || strstr(gl_info->gl_renderer, "Quadro2 MXR")) {
1200 gl_info->gl_card = CARD_NVIDIA_GEFORCE2_MX; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1201 vidmem = 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1202 }
1203 else if(strstr(gl_info->gl_renderer, "GeForce2") || strstr(gl_info->gl_renderer, "Quadro2")) {
1204 gl_info->gl_card = CARD_NVIDIA_GEFORCE2; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1205 vidmem = 32; /* Geforce2 GPUs have 32-64MB of video memory */
1206 }
1207 else {
1208 gl_info->gl_card = CARD_NVIDIA_GEFORCE; /* Geforce 256/DDR, Quadro */
1209 vidmem = 32; /* Most Geforce1 cards have 32MB, there are also some rare 16 and 64MB (Dell) models */
1210 }
1211 } else {
1212 if (strstr(gl_info->gl_renderer, "TNT2")) {
1213 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT2; /* Riva TNT2 standard/M64/Pro/Ultra */
1214 vidmem = 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1215 }
1216 else {
1217 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT; /* Riva TNT, Vanta */
1218 vidmem = 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1219 }
1220 }
1221 break;
1222 case VENDOR_ATI:
1223 if(WINE_D3D9_CAPABLE(gl_info)) {
1224 /* Radeon R6xx HD2900/HD3800 - highend */
1225 if (strstr(gl_info->gl_renderer, "HD 2900") ||
1226 strstr(gl_info->gl_renderer, "HD 3870") ||
1227 strstr(gl_info->gl_renderer, "HD 3850"))
1228 {
1229 gl_info->gl_card = CARD_ATI_RADEON_HD2900;
1230 vidmem = 512; /* HD2900/HD3800 uses 256-1024MB */
1231 }
1232 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1233 else if (strstr(gl_info->gl_renderer, "HD 2600") ||
1234 strstr(gl_info->gl_renderer, "HD 3830") ||
1235 strstr(gl_info->gl_renderer, "HD 3690") ||
1236 strstr(gl_info->gl_renderer, "HD 3650"))
1237 {
1238 gl_info->gl_card = CARD_ATI_RADEON_HD2600;
1239 vidmem = 256; /* HD2600/HD3600 uses 256-512MB */
1240 }
1241 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1242 else if (strstr(gl_info->gl_renderer, "HD 2300") ||
1243 strstr(gl_info->gl_renderer, "HD 2400") ||
1244 strstr(gl_info->gl_renderer, "HD 3470") ||
1245 strstr(gl_info->gl_renderer, "HD 3450") ||
1246 strstr(gl_info->gl_renderer, "HD 3430"))
1247 {
1248 gl_info->gl_card = CARD_ATI_RADEON_HD2300;
1249 vidmem = 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1250 }
1251 /* Radeon R6xx/R7xx integrated */
1252 else if (strstr(gl_info->gl_renderer, "HD 3100") ||
1253 strstr(gl_info->gl_renderer, "HD 3200") ||
1254 strstr(gl_info->gl_renderer, "HD 3300"))
1255 {
1256 gl_info->gl_card = CARD_ATI_RADEON_HD3200;
1257 vidmem = 128; /* 128MB */
1258 }
1259 /* Radeon R5xx */
1260 else if (strstr(gl_info->gl_renderer, "X1600") ||
1261 strstr(gl_info->gl_renderer, "X1650") ||
1262 strstr(gl_info->gl_renderer, "X1800") ||
1263 strstr(gl_info->gl_renderer, "X1900") ||
1264 strstr(gl_info->gl_renderer, "X1950"))
1265 {
1266 gl_info->gl_card = CARD_ATI_RADEON_X1600;
1267 vidmem = 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1268 }
1269 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1270 else if(strstr(gl_info->gl_renderer, "X700") ||
1271 strstr(gl_info->gl_renderer, "X800") ||
1272 strstr(gl_info->gl_renderer, "X850") ||
1273 strstr(gl_info->gl_renderer, "X1300") ||
1274 strstr(gl_info->gl_renderer, "X1400") ||
1275 strstr(gl_info->gl_renderer, "X1450") ||
1276 strstr(gl_info->gl_renderer, "X1550"))
1277 {
1278 gl_info->gl_card = CARD_ATI_RADEON_X700;
1279 vidmem = 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1280 }
1281 /* Radeon R3xx */
1282 else {
1283 gl_info->gl_card = CARD_ATI_RADEON_9500; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1284 vidmem = 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1285 }
1286 } else if(WINE_D3D8_CAPABLE(gl_info)) {
1287 gl_info->gl_card = CARD_ATI_RADEON_8500; /* Radeon 8500/9000/9100/9200/9300 */
1288 vidmem = 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1289 } else if(WINE_D3D7_CAPABLE(gl_info)) {
1290 gl_info->gl_card = CARD_ATI_RADEON_7200; /* Radeon 7000/7100/7200/7500 */
1291 vidmem = 32; /* There are models with up to 64MB */
1292 } else {
1293 gl_info->gl_card = CARD_ATI_RAGE_128PRO;
1294 vidmem = 16; /* There are 16-32MB models */
1295 }
1296 break;
1297 case VENDOR_INTEL:
1298 if (strstr(gl_info->gl_renderer, "GMA 950")) {
1299 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1300 gl_info->gl_card = CARD_INTEL_I945GM;
1301 vidmem = 64;
1302 } else if (strstr(gl_info->gl_renderer, "915GM")) {
1303 gl_info->gl_card = CARD_INTEL_I915GM;
1304 } else if (strstr(gl_info->gl_renderer, "915G")) {
1305 gl_info->gl_card = CARD_INTEL_I915G;
1306 } else if (strstr(gl_info->gl_renderer, "865G")) {
1307 gl_info->gl_card = CARD_INTEL_I865G;
1308 } else if (strstr(gl_info->gl_renderer, "855G")) {
1309 gl_info->gl_card = CARD_INTEL_I855G;
1310 } else if (strstr(gl_info->gl_renderer, "830G")) {
1311 gl_info->gl_card = CARD_INTEL_I830G;
1312 } else {
1313 gl_info->gl_card = CARD_INTEL_I915G;
1314 }
1315 break;
1316 case VENDOR_MESA:
1317 case VENDOR_WINE:
1318 default:
1319 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1320 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1321 * them a good generic choice.
1322 */
1323 gl_info->gl_vendor = VENDOR_NVIDIA;
1324 if(WINE_D3D9_CAPABLE(gl_info))
1325 gl_info->gl_card = CARD_NVIDIA_GEFORCEFX_5600;
1326 else if(WINE_D3D8_CAPABLE(gl_info))
1327 gl_info->gl_card = CARD_NVIDIA_GEFORCE3;
1328 else if(WINE_D3D7_CAPABLE(gl_info))
1329 gl_info->gl_card = CARD_NVIDIA_GEFORCE;
1330 else if(WINE_D3D6_CAPABLE(gl_info))
1331 gl_info->gl_card = CARD_NVIDIA_RIVA_TNT;
1332 else
1333 gl_info->gl_card = CARD_NVIDIA_RIVA_128;
1334 }
1335 TRACE_(d3d_caps)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info->gl_vendor, gl_info->gl_card);
1336
1337 /* If we have an estimate use it, else default to 64MB; */
1338 if(vidmem)
1339 gl_info->vidmem = vidmem*1024*1024; /* convert from MBs to bytes */
1340 else
1341 gl_info->vidmem = WINE_DEFAULT_VIDMEM;
1342
1343 /* Load all the lookup tables
1344 TODO: It may be a good idea to make minLookup and maxLookup const and populate them in wined3d_private.h where they are declared */
1345 minLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_WRAP;
1346 maxLookup[WINELOOKUP_WARPPARAM] = WINED3DTADDRESS_MIRRORONCE;
1347
1348 for (i = 0; i < MAX_LOOKUPS; i++) {
1349 stateLookup[i] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup[i]) * (1 + maxLookup[i] - minLookup[i]) );
1350 }
1351
1352 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_WRAP - minLookup[WINELOOKUP_WARPPARAM]] = GL_REPEAT;
1353 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_CLAMP - minLookup[WINELOOKUP_WARPPARAM]] = GL_CLAMP_TO_EDGE;
1354 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1355 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1356 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_BORDER - minLookup[WINELOOKUP_WARPPARAM]] =
1357 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
1358 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRROR - minLookup[WINELOOKUP_WARPPARAM]] =
1359 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
1360 stateLookup[WINELOOKUP_WARPPARAM][WINED3DTADDRESS_MIRRORONCE - minLookup[WINELOOKUP_WARPPARAM]] =
1361 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] ? GL_MIRROR_CLAMP_TO_EDGE_ATI : GL_REPEAT;
1362
1363 magLookup[WINED3DTEXF_NONE - WINED3DTEXF_NONE] = GL_NEAREST;
1364 magLookup[WINED3DTEXF_POINT - WINED3DTEXF_NONE] = GL_NEAREST;
1365 magLookup[WINED3DTEXF_LINEAR - WINED3DTEXF_NONE] = GL_LINEAR;
1366 magLookup[WINED3DTEXF_ANISOTROPIC - WINED3DTEXF_NONE] =
1367 gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR : GL_NEAREST;
1368
1369
1370 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_NONE] = GL_LINEAR;
1371 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_POINT] = GL_LINEAR;
1372 minMipLookup[WINED3DTEXF_NONE][WINED3DTEXF_LINEAR] = GL_LINEAR;
1373 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_NONE] = GL_NEAREST;
1374 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_POINT] = GL_NEAREST_MIPMAP_NEAREST;
1375 minMipLookup[WINED3DTEXF_POINT][WINED3DTEXF_LINEAR] = GL_NEAREST_MIPMAP_LINEAR;
1376 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_NONE] = GL_LINEAR;
1377 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_POINT] = GL_LINEAR_MIPMAP_NEAREST;
1378 minMipLookup[WINED3DTEXF_LINEAR][WINED3DTEXF_LINEAR] = GL_LINEAR_MIPMAP_LINEAR;
1379 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_NONE] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ?
1380 GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1381 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_POINT] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR;
1382 minMipLookup[WINED3DTEXF_ANISOTROPIC][WINED3DTEXF_LINEAR] = gl_info->supported[EXT_TEXTURE_FILTER_ANISOTROPIC] ? GL_LINEAR_MIPMAP_LINEAR : GL_LINEAR;
1383
1384 /* TODO: config lookups */
1385
1386 /* Make sure there's an active HDC else the WGL extensions will fail */
1387 hdc = pwglGetCurrentDC();
1388 if (hdc) {
1389 WGL_Extensions = GL_EXTCALL(wglGetExtensionsStringARB(hdc));
1390 TRACE_(d3d_caps)("WGL_Extensions reported:\n");
1391
1392 if (NULL == WGL_Extensions) {
1393 ERR(" WGL_Extensions returns NULL\n");
1394 } else {
1395 while (*WGL_Extensions != 0x00) {
1396 const char *Start;
1397 char ThisExtn[256];
1398 size_t len;
1399
1400 while (isspace(*WGL_Extensions)) WGL_Extensions++;
1401 Start = WGL_Extensions;
1402 while (!isspace(*WGL_Extensions) && *WGL_Extensions != 0x00) {
1403 WGL_Extensions++;
1404 }
1405
1406 len = WGL_Extensions - Start;
1407 if (len == 0 || len >= sizeof(ThisExtn))
1408 continue;
1409
1410 memcpy(ThisExtn, Start, len);
1411 ThisExtn[len] = '\0';
1412 TRACE_(d3d_caps)("- %s\n", ThisExtn);
1413
1414 if (!strcmp(ThisExtn, "WGL_ARB_pbuffer")) {
1415 gl_info->supported[WGL_ARB_PBUFFER] = TRUE;
1416 TRACE_(d3d_caps)("FOUND: WGL_ARB_pbuffer support\n");
1417 }
1418 if (!strcmp(ThisExtn, "WGL_WINE_pixel_format_passthrough")) {
1419 gl_info->supported[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH] = TRUE;
1420 TRACE_(d3d_caps)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
1421 }
1422 }
1423 }
1424 }
1425 LEAVE_GL();
1426
1427 return return_value;
1428 }
1429 #undef GLINFO_LOCATION
1430
1431 /**********************************************************
1432 * IWineD3D implementation follows
1433 **********************************************************/
1434
1435 static UINT WINAPI IWineD3DImpl_GetAdapterCount (IWineD3D *iface) {
1436 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1437
1438 TRACE_(d3d_caps)("(%p): Reporting %d adapters\n", This, numAdapters);
1439 return numAdapters;
1440 }
1441
1442 static HRESULT WINAPI IWineD3DImpl_RegisterSoftwareDevice(IWineD3D *iface, void* pInitializeFunction) {
1443 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1444 FIXME("(%p)->(%p): stub\n", This, pInitializeFunction);
1445 return WINED3D_OK;
1446 }
1447
1448 static HMONITOR WINAPI IWineD3DImpl_GetAdapterMonitor(IWineD3D *iface, UINT Adapter) {
1449 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1450
1451 TRACE_(d3d_caps)("(%p)->(%d)\n", This, Adapter);
1452
1453 if (Adapter >= IWineD3DImpl_GetAdapterCount(iface)) {
1454 return NULL;
1455 }
1456
1457 return MonitorFromPoint(Adapters[Adapter].monitorPoint, MONITOR_DEFAULTTOPRIMARY);
1458 }
1459
1460 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1461 of the same bpp but different resolutions */
1462
1463 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1464 static UINT WINAPI IWineD3DImpl_GetAdapterModeCount(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format) {
1465 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1466 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Format: %s)\n", This, Adapter, debug_d3dformat(Format));
1467
1468 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1469 return 0;
1470 }
1471
1472 /* TODO: Store modes per adapter and read it from the adapter structure */
1473 if (Adapter == 0) { /* Display */
1474 int i = 0;
1475 int j = 0;
1476
1477 if (!DEBUG_SINGLE_MODE) {
1478 DEVMODEW DevModeW;
1479
1480 ZeroMemory(&DevModeW, sizeof(DevModeW));
1481 DevModeW.dmSize = sizeof(DevModeW);
1482 while (EnumDisplaySettingsExW(NULL, j, &DevModeW, 0)) {
1483 j++;
1484 switch (Format)
1485 {
1486 case WINED3DFMT_UNKNOWN:
1487 /* This is for D3D8, do not enumerate P8 here */
1488 if (DevModeW.dmBitsPerPel == 32 ||
1489 DevModeW.dmBitsPerPel == 16) i++;
1490 break;
1491 case WINED3DFMT_X8R8G8B8:
1492 if (DevModeW.dmBitsPerPel == 32) i++;
1493 break;
1494 case WINED3DFMT_R5G6B5:
1495 if (DevModeW.dmBitsPerPel == 16) i++;
1496 break;
1497 case WINED3DFMT_P8:
1498 if (DevModeW.dmBitsPerPel == 8) i++;
1499 break;
1500 default:
1501 /* Skip other modes as they do not match the requested format */
1502 break;
1503 }
1504 }
1505 } else {
1506 i = 1;
1507 j = 1;
1508 }
1509
1510 TRACE_(d3d_caps)("(%p}->(Adapter: %d) => %d (out of %d)\n", This, Adapter, i, j);
1511 return i;
1512 } else {
1513 FIXME_(d3d_caps)("Adapter not primary display\n");
1514 }
1515 return 0;
1516 }
1517
1518 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1519 static HRESULT WINAPI IWineD3DImpl_EnumAdapterModes(IWineD3D *iface, UINT Adapter, WINED3DFORMAT Format, UINT Mode, WINED3DDISPLAYMODE* pMode) {
1520 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1521 TRACE_(d3d_caps)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This, Adapter, Mode, pMode, debug_d3dformat(Format));
1522
1523 /* Validate the parameters as much as possible */
1524 if (NULL == pMode ||
1525 Adapter >= IWineD3DImpl_GetAdapterCount(iface) ||
1526 Mode >= IWineD3DImpl_GetAdapterModeCount(iface, Adapter, Format)) {
1527 return WINED3DERR_INVALIDCALL;
1528 }
1529
1530 /* TODO: Store modes per adapter and read it from the adapter structure */
1531 if (Adapter == 0 && !DEBUG_SINGLE_MODE) { /* Display */
1532 DEVMODEW DevModeW;
1533 int ModeIdx = 0;
1534 int i = 0;
1535 int j = 0;
1536
1537 ZeroMemory(&DevModeW, sizeof(DevModeW));
1538 DevModeW.dmSize = sizeof(DevModeW);
1539
1540 /* If we are filtering to a specific format (D3D9), then need to skip
1541 all unrelated modes, but if mode is irrelevant (D3D8), then we can
1542 just count through the ones with valid bit depths */
1543 while ((i<=Mode) && EnumDisplaySettingsExW(NULL, j++, &DevModeW, 0)) {
1544 switch (Format)
1545 {
1546 case WINED3DFMT_UNKNOWN:
1547 /* This is D3D8. Do not enumerate P8 here */
1548 if (DevModeW.dmBitsPerPel == 32 ||
1549 DevModeW.dmBitsPerPel == 16) i++;
1550 break;
1551 case WINED3DFMT_X8R8G8B8:
1552 if (DevModeW.dmBitsPerPel == 32) i++;
1553 break;
1554 case WINED3DFMT_R5G6B5:
1555 if (DevModeW.dmBitsPerPel == 16) i++;
1556 break;
1557 case WINED3DFMT_P8:
1558 if (DevModeW.dmBitsPerPel == 8) i++;
1559 break;
1560 default:
1561 /* Modes that don't match what we support can get an early-out */
1562 TRACE_(d3d_caps)("Searching for %s, returning D3DERR_INVALIDCALL\n", debug_d3dformat(Format));
1563 return WINED3DERR_INVALIDCALL;
1564 }
1565 }
1566
1567 if (i == 0) {
1568 TRACE_(d3d_caps)("No modes found for format (%x - %s)\n", Format, debug_d3dformat(Format));
1569 return WINED3DERR_INVALIDCALL;
1570 }
1571 ModeIdx = j - 1;
1572
1573 /* Now get the display mode via the calculated index */
1574 if (EnumDisplaySettingsExW(NULL, ModeIdx, &DevModeW, 0)) {
1575 pMode->Width = DevModeW.dmPelsWidth;
1576 pMode->Height = DevModeW.dmPelsHeight;
1577 pMode->RefreshRate = WINED3DADAPTER_DEFAULT;
1578 if (DevModeW.dmFields & DM_DISPLAYFREQUENCY)
1579 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1580
1581 if (Format == WINED3DFMT_UNKNOWN) {
1582 pMode->Format = pixelformat_for_depth(DevModeW.dmBitsPerPel);
1583 } else {
1584 pMode->Format = Format;
1585 }
1586 } else {
1587 TRACE_(d3d_caps)("Requested mode out of range %d\n", Mode);
1588 return WINED3DERR_INVALIDCALL;
1589 }
1590
1591 TRACE_(d3d_caps)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode->Width, pMode->Height,
1592 pMode->RefreshRate, pMode->Format, debug_d3dformat(pMode->Format),
1593 DevModeW.dmBitsPerPel);
1594
1595 } else if (DEBUG_SINGLE_MODE) {
1596 /* Return one setting of the format requested */
1597 if (Mode > 0) return WINED3DERR_INVALIDCALL;
1598 pMode->Width = 800;
1599 pMode->Height = 600;
1600 pMode->RefreshRate = 60;
1601 pMode->Format = (Format == WINED3DFMT_UNKNOWN) ? WINED3DFMT_X8R8G8B8 : Format;
1602 } else {
1603 FIXME_(d3d_caps)("Adapter not primary display\n");
1604 }
1605
1606 return WINED3D_OK;
1607 }
1608
1609 static HRESULT WINAPI IWineD3DImpl_GetAdapterDisplayMode(IWineD3D *iface, UINT Adapter, WINED3DDISPLAYMODE* pMode) {
1610 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1611 TRACE_(d3d_caps)("(%p}->(Adapter: %d, pMode: %p)\n", This, Adapter, pMode);
1612
1613 if (NULL == pMode ||
1614 Adapter >= IWineD3D_GetAdapterCount(iface)) {
1615 return WINED3DERR_INVALIDCALL;
1616 }
1617
1618 if (Adapter == 0) { /* Display */
1619 int bpp = 0;
1620 DEVMODEW DevModeW;
1621
1622 ZeroMemory(&DevModeW, sizeof(DevModeW));
1623 DevModeW.dmSize = sizeof(DevModeW);
1624
1625 EnumDisplaySettingsExW(NULL, ENUM_CURRENT_SETTINGS, &DevModeW, 0);
1626 pMode->Width = DevModeW.dmPelsWidth;
1627 pMode->Height = DevModeW.dmPelsHeight;
1628 bpp = DevModeW.dmBitsPerPel;
1629 pMode->RefreshRate = WINED3DADAPTER_DEFAULT;
1630 if (DevModeW.dmFields&DM_DISPLAYFREQUENCY)
1631 {
1632 pMode->RefreshRate = DevModeW.dmDisplayFrequency;
1633 }
1634
1635 pMode->Format = pixelformat_for_depth(bpp);
1636 } else {
1637 FIXME_(d3d_caps)("Adapter not primary display\n");
1638 }
1639
1640 TRACE_(d3d_caps)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode->Width,
1641 pMode->Height, pMode->RefreshRate, debug_d3dformat(pMode->Format));
1642 return WINED3D_OK;
1643 }
1644
1645 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1646 and fields being inserted in the middle, a new structure is used in place */
1647 static HRESULT WINAPI IWineD3DImpl_GetAdapterIdentifier(IWineD3D *iface, UINT Adapter, DWORD Flags,
1648 WINED3DADAPTER_IDENTIFIER* pIdentifier) {
1649 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1650
1651 TRACE_(d3d_caps)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This, Adapter, Flags, pIdentifier);
1652
1653 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1654 return WINED3DERR_INVALIDCALL;
1655 }
1656
1657 /* Return the information requested */
1658 TRACE_(d3d_caps)("device/Vendor Name and Version detection using FillGLCaps\n");
1659 strcpy(pIdentifier->Driver, Adapters[Adapter].driver);
1660 strcpy(pIdentifier->Description, Adapters[Adapter].description);
1661
1662 /* Note dx8 doesn't supply a DeviceName */
1663 if (NULL != pIdentifier->DeviceName) strcpy(pIdentifier->DeviceName, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1664 pIdentifier->DriverVersion->u.HighPart = Adapters[Adapter].gl_info.driver_version_hipart;
1665 pIdentifier->DriverVersion->u.LowPart = Adapters[Adapter].gl_info.driver_version;
1666 *(pIdentifier->VendorId) = Adapters[Adapter].gl_info.gl_vendor;
1667 *(pIdentifier->DeviceId) = Adapters[Adapter].gl_info.gl_card;
1668 *(pIdentifier->SubSysId) = 0;
1669 *(pIdentifier->Revision) = 0;
1670 *pIdentifier->DeviceIdentifier = IID_D3DDEVICE_D3DUID;
1671
1672 if (Flags & WINED3DENUM_NO_WHQL_LEVEL) {
1673 *(pIdentifier->WHQLLevel) = 0;
1674 } else {
1675 *(pIdentifier->WHQLLevel) = 1;
1676 }
1677
1678 return WINED3D_OK;
1679 }
1680
1681 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1682 short redSize, greenSize, blueSize, alphaSize, colorBits;
1683
1684 if(!cfg)
1685 return FALSE;
1686
1687 if(cfg->iPixelType == WGL_TYPE_RGBA_ARB) { /* Integer RGBA formats */
1688 if(!getColorBits(Format, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits)) {
1689 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1690 return FALSE;
1691 }
1692
1693 if(cfg->redSize < redSize)
1694 return FALSE;
1695
1696 if(cfg->greenSize < greenSize)
1697 return FALSE;
1698
1699 if(cfg->blueSize < blueSize)
1700 return FALSE;
1701
1702 if(cfg->alphaSize < alphaSize)
1703 return FALSE;
1704
1705 return TRUE;
1706 } else if(cfg->iPixelType == WGL_TYPE_RGBA_FLOAT_ARB) { /* Float RGBA formats; TODO: WGL_NV_float_buffer */
1707 if(Format == WINED3DFMT_R16F)
1708 return (cfg->redSize == 16 && cfg->greenSize == 0 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1709 if(Format == WINED3DFMT_G16R16F)
1710 return (cfg->redSize == 16 && cfg->greenSize == 16 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1711 if(Format == WINED3DFMT_A16B16G16R16F)
1712 return (cfg->redSize == 16 && cfg->greenSize == 16 && cfg->blueSize == 16 && cfg->alphaSize == 16);
1713 if(Format == WINED3DFMT_R32F)
1714 return (cfg->redSize == 32 && cfg->greenSize == 0 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1715 if(Format == WINED3DFMT_G32R32F)
1716 return (cfg->redSize == 32 && cfg->greenSize == 32 && cfg->blueSize == 0 && cfg->alphaSize == 0);
1717 if(Format == WINED3DFMT_A32B32G32R32F)
1718 return (cfg->redSize == 32 && cfg->greenSize == 32 && cfg->blueSize == 32 && cfg->alphaSize == 32);
1719 } else {
1720 /* Probably a color index mode */
1721 return FALSE;
1722 }
1723
1724 return FALSE;
1725 }
1726
1727 static BOOL IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const WineD3D_PixelFormat *cfg, WINED3DFORMAT Format) {
1728 short depthSize, stencilSize;
1729 BOOL lockable = FALSE;
1730
1731 if(!cfg)
1732 return FALSE;
1733
1734 if(!getDepthStencilBits(Format, &depthSize, &stencilSize)) {
1735 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format));
1736 return FALSE;
1737 }
1738
1739 if((Format == WINED3DFMT_D16_LOCKABLE) || (Format == WINED3DFMT_D32F_LOCKABLE))
1740 lockable = TRUE;
1741
1742 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
1743 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
1744 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
1745 if(!(cfg->depthSize == depthSize || (!lockable && cfg->depthSize > depthSize)))
1746 return FALSE;
1747
1748 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
1749 * allow more stencil bits than requested. */
1750 if(cfg->stencilSize < stencilSize)
1751 return FALSE;
1752
1753 return TRUE;
1754 }
1755
1756 static HRESULT WINAPI IWineD3DImpl_CheckDepthStencilMatch(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1757 WINED3DFORMAT AdapterFormat,
1758 WINED3DFORMAT RenderTargetFormat,
1759 WINED3DFORMAT DepthStencilFormat) {
1760 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1761 int nCfgs;
1762 WineD3D_PixelFormat *cfgs;
1763 int it;
1764
1765 WARN_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1766 This, Adapter,
1767 DeviceType, debug_d3ddevicetype(DeviceType),
1768 AdapterFormat, debug_d3dformat(AdapterFormat),
1769 RenderTargetFormat, debug_d3dformat(RenderTargetFormat),
1770 DepthStencilFormat, debug_d3dformat(DepthStencilFormat));
1771
1772 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1773 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This, Adapter, IWineD3D_GetAdapterCount(iface));
1774 return WINED3DERR_INVALIDCALL;
1775 }
1776
1777 cfgs = Adapters[Adapter].cfgs;
1778 nCfgs = Adapters[Adapter].nCfgs;
1779 for (it = 0; it < nCfgs; ++it) {
1780 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], RenderTargetFormat)) {
1781 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[it], DepthStencilFormat)) {
1782 TRACE_(d3d_caps)("(%p) : Formats matched\n", This);
1783 return WINED3D_OK;
1784 }
1785 }
1786 }
1787 WARN_(d3d_caps)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat), debug_d3dformat(DepthStencilFormat));
1788
1789 return WINED3DERR_NOTAVAILABLE;
1790 }
1791
1792 static HRESULT WINAPI IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1793 WINED3DFORMAT SurfaceFormat,
1794 BOOL Windowed, WINED3DMULTISAMPLE_TYPE MultiSampleType, DWORD* pQualityLevels) {
1795
1796 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1797 const GlPixelFormatDesc *glDesc;
1798 const StaticPixelFormatDesc *desc;
1799
1800 TRACE_(d3d_caps)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1801 This,
1802 Adapter,
1803 DeviceType, debug_d3ddevicetype(DeviceType),
1804 SurfaceFormat, debug_d3dformat(SurfaceFormat),
1805 Windowed,
1806 MultiSampleType,
1807 pQualityLevels);
1808
1809 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1810 return WINED3DERR_INVALIDCALL;
1811 }
1812
1813 /* TODO: handle Windowed, add more quality levels */
1814
1815 if (WINED3DMULTISAMPLE_NONE == MultiSampleType) return WINED3D_OK;
1816
1817 /* By default multisampling is disabled right now as it causes issues
1818 * on some Nvidia driver versions and it doesn't work well in combination
1819 * with FBOs yet. */
1820 if(!wined3d_settings.allow_multisampling)
1821 return WINED3DERR_NOTAVAILABLE;
1822
1823 desc = getFormatDescEntry(SurfaceFormat, &Adapters[Adapter].gl_info, &glDesc);
1824 if(!desc || !glDesc) {
1825 return WINED3DERR_INVALIDCALL;
1826 }
1827
1828 if(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) {
1829 int i, nCfgs;
1830 WineD3D_PixelFormat *cfgs;
1831
1832 cfgs = Adapters[Adapter].cfgs;
1833 nCfgs = Adapters[Adapter].nCfgs;
1834 for(i=0; i<nCfgs; i++) {
1835 if(cfgs[i].numSamples != MultiSampleType)
1836 continue;
1837
1838 if(!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs[i], SurfaceFormat))
1839 continue;
1840
1841 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
1842
1843 if(pQualityLevels)
1844 *pQualityLevels = 1; /* Guess at a value! */
1845 return WINED3D_OK;
1846 }
1847 }
1848 else if(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET) {
1849 short redSize, greenSize, blueSize, alphaSize, colorBits;
1850 int i, nCfgs;
1851 WineD3D_PixelFormat *cfgs;
1852
1853 if(!getColorBits(SurfaceFormat, &redSize, &greenSize, &blueSize, &alphaSize, &colorBits)) {
1854 ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat);
1855 return WINED3DERR_NOTAVAILABLE;
1856 }
1857
1858 cfgs = Adapters[Adapter].cfgs;
1859 nCfgs = Adapters[Adapter].nCfgs;
1860 for(i=0; i<nCfgs; i++) {
1861 if(cfgs[i].numSamples != MultiSampleType)
1862 continue;
1863 if(cfgs[i].redSize != redSize)
1864 continue;
1865 if(cfgs[i].greenSize != greenSize)
1866 continue;
1867 if(cfgs[i].blueSize != blueSize)
1868 continue;
1869 if(cfgs[i].alphaSize != alphaSize)
1870 continue;
1871
1872 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs[i].iPixelFormat, MultiSampleType, debug_d3dformat(SurfaceFormat));
1873
1874 if(pQualityLevels)
1875 *pQualityLevels = 1; /* Guess at a value! */
1876 return WINED3D_OK;
1877 }
1878 }
1879 return WINED3DERR_NOTAVAILABLE;
1880 }
1881
1882 static HRESULT WINAPI IWineD3DImpl_CheckDeviceType(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
1883 WINED3DFORMAT DisplayFormat, WINED3DFORMAT BackBufferFormat, BOOL Windowed) {
1884
1885 IWineD3DImpl *This = (IWineD3DImpl *)iface;
1886 HRESULT hr = WINED3DERR_NOTAVAILABLE;
1887 UINT nmodes;
1888
1889 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1890 This,
1891 Adapter,
1892 DeviceType, debug_d3ddevicetype(DeviceType),
1893 DisplayFormat, debug_d3dformat(DisplayFormat),
1894 BackBufferFormat, debug_d3dformat(BackBufferFormat),
1895 Windowed);
1896
1897 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
1898 WARN_(d3d_caps)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
1899 return WINED3DERR_INVALIDCALL;
1900 }
1901
1902 /* The task of this function is to check whether a certain display / backbuffer format
1903 * combination is available on the given adapter. In fullscreen mode microsoft specified
1904 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
1905 * and display format should match exactly.
1906 * In windowed mode format conversion can occur and this depends on the driver. When format
1907 * conversion is done, this function should nevertheless fail and applications need to use
1908 * CheckDeviceFormatConversion.
1909 * At the moment we assume that fullscreen and windowed have the same capabilities */
1910
1911 /* There are only 4 display formats */
1912 if(!((DisplayFormat == WINED3DFMT_R5G6B5) ||
1913 (DisplayFormat == WINED3DFMT_X1R5G5B5) ||
1914 (DisplayFormat == WINED3DFMT_X8R8G8B8) ||
1915 (DisplayFormat == WINED3DFMT_A2R10G10B10)))
1916 {
1917 TRACE_(d3d_caps)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat));
1918 return WINED3DERR_NOTAVAILABLE;
1919 }
1920
1921 /* If the requested DisplayFormat is not available, don't continue */
1922 nmodes = IWineD3DImpl_GetAdapterModeCount(iface, Adapter, DisplayFormat);
1923 if(!nmodes) {
1924 TRACE_(d3d_caps)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat));
1925 return WINED3DERR_NOTAVAILABLE;
1926 }
1927
1928 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
1929 if(!Windowed && BackBufferFormat == WINED3DFMT_UNKNOWN) {
1930 TRACE_(d3d_caps)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
1931 return WINED3DERR_NOTAVAILABLE;
1932 }
1933
1934 /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
1935 if( (DisplayFormat == WINED3DFMT_R5G6B5) && (BackBufferFormat != WINED3DFMT_R5G6B5) ) {
1936 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1937 return WINED3DERR_NOTAVAILABLE;
1938 }
1939
1940 /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
1941 if( (DisplayFormat == WINED3DFMT_X1R5G5B5) && !((BackBufferFormat == WINED3DFMT_X1R5G5B5) || (BackBufferFormat == WINED3DFMT_A1R5G5B5)) ) {
1942 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1943 return WINED3DERR_NOTAVAILABLE;
1944 }
1945
1946 /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
1947 if( (DisplayFormat == WINED3DFMT_X8R8G8B8) && !((BackBufferFormat == WINED3DFMT_X8R8G8B8) || (BackBufferFormat == WINED3DFMT_A8R8G8B8)) ) {
1948 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1949 return WINED3DERR_NOTAVAILABLE;
1950 }
1951
1952 /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
1953 if( (DisplayFormat == WINED3DFMT_A2R10G10B10) && ((BackBufferFormat != WINED3DFMT_A2R10G10B10) || Windowed)) {
1954 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1955 return WINED3DERR_NOTAVAILABLE;
1956 }
1957
1958 /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
1959 hr = IWineD3DImpl_CheckDeviceFormat(iface, Adapter, DeviceType, DisplayFormat, WINED3DUSAGE_RENDERTARGET, WINED3DRTYPE_SURFACE, BackBufferFormat, SURFACE_OPENGL);
1960 if(FAILED(hr))
1961 TRACE_(d3d_caps)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat), debug_d3dformat(BackBufferFormat));
1962
1963 return hr;
1964 }
1965
1966
1967 #define GLINFO_LOCATION Adapters[Adapter].gl_info
1968 /* Check if we support bumpmapping for a format */
1969 static BOOL CheckBumpMapCapability(UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat)
1970 {
1971 const struct fragment_pipeline *fp;
1972 const GlPixelFormatDesc *glDesc;
1973
1974 switch(CheckFormat) {
1975 case WINED3DFMT_V8U8:
1976 case WINED3DFMT_V16U16:
1977 case WINED3DFMT_L6V5U5:
1978 case WINED3DFMT_X8L8V8U8:
1979 case WINED3DFMT_Q8W8V8U8:
1980 getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
1981 if(glDesc->conversion_group == WINED3DFMT_UNKNOWN) {
1982 /* We have a GL extension giving native support */
1983 TRACE_(d3d_caps)("[OK]\n");
1984 return TRUE;
1985 }
1986
1987 /* No native support: Ask the fixed function pipeline implementation if it
1988 * can deal with the conversion
1989 */
1990 fp = select_fragment_implementation(Adapter, DeviceType);
1991 if(fp->conv_supported(CheckFormat)) {
1992 TRACE_(d3d_caps)("[OK]\n");
1993 return TRUE;
1994 } else {
1995 TRACE_(d3d_caps)("[FAILED]\n");
1996 return FALSE;
1997 }
1998
1999 default:
2000 TRACE_(d3d_caps)("[FAILED]\n");
2001 return FALSE;
2002 }
2003 }
2004
2005 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
2006 static BOOL CheckDepthStencilCapability(UINT Adapter, WINED3DFORMAT DisplayFormat, WINED3DFORMAT DepthStencilFormat)
2007 {
2008 int it=0;
2009 const GlPixelFormatDesc *glDesc;
2010 const StaticPixelFormatDesc *desc = getFormatDescEntry(DepthStencilFormat, &GLINFO_LOCATION, &glDesc);
2011
2012 /* Fail if we weren't able to get a description of the format */
2013 if(!desc || !glDesc)
2014 return FALSE;
2015
2016 /* Only allow depth/stencil formats */
2017 if(!(glDesc->Flags & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)))
2018 return FALSE;
2019
2020 /* Walk through all WGL pixel formats to find a match */
2021 for (it = 0; it < Adapters[Adapter].nCfgs; ++it) {
2022 WineD3D_PixelFormat *cfg = &Adapters[Adapter].cfgs[it];
2023 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(cfg, DisplayFormat)) {
2024 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(cfg, DepthStencilFormat)) {
2025 return TRUE;
2026 }
2027 }
2028 }
2029
2030 return FALSE;
2031 }
2032
2033 static BOOL CheckFilterCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2034 {
2035 const GlPixelFormatDesc *glDesc;
2036 const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
2037
2038 /* Fail if we weren't able to get a description of the format */
2039 if(!desc || !glDesc)
2040 return FALSE;
2041
2042 /* The flags entry of a format contains the filtering capability */
2043 if(glDesc->Flags & WINED3DFMT_FLAG_FILTERING)
2044 return TRUE;
2045
2046 return FALSE;
2047 }
2048
2049 /* Check the render target capabilities of a format */
2050 static BOOL CheckRenderTargetCapability(WINED3DFORMAT AdapterFormat, WINED3DFORMAT CheckFormat)
2051 {
2052 UINT Adapter = 0;
2053 const GlPixelFormatDesc *glDesc;
2054 const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
2055
2056 /* Fail if we weren't able to get a description of the format */
2057 if(!desc || !glDesc)
2058 return FALSE;
2059
2060 /* Filter out non-RT formats */
2061 if(!(glDesc->Flags & WINED3DFMT_FLAG_RENDERTARGET))
2062 return FALSE;
2063
2064 if(wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) {
2065 WineD3D_PixelFormat *cfgs = Adapters[Adapter].cfgs;
2066 int it;
2067 short AdapterRed, AdapterGreen, AdapterBlue, AdapterAlpha, AdapterTotalSize;
2068 short CheckRed, CheckGreen, CheckBlue, CheckAlpha, CheckTotalSize;
2069
2070 getColorBits(AdapterFormat, &AdapterRed, &AdapterGreen, &AdapterBlue, &AdapterAlpha, &AdapterTotalSize);
2071 getColorBits(CheckFormat, &CheckRed, &CheckGreen, &CheckBlue, &CheckAlpha, &CheckTotalSize);
2072
2073 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
2074 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
2075 if(!((AdapterRed == CheckRed) && (AdapterGreen == CheckGreen) && (AdapterBlue == CheckBlue))) {
2076 TRACE_(d3d_caps)("[FAILED]\n");
2077 return FALSE;
2078 }
2079
2080 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
2081 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
2082 for (it = 0; it < Adapters[Adapter].nCfgs; ++it) {
2083 if (cfgs[it].windowDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], CheckFormat)) {
2084 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs[it].iPixelFormat, debug_d3dformat(CheckFormat));
2085 return TRUE;
2086 }
2087 }
2088 } else if(wined3d_settings.offscreen_rendering_mode == ORM_PBUFFER) {
2089 /* We can probably use this function in FBO mode too on some drivers to get some basic indication of the capabilities. */
2090 WineD3D_PixelFormat *cfgs = Adapters[Adapter].cfgs;
2091 int it;
2092
2093 /* Check if there is a WGL pixel format matching the requirements, the pixel format should also be usable with pbuffers */
2094 for (it = 0; it < Adapters[Adapter].nCfgs; ++it) {
2095 if (cfgs[it].pbufferDrawable && IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs[it], CheckFormat)) {
2096 TRACE_(d3d_caps)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs[it].iPixelFormat, debug_d3dformat(CheckFormat));
2097 return TRUE;
2098 }
2099 }
2100 } else if(wined3d_settings.offscreen_rendering_mode == ORM_FBO){
2101 /* For now return TRUE for FBOs until we have some proper checks.
2102 * Note that this function will only be called when the format is around for texturing. */
2103 return TRUE;
2104 }
2105 return FALSE;
2106 }
2107
2108 static BOOL CheckSrgbReadCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2109 {
2110 /* Check for supported sRGB formats (Texture loading and framebuffer) */
2111 if(!GL_SUPPORT(EXT_TEXTURE_SRGB)) {
2112 TRACE_(d3d_caps)("[FAILED] GL_EXT_texture_sRGB not supported\n");
2113 return FALSE;
2114 }
2115
2116 switch (CheckFormat) {
2117 case WINED3DFMT_A8R8G8B8:
2118 case WINED3DFMT_X8R8G8B8:
2119 case WINED3DFMT_A4R4G4B4:
2120 case WINED3DFMT_L8:
2121 case WINED3DFMT_A8L8:
2122 case WINED3DFMT_DXT1:
2123 case WINED3DFMT_DXT2:
2124 case WINED3DFMT_DXT3:
2125 case WINED3DFMT_DXT4:
2126 case WINED3DFMT_DXT5:
2127 TRACE_(d3d_caps)("[OK]\n");
2128 return TRUE;
2129
2130 default:
2131 TRACE_(d3d_caps)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(CheckFormat));
2132 return FALSE;
2133 }
2134 return FALSE;
2135 }
2136
2137 static BOOL CheckSrgbWriteCapability(UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat)
2138 {
2139 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
2140 * doing the color fixup in shaders.
2141 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
2142 if((CheckFormat == WINED3DFMT_X8R8G8B8) || (CheckFormat == WINED3DFMT_A8R8G8B8)) {
2143 int vs_selected_mode;
2144 int ps_selected_mode;
2145 select_shader_mode(&GLINFO_LOCATION, DeviceType, &ps_selected_mode, &vs_selected_mode);
2146
2147 if((ps_selected_mode == SHADER_ARB) || (ps_selected_mode == SHADER_GLSL)) {
2148 TRACE_(d3d_caps)("[OK]\n");
2149 return TRUE;
2150 }
2151 }
2152
2153 TRACE_(d3d_caps)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(CheckFormat));
2154 return FALSE;
2155 }
2156
2157 /* Check if a format support blending in combination with pixel shaders */
2158 static BOOL CheckPostPixelShaderBlendingCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2159 {
2160 const GlPixelFormatDesc *glDesc;
2161 const StaticPixelFormatDesc *desc = getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
2162
2163 /* Fail if we weren't able to get a description of the format */
2164 if(!desc || !glDesc)
2165 return FALSE;
2166
2167 /* The flags entry of a format contains the post pixel shader blending capability */
2168 if(glDesc->Flags & WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING)
2169 return TRUE;
2170
2171 return FALSE;
2172 }
2173
2174 static BOOL CheckWrapAndMipCapability(UINT Adapter, WINED3DFORMAT CheckFormat) {
2175 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
2176 * but we have to report mipmapping so we cannot reject this flag. Tests show that
2177 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
2178 * that wrapping is supported. The lack of filtering will sort out the mipmapping
2179 * capability anyway.
2180 *
2181 * For now lets report this on all formats, but in the future we may want to
2182 * restrict it to some should games need that
2183 */
2184 return TRUE;
2185 }
2186
2187 /* Check if a texture format is supported on the given adapter */
2188 static BOOL CheckTextureCapability(UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat)
2189 {
2190 const shader_backend_t *shader_backend;
2191 const struct fragment_pipeline *fp;
2192 const GlPixelFormatDesc *glDesc;
2193
2194 switch (CheckFormat) {
2195
2196 /*****
2197 * supported: RGB(A) formats
2198 */
2199 case WINED3DFMT_R8G8B8: /* Enable for dx7, blacklisted for 8 and 9 above */
2200 case WINED3DFMT_A8R8G8B8:
2201 case WINED3DFMT_X8R8G8B8:
2202 case WINED3DFMT_R5G6B5:
2203 case WINED3DFMT_X1R5G5B5:
2204 case WINED3DFMT_A1R5G5B5:
2205 case WINED3DFMT_A4R4G4B4:
2206 case WINED3DFMT_A8:
2207 case WINED3DFMT_X4R4G4B4:
2208 case WINED3DFMT_A8B8G8R8:
2209 case WINED3DFMT_X8B8G8R8:
2210 case WINED3DFMT_A2R10G10B10:
2211 case WINED3DFMT_A2B10G10R10:
2212 case WINED3DFMT_G16R16:
2213 TRACE_(d3d_caps)("[OK]\n");
2214 return TRUE;
2215
2216 case WINED3DFMT_R3G3B2:
2217 TRACE_(d3d_caps)("[FAILED] - Not supported on Windows\n");
2218 return FALSE;
2219
2220 /*****
2221 * supported: Palettized
2222 */
2223 case WINED3DFMT_P8:
2224 TRACE_(d3d_caps)("[OK]\n");
2225 return TRUE;
2226 /* No Windows driver offers A8P8, so don't offer it either */
2227 case WINED3DFMT_A8P8:
2228 return FALSE;
2229
2230 /*****
2231 * Supported: (Alpha)-Luminance
2232 */
2233 case WINED3DFMT_L8:
2234 case WINED3DFMT_A8L8:
2235 case WINED3DFMT_L16:
2236 TRACE_(d3d_caps)("[OK]\n");
2237 return TRUE;
2238
2239 /* Not supported on Windows, thus disabled */
2240 case WINED3DFMT_A4L4:
2241 TRACE_(d3d_caps)("[FAILED] - not supported on windows\n");
2242 return FALSE;
2243
2244 /*****
2245 * Supported: Depth/Stencil formats
2246 */
2247 case WINED3DFMT_D16_LOCKABLE:
2248 case WINED3DFMT_D16:
2249 case WINED3DFMT_D15S1:
2250 case WINED3DFMT_D24X8:
2251 case WINED3DFMT_D24X4S4:
2252 case WINED3DFMT_D24S8:
2253 case WINED3DFMT_D24FS8:
2254 case WINED3DFMT_D32:
2255 case WINED3DFMT_D32F_LOCKABLE:
2256 return TRUE;
2257
2258 /*****
2259 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
2260 * GL_NV_texture_shader). Emulated by shaders
2261 */
2262 case WINED3DFMT_V8U8:
2263 case WINED3DFMT_X8L8V8U8:
2264 case WINED3DFMT_L6V5U5:
2265 case WINED3DFMT_Q8W8V8U8:
2266 case WINED3DFMT_V16U16:
2267 case WINED3DFMT_W11V11U10:
2268 getFormatDescEntry(CheckFormat, &GLINFO_LOCATION, &glDesc);
2269 if(glDesc->conversion_group == WINED3DFMT_UNKNOWN) {
2270 /* We have a GL extension giving native support */
2271 TRACE_(d3d_caps)("[OK]\n");
2272 return TRUE;
2273 }
2274
2275 /* No native support: Ask the fixed function pipeline implementation if it
2276 * can deal with the conversion
2277 */
2278 shader_backend = select_shader_backend(Adapter, DeviceType);
2279 if(shader_backend->shader_conv_supported(CheckFormat)) {
2280 TRACE_(d3d_caps)("[OK]\n");
2281 return TRUE;
2282 } else {
2283 TRACE_(d3d_caps)("[FAILED]\n");
2284 return FALSE;
2285 }
2286
2287 case WINED3DFMT_DXT1:
2288 case WINED3DFMT_DXT2:
2289 case WINED3DFMT_DXT3:
2290 case WINED3DFMT_DXT4:
2291 case WINED3DFMT_DXT5:
2292 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC)) {
2293 TRACE_(d3d_caps)("[OK]\n");
2294 return TRUE;
2295 }
2296 TRACE_(d3d_caps)("[FAILED]\n");
2297 return FALSE;
2298
2299
2300 /*****
2301 * Odd formats - not supported
2302 */
2303 case WINED3DFMT_VERTEXDATA:
2304 case WINED3DFMT_INDEX16:
2305 case WINED3DFMT_INDEX32:
2306 case WINED3DFMT_Q16W16V16U16:
2307 case WINED3DFMT_A2W10V10U10:
2308 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2309 return FALSE;
2310
2311 /*****
2312 * WINED3DFMT_CxV8U8: Not supported right now
2313 */
2314 case WINED3DFMT_CxV8U8:
2315 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2316 return FALSE;
2317
2318 /* YUV formats */
2319 case WINED3DFMT_UYVY:
2320 case WINED3DFMT_YUY2:
2321 if(GL_SUPPORT(APPLE_YCBCR_422)) {
2322 TRACE_(d3d_caps)("[OK]\n");
2323 return TRUE;
2324 }
2325 TRACE_(d3d_caps)("[FAILED]\n");
2326 return FALSE;
2327 case WINED3DFMT_YV12:
2328 TRACE_(d3d_caps)("[FAILED]\n");
2329 return FALSE;
2330
2331 /* Not supported */
2332 case WINED3DFMT_A16B16G16R16:
2333 case WINED3DFMT_A8R3G3B2:
2334 TRACE_(d3d_caps)("[FAILED]\n"); /* Enable when implemented */
2335 return FALSE;
2336
2337 /* Floating point formats */
2338 case WINED3DFMT_R16F:
2339 case WINED3DFMT_A16B16G16R16F:
2340 if(GL_SUPPORT(ARB_TEXTURE_FLOAT) && GL_SUPPORT(ARB_HALF_FLOAT_PIXEL)) {
2341 TRACE_(d3d_caps)("[OK]\n");
2342 return TRUE;
2343 }
2344 TRACE_(d3d_caps)("[FAILED]\n");
2345 return FALSE;
2346
2347 case WINED3DFMT_R32F:
2348 case WINED3DFMT_A32B32G32R32F:
2349 if (GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
2350 TRACE_(d3d_caps)("[OK]\n");
2351 return TRUE;
2352 }
2353 TRACE_(d3d_caps)("[FAILED]\n");
2354 return FALSE;
2355
2356 case WINED3DFMT_G16R16F:
2357 case WINED3DFMT_G32R32F:
2358 TRACE_(d3d_caps)("[FAILED]\n");
2359 return FALSE;
2360
2361 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
2362 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
2363 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
2364 * We can do instancing with all shader versions, but we need vertex shaders.
2365 *
2366 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
2367 * to enable instancing. WineD3D doesn't need that and just ignores it.
2368 *
2369 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
2370 */
2371 case WINEMAKEFOURCC('I','N','S','T'):
2372 TRACE("ATI Instancing check hack\n");
2373 if(GL_SUPPORT(ARB_VERTEX_PROGRAM) || GL_SUPPORT(ARB_VERTEX_SHADER)) {
2374 TRACE_(d3d_caps)("[OK]\n");
2375 return TRUE;
2376 }
2377 TRACE_(d3d_caps)("[FAILED]\n");
2378 return FALSE;
2379
2380 /* Some weird FOURCC formats */
2381 case WINED3DFMT_R8G8_B8G8:
2382 case WINED3DFMT_G8R8_G8B8:
2383 case WINED3DFMT_MULTI2_ARGB8:
2384 TRACE_(d3d_caps)("[FAILED]\n");
2385 return FALSE;
2386
2387 /* Vendor specific formats */
2388 case WINED3DFMT_ATI2N:
2389 if(GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC) || GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC)) {
2390 shader_backend = select_shader_backend(Adapter, DeviceType);
2391 fp = select_fragment_implementation(Adapter, DeviceType);
2392 if(shader_backend->shader_conv_supported(CheckFormat) &&
2393 fp->conv_supported(CheckFormat)) {
2394 TRACE_(d3d_caps)("[OK]\n");
2395 return TRUE;
2396 }
2397
2398 TRACE_(d3d_caps)("[OK]\n");
2399 return TRUE;
2400 }
2401 TRACE_(d3d_caps)("[FAILED]\n");
2402 return FALSE;
2403
2404 case WINED3DFMT_NVHU:
2405 case WINED3DFMT_NVHS:
2406 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
2407 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
2408 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
2409 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
2410 * Applications have to deal with not having NVHS and NVHU.
2411 */
2412 TRACE_(d3d_caps)("[FAILED]\n");
2413 return FALSE;
2414
2415 case WINED3DFMT_UNKNOWN:
2416 return FALSE;
2417
2418 default:
2419 ERR("Unhandled format=%s\n", debug_d3dformat(CheckFormat));
2420 break;
2421 }
2422 return FALSE;
2423 }
2424
2425 static BOOL CheckSurfaceCapability(UINT Adapter, WINED3DFORMAT AdapterFormat, WINED3DDEVTYPE DeviceType, WINED3DFORMAT CheckFormat, WINED3DSURFTYPE SurfaceType) {
2426 const struct blit_shader *blitter;
2427
2428 if(SurfaceType == SURFACE_GDI) {
2429 switch(CheckFormat) {
2430 case WINED3DFMT_R8G8B8:
2431 case WINED3DFMT_A8R8G8B8:
2432 case WINED3DFMT_X8R8G8B8:
2433 case WINED3DFMT_R5G6B5:
2434 case WINED3DFMT_X1R5G5B5:
2435 case WINED3DFMT_A1R5G5B5:
2436 case WINED3DFMT_A4R4G4B4:
2437 case WINED3DFMT_R3G3B2:
2438 case WINED3DFMT_A8:
2439 case WINED3DFMT_A8R3G3B2:
2440 case WINED3DFMT_X4R4G4B4:
2441 case WINED3DFMT_A2B10G10R10:
2442 case WINED3DFMT_A8B8G8R8:
2443 case WINED3DFMT_X8B8G8R8:
2444 case WINED3DFMT_G16R16:
2445 case WINED3DFMT_A2R10G10B10:
2446 case WINED3DFMT_A16B16G16R16:
2447 case WINED3DFMT_P8:
2448 TRACE_(d3d_caps)("[OK]\n");
2449 return TRUE;
2450 default:
2451 TRACE_(d3d_caps)("[FAILED] - not available on GDI surfaces\n");
2452 return FALSE;
2453 }
2454 }
2455
2456 /* All format that are supported for textures are supported for surfaces as well */
2457 if(CheckTextureCapability(Adapter, DeviceType, CheckFormat)) return TRUE;
2458 /* All depth stencil formats are supported on surfaces */
2459 if(CheckDepthStencilCapability(Adapter, AdapterFormat, CheckFormat)) return TRUE;
2460
2461 /* If opengl can't process the format natively, the blitter may be able to convert it */
2462 blitter = select_blit_implementation(Adapter, DeviceType);
2463 if(blitter->conv_supported(CheckFormat)) {
2464 TRACE_(d3d_caps)("[OK]\n");
2465 return TRUE;
2466 }
2467
2468 /* Reject other formats */
2469 TRACE_(d3d_caps)("[FAILED]\n");
2470 return FALSE;
2471 }
2472
2473 static BOOL CheckVertexTextureCapability(UINT Adapter, WINED3DFORMAT CheckFormat)
2474 {
2475 if (!GL_LIMITS(vertex_samplers)) {
2476 TRACE_(d3d_caps)("[FAILED]\n");
2477 return FALSE;
2478 }
2479
2480 switch (CheckFormat) {
2481 case WINED3DFMT_A32B32G32R32F:
2482 if (!GL_SUPPORT(ARB_TEXTURE_FLOAT)) {
2483 TRACE_(d3d_caps)("[FAILED]\n");
2484 return FALSE;
2485 }
2486 TRACE_(d3d_caps)("[OK]\n");
2487 return TRUE;
2488
2489 default:
2490 TRACE_(d3d_caps)("[FAILED]\n");
2491 return FALSE;
2492 }
2493 return FALSE;
2494 }
2495
2496 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormat(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
2497 WINED3DFORMAT AdapterFormat, DWORD Usage, WINED3DRESOURCETYPE RType, WINED3DFORMAT CheckFormat,
2498 WINED3DSURFTYPE SurfaceType) {
2499 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2500 DWORD UsageCaps = 0;
2501
2502 TRACE_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
2503 This,
2504 Adapter,
2505 DeviceType, debug_d3ddevicetype(DeviceType),
2506 AdapterFormat, debug_d3dformat(AdapterFormat),
2507 Usage, debug_d3dusage(Usage), debug_d3dusagequery(Usage),
2508 RType, debug_d3dresourcetype(RType),
2509 CheckFormat, debug_d3dformat(CheckFormat));
2510
2511 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
2512 return WINED3DERR_INVALIDCALL;
2513 }
2514
2515 if(RType == WINED3DRTYPE_CUBETEXTURE) {
2516
2517 if(SurfaceType != SURFACE_OPENGL) {
2518 TRACE("[FAILED]\n");
2519 return WINED3DERR_NOTAVAILABLE;
2520 }
2521
2522 /* Cubetexture allows:
2523 * - D3DUSAGE_AUTOGENMIPMAP
2524 * - D3DUSAGE_DEPTHSTENCIL
2525 * - D3DUSAGE_DYNAMIC
2526 * - D3DUSAGE_NONSECURE (d3d9ex)
2527 * - D3DUSAGE_RENDERTARGET
2528 * - D3DUSAGE_SOFTWAREPROCESSING
2529 * - D3DUSAGE_QUERY_WRAPANDMIP
2530 */
2531 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
2532 /* Check if the texture format is around */
2533 if(CheckTextureCapability(Adapter, DeviceType, CheckFormat)) {
2534 if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
2535 /* Check for automatic mipmap generation support */
2536 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
2537 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
2538 } else {
2539 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2540 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
2541 }
2542 }
2543
2544 /* Always report dynamic locking */
2545 if(Usage & WINED3DUSAGE_DYNAMIC)
2546 UsageCaps |= WINED3DUSAGE_DYNAMIC;
2547
2548 if(Usage & WINED3DUSAGE_RENDERTARGET) {
2549 if(CheckRenderTargetCapability(AdapterFormat, CheckFormat)) {
2550 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2551 } else {
2552 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2553 return WINED3DERR_NOTAVAILABLE;
2554 }
2555 }
2556
2557 /* Always report software processing */
2558 if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2559 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2560
2561 /* Check QUERY_FILTER support */
2562 if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2563 if(CheckFilterCapability(Adapter, CheckFormat)) {
2564 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2565 } else {
2566 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2567 return WINED3DERR_NOTAVAILABLE;
2568 }
2569 }
2570
2571 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2572 if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2573 if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2574 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2575 } else {
2576 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2577 return WINED3DERR_NOTAVAILABLE;
2578 }
2579 }
2580
2581 /* Check QUERY_SRGBREAD support */
2582 if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2583 if(CheckSrgbReadCapability(Adapter, CheckFormat)) {
2584 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2585 } else {
2586 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2587 return WINED3DERR_NOTAVAILABLE;
2588 }
2589 }
2590
2591 /* Check QUERY_SRGBWRITE support */
2592 if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2593 if(CheckSrgbWriteCapability(Adapter, DeviceType, CheckFormat)) {
2594 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2595 } else {
2596 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2597 return WINED3DERR_NOTAVAILABLE;
2598 }
2599 }
2600
2601 /* Check QUERY_VERTEXTEXTURE support */
2602 if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2603 if(CheckVertexTextureCapability(Adapter, CheckFormat)) {
2604 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2605 } else {
2606 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2607 return WINED3DERR_NOTAVAILABLE;
2608 }
2609 }
2610
2611 /* Check QUERY_WRAPANDMIP support */
2612 if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2613 if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2614 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2615 } else {
2616 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2617 return WINED3DERR_NOTAVAILABLE;
2618 }
2619 }
2620 } else {
2621 TRACE_(d3d_caps)("[FAILED] - Cube texture format not supported\n");
2622 return WINED3DERR_NOTAVAILABLE;
2623 }
2624 } else {
2625 TRACE_(d3d_caps)("[FAILED] - No cube texture support\n");
2626 return WINED3DERR_NOTAVAILABLE;
2627 }
2628 } else if(RType == WINED3DRTYPE_SURFACE) {
2629 /* Surface allows:
2630 * - D3DUSAGE_DEPTHSTENCIL
2631 * - D3DUSAGE_NONSECURE (d3d9ex)
2632 * - D3DUSAGE_RENDERTARGET
2633 */
2634
2635 if(CheckSurfaceCapability(Adapter, AdapterFormat, DeviceType, CheckFormat, SurfaceType)) {
2636 if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
2637 if(CheckDepthStencilCapability(Adapter, AdapterFormat, CheckFormat)) {
2638 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
2639 } else {
2640 TRACE_(d3d_caps)("[FAILED] - No depthstencil support\n");
2641 return WINED3DERR_NOTAVAILABLE;
2642 }
2643 }
2644
2645 if(Usage & WINED3DUSAGE_RENDERTARGET) {
2646 if(CheckRenderTargetCapability(AdapterFormat, CheckFormat)) {
2647 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2648 } else {
2649 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2650 return WINED3DERR_NOTAVAILABLE;
2651 }
2652 }
2653
2654 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2655 if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2656 if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2657 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2658 } else {
2659 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2660 return WINED3DERR_NOTAVAILABLE;
2661 }
2662 }
2663 } else {
2664 TRACE_(d3d_caps)("[FAILED] - Not supported for plain surfaces\n");
2665 return WINED3DERR_NOTAVAILABLE;
2666 }
2667
2668 } else if(RType == WINED3DRTYPE_TEXTURE) {
2669 /* Texture allows:
2670 * - D3DUSAGE_AUTOGENMIPMAP
2671 * - D3DUSAGE_DEPTHSTENCIL
2672 * - D3DUSAGE_DMAP
2673 * - D3DUSAGE_DYNAMIC
2674 * - D3DUSAGE_NONSECURE (d3d9ex)
2675 * - D3DUSAGE_RENDERTARGET
2676 * - D3DUSAGE_SOFTWAREPROCESSING
2677 * - D3DUSAGE_TEXTAPI (d3d9ex)
2678 * - D3DUSAGE_QUERY_WRAPANDMIP
2679 */
2680
2681 if(SurfaceType != SURFACE_OPENGL) {
2682 TRACE("[FAILED]\n");
2683 return WINED3DERR_NOTAVAILABLE;
2684 }
2685
2686 /* Check if the texture format is around */
2687 if(CheckTextureCapability(Adapter, DeviceType, CheckFormat)) {
2688 if(Usage & WINED3DUSAGE_AUTOGENMIPMAP) {
2689 /* Check for automatic mipmap generation support */
2690 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
2691 UsageCaps |= WINED3DUSAGE_AUTOGENMIPMAP;
2692 } else {
2693 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2694 TRACE_(d3d_caps)("[FAILED] - No autogenmipmap support, but continuing\n");
2695 }
2696 }
2697
2698 /* Always report dynamic locking */
2699 if(Usage & WINED3DUSAGE_DYNAMIC)
2700 UsageCaps |= WINED3DUSAGE_DYNAMIC;
2701
2702 if(Usage & WINED3DUSAGE_RENDERTARGET) {
2703 if(CheckRenderTargetCapability(AdapterFormat, CheckFormat)) {
2704 UsageCaps |= WINED3DUSAGE_RENDERTARGET;
2705 } else {
2706 TRACE_(d3d_caps)("[FAILED] - No rendertarget support\n");
2707 return WINED3DERR_NOTAVAILABLE;
2708 }
2709 }
2710
2711 /* Always report software processing */
2712 if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2713 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2714
2715 /* Check QUERY_FILTER support */
2716 if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2717 if(CheckFilterCapability(Adapter, CheckFormat)) {
2718 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2719 } else {
2720 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2721 return WINED3DERR_NOTAVAILABLE;
2722 }
2723 }
2724
2725 /* Check QUERY_LEGACYBUMPMAP support */
2726 if(Usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) {
2727 if(CheckBumpMapCapability(Adapter, DeviceType, CheckFormat)) {
2728 UsageCaps |= WINED3DUSAGE_QUERY_LEGACYBUMPMAP;
2729 } else {
2730 TRACE_(d3d_caps)("[FAILED] - No legacy bumpmap support\n");
2731 return WINED3DERR_NOTAVAILABLE;
2732 }
2733 }
2734
2735 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2736 if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2737 if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2738 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2739 } else {
2740 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2741 return WINED3DERR_NOTAVAILABLE;
2742 }
2743 }
2744
2745 /* Check QUERY_SRGBREAD support */
2746 if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2747 if(CheckSrgbReadCapability(Adapter, CheckFormat)) {
2748 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2749 } else {
2750 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2751 return WINED3DERR_NOTAVAILABLE;
2752 }
2753 }
2754
2755 /* Check QUERY_SRGBWRITE support */
2756 if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2757 if(CheckSrgbWriteCapability(Adapter, DeviceType, CheckFormat)) {
2758 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2759 } else {
2760 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2761 return WINED3DERR_NOTAVAILABLE;
2762 }
2763 }
2764
2765 /* Check QUERY_VERTEXTEXTURE support */
2766 if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2767 if(CheckVertexTextureCapability(Adapter, CheckFormat)) {
2768 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2769 } else {
2770 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2771 return WINED3DERR_NOTAVAILABLE;
2772 }
2773 }
2774
2775 /* Check QUERY_WRAPANDMIP support */
2776 if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2777 if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2778 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2779 } else {
2780 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2781 return WINED3DERR_NOTAVAILABLE;
2782 }
2783 }
2784
2785 if(Usage & WINED3DUSAGE_DEPTHSTENCIL) {
2786 if(CheckDepthStencilCapability(Adapter, AdapterFormat, CheckFormat)) {
2787 UsageCaps |= WINED3DUSAGE_DEPTHSTENCIL;
2788 } else {
2789 TRACE_(d3d_caps)("[FAILED] - No depth stencil support\n");
2790 return WINED3DERR_NOTAVAILABLE;
2791 }
2792 }
2793 } else {
2794 TRACE_(d3d_caps)("[FAILED] - Texture format not supported\n");
2795 return WINED3DERR_NOTAVAILABLE;
2796 }
2797 } else if((RType == WINED3DRTYPE_VOLUME) || (RType == WINED3DRTYPE_VOLUMETEXTURE)) {
2798 /* Volume is to VolumeTexture what Surface is to Texture but its usage caps are not documented.
2799 * Most driver seem to offer (nearly) the same on Volume and VolumeTexture, so do that too.
2800 *
2801 * Volumetexture allows:
2802 * - D3DUSAGE_DYNAMIC
2803 * - D3DUSAGE_NONSECURE (d3d9ex)
2804 * - D3DUSAGE_SOFTWAREPROCESSING
2805 * - D3DUSAGE_QUERY_WRAPANDMIP
2806 */
2807
2808 if(SurfaceType != SURFACE_OPENGL) {
2809 TRACE("[FAILED]\n");
2810 return WINED3DERR_NOTAVAILABLE;
2811 }
2812
2813 /* Check volume texture and volume usage caps */
2814 if(GL_SUPPORT(EXT_TEXTURE3D)) {
2815 if(CheckTextureCapability(Adapter, DeviceType, CheckFormat) == FALSE) {
2816 TRACE_(d3d_caps)("[FAILED] - Format not supported\n");
2817 return WINED3DERR_NOTAVAILABLE;
2818 }
2819
2820 /* Always report dynamic locking */
2821 if(Usage & WINED3DUSAGE_DYNAMIC)
2822 UsageCaps |= WINED3DUSAGE_DYNAMIC;
2823
2824 /* Always report software processing */
2825 if(Usage & WINED3DUSAGE_SOFTWAREPROCESSING)
2826 UsageCaps |= WINED3DUSAGE_SOFTWAREPROCESSING;
2827
2828 /* Check QUERY_FILTER support */
2829 if(Usage & WINED3DUSAGE_QUERY_FILTER) {
2830 if(CheckFilterCapability(Adapter, CheckFormat)) {
2831 UsageCaps |= WINED3DUSAGE_QUERY_FILTER;
2832 } else {
2833 TRACE_(d3d_caps)("[FAILED] - No query filter support\n");
2834 return WINED3DERR_NOTAVAILABLE;
2835 }
2836 }
2837
2838 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2839 if(Usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) {
2840 if(CheckPostPixelShaderBlendingCapability(Adapter, CheckFormat)) {
2841 UsageCaps |= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING;
2842 } else {
2843 TRACE_(d3d_caps)("[FAILED] - No query post pixelshader blending support\n");
2844 return WINED3DERR_NOTAVAILABLE;
2845 }
2846 }
2847
2848 /* Check QUERY_SRGBREAD support */
2849 if(Usage & WINED3DUSAGE_QUERY_SRGBREAD) {
2850 if(CheckSrgbReadCapability(Adapter, CheckFormat)) {
2851 UsageCaps |= WINED3DUSAGE_QUERY_SRGBREAD;
2852 } else {
2853 TRACE_(d3d_caps)("[FAILED] - No query srgbread support\n");
2854 return WINED3DERR_NOTAVAILABLE;
2855 }
2856 }
2857
2858 /* Check QUERY_SRGBWRITE support */
2859 if(Usage & WINED3DUSAGE_QUERY_SRGBWRITE) {
2860 if(CheckSrgbWriteCapability(Adapter, DeviceType, CheckFormat)) {
2861 UsageCaps |= WINED3DUSAGE_QUERY_SRGBWRITE;
2862 } else {
2863 TRACE_(d3d_caps)("[FAILED] - No query srgbwrite support\n");
2864 return WINED3DERR_NOTAVAILABLE;
2865 }
2866 }
2867
2868 /* Check QUERY_VERTEXTEXTURE support */
2869 if(Usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) {
2870 if(CheckVertexTextureCapability(Adapter, CheckFormat)) {
2871 UsageCaps |= WINED3DUSAGE_QUERY_VERTEXTEXTURE;
2872 } else {
2873 TRACE_(d3d_caps)("[FAILED] - No query vertextexture support\n");
2874 return WINED3DERR_NOTAVAILABLE;
2875 }
2876 }
2877
2878 /* Check QUERY_WRAPANDMIP support */
2879 if(Usage & WINED3DUSAGE_QUERY_WRAPANDMIP) {
2880 if(CheckWrapAndMipCapability(Adapter, CheckFormat)) {
2881 UsageCaps |= WINED3DUSAGE_QUERY_WRAPANDMIP;
2882 } else {
2883 TRACE_(d3d_caps)("[FAILED] - No wrapping and mipmapping support\n");
2884 return WINED3DERR_NOTAVAILABLE;
2885 }
2886 }
2887 } else {
2888 TRACE_(d3d_caps)("[FAILED] - No volume texture support\n");
2889 return WINED3DERR_NOTAVAILABLE;
2890 }
2891
2892 /* Filter formats that need conversion; For one part, this conversion is unimplemented,
2893 * and volume textures are huge, so it would be a big performance hit. Unless we hit an
2894 * app needing one of those formats, don't advertize them to avoid leading apps into
2895 * temptation. The windows drivers don't support most of those formats on volumes anyway,
2896 * except of R32F.
2897 */
2898 switch(CheckFormat) {
2899 case WINED3DFMT_P8:
2900 case WINED3DFMT_A4L4:
2901 case WINED3DFMT_R32F:
2902 case WINED3DFMT_R16F:
2903 case WINED3DFMT_X8L8V8U8:
2904 case WINED3DFMT_L6V5U5:
2905 case WINED3DFMT_G16R16:
2906 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2907 return WINED3DERR_NOTAVAILABLE;
2908
2909 case WINED3DFMT_Q8W8V8U8:
2910 case WINED3DFMT_V16U16:
2911 if(!GL_SUPPORT(NV_TEXTURE_SHADER)) {
2912 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2913 return WINED3DERR_NOTAVAILABLE;
2914 }
2915 break;
2916
2917 case WINED3DFMT_V8U8:
2918 if(!GL_SUPPORT(NV_TEXTURE_SHADER) || !GL_SUPPORT(ATI_ENVMAP_BUMPMAP)) {
2919 TRACE_(d3d_caps)("[FAILED] - No converted formats on volumes\n");
2920 return WINED3DERR_NOTAVAILABLE;
2921 }
2922 break;
2923
2924 case WINED3DFMT_DXT1:
2925 case WINED3DFMT_DXT2:
2926 case WINED3DFMT_DXT3:
2927 case WINED3DFMT_DXT4:
2928 case WINED3DFMT_DXT5:
2929 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
2930 * compressed texture results in an error. While the D3D refrast does
2931 * support s3tc volumes, at least the nvidia windows driver does not, so
2932 * we're free not to support this format.
2933 */
2934 TRACE_(d3d_caps)("[FAILED] - DXTn does not support 3D textures\n");
2935 return WINED3DERR_NOTAVAILABLE;
2936
2937 default:
2938 /* Do nothing, continue with checking the format below */
2939 break;
2940 }
2941 } else if((RType == WINED3DRTYPE_INDEXBUFFER) || (RType == WINED3DRTYPE_VERTEXBUFFER)){
2942 /* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
2943 TRACE_(d3d_caps)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
2944 return WINED3DERR_NOTAVAILABLE;
2945 }
2946
2947 /* This format is nothing special and it is supported perfectly.
2948 * However, ati and nvidia driver on windows do not mark this format as
2949 * supported (tested with the dxCapsViewer) and pretending to
2950 * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
2951 * So do the same as Windows drivers and pretend not to support it on dx8 and 9
2952 * Enable it on dx7. It will need additional checking on dx10 when we support it.
2953 */
2954 if(This->dxVersion > 7 && CheckFormat == WINED3DFMT_R8G8B8) {
2955 TRACE_(d3d_caps)("[FAILED]\n");
2956 return WINED3DERR_NOTAVAILABLE;
2957 }
2958
2959 /* When the UsageCaps exactly matches Usage return WINED3D_OK except for the situation in which
2960 * WINED3DUSAGE_AUTOGENMIPMAP isn't around, then WINED3DOK_NOAUTOGEN is returned if all the other
2961 * usage flags match. */
2962 if(UsageCaps == Usage) {
2963 return WINED3D_OK;
2964 } else if((UsageCaps == (Usage & ~WINED3DUSAGE_AUTOGENMIPMAP)) && (Usage & WINED3DUSAGE_AUTOGENMIPMAP)){
2965 return WINED3DOK_NOAUTOGEN;
2966 } else {
2967 TRACE_(d3d_caps)("[FAILED] - Usage=%#08x requested for CheckFormat=%s and RType=%d but only %#08x is available\n", Usage, debug_d3dformat(CheckFormat), RType, UsageCaps);
2968 return WINED3DERR_NOTAVAILABLE;
2969 }
2970 }
2971
2972 static HRESULT WINAPI IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType,
2973 WINED3DFORMAT SourceFormat, WINED3DFORMAT TargetFormat) {
2974 IWineD3DImpl *This = (IWineD3DImpl *)iface;
2975
2976 FIXME_(d3d_caps)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
2977 This,
2978 Adapter,
2979 DeviceType, debug_d3ddevicetype(DeviceType),
2980 SourceFormat, debug_d3dformat(SourceFormat),
2981 TargetFormat, debug_d3dformat(TargetFormat));
2982 return WINED3D_OK;
2983 }
2984
2985 static const shader_backend_t *select_shader_backend(UINT Adapter, WINED3DDEVTYPE DeviceType) {
2986 const shader_backend_t *ret;
2987 int vs_selected_mode;
2988 int ps_selected_mode;
2989
2990 select_shader_mode(&GLINFO_LOCATION, DeviceType, &ps_selected_mode, &vs_selected_mode);
2991 if (vs_selected_mode == SHADER_GLSL || ps_selected_mode == SHADER_GLSL) {
2992 ret = &glsl_shader_backend;
2993 } else if (vs_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_ARB) {
2994 ret = &arb_program_shader_backend;
2995 } else {
2996 ret = &none_shader_backend;
2997 }
2998 return ret;
2999 }
3000
3001 static const struct fragment_pipeline *select_fragment_implementation(UINT Adapter, WINED3DDEVTYPE DeviceType) {
3002 int vs_selected_mode;
3003 int ps_selected_mode;
3004
3005 select_shader_mode(&GLINFO_LOCATION, DeviceType, &ps_selected_mode, &vs_selected_mode);
3006 if((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
3007 return &arbfp_fragment_pipeline;
3008 } else if(ps_selected_mode == SHADER_ATI) {
3009 return &atifs_fragment_pipeline;
3010 } else if(GL_SUPPORT(NV_REGISTER_COMBINERS) && GL_SUPPORT(NV_TEXTURE_SHADER2)) {
3011 return &nvts_fragment_pipeline;
3012 } else if(GL_SUPPORT(NV_REGISTER_COMBINERS)) {
3013 return &nvrc_fragment_pipeline;
3014 } else {
3015 return &ffp_fragment_pipeline;
3016 }
3017 }
3018
3019 static const struct blit_shader *select_blit_implementation(UINT Adapter, WINED3DDEVTYPE DeviceType) {
3020 int vs_selected_mode;
3021 int ps_selected_mode;
3022
3023 select_shader_mode(&GLINFO_LOCATION, DeviceType, &ps_selected_mode, &vs_selected_mode);
3024 if((ps_selected_mode == SHADER_ARB || ps_selected_mode == SHADER_GLSL) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM)) {
3025 return &arbfp_blit;
3026 } else {
3027 return &ffp_blit;
3028 }
3029 }
3030
3031 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
3032 subset of a D3DCAPS9 structure. However, it has to come via a void *
3033 as the d3d8 interface cannot import the d3d9 header */
3034 static HRESULT WINAPI IWineD3DImpl_GetDeviceCaps(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, WINED3DCAPS* pCaps) {
3035
3036 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3037 int vs_selected_mode;
3038 int ps_selected_mode;
3039 struct shader_caps shader_caps;
3040 struct fragment_caps fragment_caps;
3041 const shader_backend_t *shader_backend;
3042 const struct fragment_pipeline *frag_pipeline = NULL;
3043 DWORD ckey_caps, blit_caps, fx_caps;
3044
3045 TRACE_(d3d_caps)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This, Adapter, DeviceType, pCaps);
3046
3047 if (Adapter >= IWineD3D_GetAdapterCount(iface)) {
3048 return WINED3DERR_INVALIDCALL;
3049 }
3050
3051 select_shader_mode(&Adapters[Adapter].gl_info, DeviceType, &ps_selected_mode, &vs_selected_mode);
3052
3053 /* This function should *not* be modifying GL caps
3054 * TODO: move the functionality where it belongs */
3055 select_shader_max_constants(ps_selected_mode, vs_selected_mode, &Adapters[Adapter].gl_info);
3056
3057 /* ------------------------------------------------
3058 The following fields apply to both d3d8 and d3d9
3059 ------------------------------------------------ */
3060 pCaps->DeviceType = (DeviceType == WINED3DDEVTYPE_HAL) ? WINED3DDEVTYPE_HAL : WINED3DDEVTYPE_REF; /* Not quite true, but use h/w supported by opengl I suppose */
3061 pCaps->AdapterOrdinal = Adapter;
3062
3063 pCaps->Caps = 0;
3064 pCaps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED |
3065 WINED3DCAPS2_FULLSCREENGAMMA |
3066 WINED3DCAPS2_DYNAMICTEXTURES;
3067 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP)) {
3068 pCaps->Caps2 |= WINED3DCAPS2_CANAUTOGENMIPMAP;
3069 }
3070 pCaps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD;
3071 pCaps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE |
3072 WINED3DPRESENT_INTERVAL_ONE;
3073
3074 pCaps->CursorCaps = WINED3DCURSORCAPS_COLOR |
3075 WINED3DCURSORCAPS_LOWRES;
3076
3077 pCaps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX |
3078 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY |
3079 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY|
3080 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY |
3081 WINED3DDEVCAPS_DRAWPRIMTLVERTEX |
3082 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT |
3083 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY |
3084 WINED3DDEVCAPS_PUREDEVICE |
3085 WINED3DDEVCAPS_HWRASTERIZATION |
3086 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY |
3087 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY |
3088 WINED3DDEVCAPS_CANRENDERAFTERFLIP |
3089 WINED3DDEVCAPS_DRAWPRIMITIVES2 |
3090 WINED3DDEVCAPS_DRAWPRIMITIVES2EX |
3091 WINED3DDEVCAPS_RTPATCHES;
3092
3093 pCaps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE |
3094 WINED3DPMISCCAPS_CULLCCW |
3095 WINED3DPMISCCAPS_CULLCW |
3096 WINED3DPMISCCAPS_COLORWRITEENABLE |
3097 WINED3DPMISCCAPS_CLIPTLVERTS |
3098 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS |
3099 WINED3DPMISCCAPS_MASKZ |
3100 WINED3DPMISCCAPS_BLENDOP |
3101 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING;
3102 /* TODO:
3103 WINED3DPMISCCAPS_NULLREFERENCE
3104 WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
3105 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
3106 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
3107 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
3108
3109 if(GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE) && GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE))
3110 pCaps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
3111
3112 pCaps->RasterCaps = WINED3DPRASTERCAPS_DITHER |
3113 WINED3DPRASTERCAPS_PAT |
3114 WINED3DPRASTERCAPS_WFOG |
3115 WINED3DPRASTERCAPS_ZFOG |
3116 WINED3DPRASTERCAPS_FOGVERTEX |
3117 WINED3DPRASTERCAPS_FOGTABLE |
3118 WINED3DPRASTERCAPS_STIPPLE |
3119 WINED3DPRASTERCAPS_SUBPIXEL |
3120 WINED3DPRASTERCAPS_ZTEST |
3121 WINED3DPRASTERCAPS_SCISSORTEST |
3122 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS |
3123 WINED3DPRASTERCAPS_DEPTHBIAS;
3124
3125 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3126 pCaps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY |
3127 WINED3DPRASTERCAPS_ZBIAS |
3128 WINED3DPRASTERCAPS_MIPMAPLODBIAS;
3129 }
3130 if(GL_SUPPORT(NV_FOG_DISTANCE)) {
3131 pCaps->RasterCaps |= WINED3DPRASTERCAPS_FOGRANGE;
3132 }
3133 /* FIXME Add:
3134 WINED3DPRASTERCAPS_COLORPERSPECTIVE
3135 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
3136 WINED3DPRASTERCAPS_ANTIALIASEDGES
3137 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
3138 WINED3DPRASTERCAPS_WBUFFER */
3139
3140 pCaps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS |
3141 WINED3DPCMPCAPS_EQUAL |
3142 WINED3DPCMPCAPS_GREATER |
3143 WINED3DPCMPCAPS_GREATEREQUAL |
3144 WINED3DPCMPCAPS_LESS |
3145 WINED3DPCMPCAPS_LESSEQUAL |
3146 WINED3DPCMPCAPS_NEVER |
3147 WINED3DPCMPCAPS_NOTEQUAL;
3148
3149 pCaps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA |
3150 WINED3DPBLENDCAPS_BOTHSRCALPHA |
3151 WINED3DPBLENDCAPS_DESTALPHA |
3152 WINED3DPBLENDCAPS_DESTCOLOR |
3153 WINED3DPBLENDCAPS_INVDESTALPHA |
3154 WINED3DPBLENDCAPS_INVDESTCOLOR |
3155 WINED3DPBLENDCAPS_INVSRCALPHA |
3156 WINED3DPBLENDCAPS_INVSRCCOLOR |
3157 WINED3DPBLENDCAPS_ONE |
3158 WINED3DPBLENDCAPS_SRCALPHA |
3159 WINED3DPBLENDCAPS_SRCALPHASAT |
3160 WINED3DPBLENDCAPS_SRCCOLOR |
3161 WINED3DPBLENDCAPS_ZERO;
3162
3163 pCaps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA |
3164 WINED3DPBLENDCAPS_DESTCOLOR |
3165 WINED3DPBLENDCAPS_INVDESTALPHA |
3166 WINED3DPBLENDCAPS_INVDESTCOLOR |
3167 WINED3DPBLENDCAPS_INVSRCALPHA |
3168 WINED3DPBLENDCAPS_INVSRCCOLOR |
3169 WINED3DPBLENDCAPS_ONE |
3170 WINED3DPBLENDCAPS_SRCALPHA |
3171 WINED3DPBLENDCAPS_SRCCOLOR |
3172 WINED3DPBLENDCAPS_ZERO;
3173 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
3174 * according to the glBlendFunc manpage
3175 *
3176 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
3177 * legacy settings for srcblend only
3178 */
3179
3180 if( GL_SUPPORT(EXT_BLEND_COLOR)) {
3181 pCaps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
3182 pCaps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
3183 }
3184
3185
3186 pCaps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS |
3187 WINED3DPCMPCAPS_EQUAL |
3188 WINED3DPCMPCAPS_GREATER |
3189 WINED3DPCMPCAPS_GREATEREQUAL |
3190 WINED3DPCMPCAPS_LESS |
3191 WINED3DPCMPCAPS_LESSEQUAL |
3192 WINED3DPCMPCAPS_NEVER |
3193 WINED3DPCMPCAPS_NOTEQUAL;
3194
3195 pCaps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB |
3196 WINED3DPSHADECAPS_COLORGOURAUDRGB |
3197 WINED3DPSHADECAPS_ALPHAFLATBLEND |
3198 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND |
3199 WINED3DPSHADECAPS_COLORFLATRGB |
3200 WINED3DPSHADECAPS_FOGFLAT |
3201 WINED3DPSHADECAPS_FOGGOURAUD |
3202 WINED3DPSHADECAPS_SPECULARFLATRGB;
3203
3204 pCaps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA |
3205 WINED3DPTEXTURECAPS_ALPHAPALETTE |
3206 WINED3DPTEXTURECAPS_TRANSPARENCY |
3207 WINED3DPTEXTURECAPS_BORDER |
3208 WINED3DPTEXTURECAPS_MIPMAP |
3209 WINED3DPTEXTURECAPS_PROJECTED |
3210 WINED3DPTEXTURECAPS_PERSPECTIVE;
3211
3212 if( !GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO)) {
3213 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_POW2 |
3214 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL;
3215 }
3216
3217 if( GL_SUPPORT(EXT_TEXTURE3D)) {
3218 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP |
3219 WINED3DPTEXTURECAPS_MIPVOLUMEMAP |
3220 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
3221 }
3222
3223 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
3224 pCaps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP |
3225 WINED3DPTEXTURECAPS_MIPCUBEMAP |
3226 WINED3DPTEXTURECAPS_CUBEMAP_POW2;
3227
3228 }
3229
3230 pCaps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
3231 WINED3DPTFILTERCAPS_MAGFPOINT |
3232 WINED3DPTFILTERCAPS_MINFLINEAR |
3233 WINED3DPTFILTERCAPS_MINFPOINT |
3234 WINED3DPTFILTERCAPS_MIPFLINEAR |
3235 WINED3DPTFILTERCAPS_MIPFPOINT |
3236 WINED3DPTFILTERCAPS_LINEAR |
3237 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
3238 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3239 WINED3DPTFILTERCAPS_MIPLINEAR |
3240 WINED3DPTFILTERCAPS_MIPNEAREST |
3241 WINED3DPTFILTERCAPS_NEAREST;
3242
3243 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3244 pCaps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
3245 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
3246 }
3247
3248 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP)) {
3249 pCaps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
3250 WINED3DPTFILTERCAPS_MAGFPOINT |
3251 WINED3DPTFILTERCAPS_MINFLINEAR |
3252 WINED3DPTFILTERCAPS_MINFPOINT |
3253 WINED3DPTFILTERCAPS_MIPFLINEAR |
3254 WINED3DPTFILTERCAPS_MIPFPOINT |
3255 WINED3DPTFILTERCAPS_LINEAR |
3256 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
3257 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3258 WINED3DPTFILTERCAPS_MIPLINEAR |
3259 WINED3DPTFILTERCAPS_MIPNEAREST |
3260 WINED3DPTFILTERCAPS_NEAREST;
3261
3262 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC)) {
3263 pCaps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC |
3264 WINED3DPTFILTERCAPS_MINFANISOTROPIC;
3265 }
3266 } else
3267 pCaps->CubeTextureFilterCaps = 0;
3268
3269 if (GL_SUPPORT(EXT_TEXTURE3D)) {
3270 pCaps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR |
3271 WINED3DPTFILTERCAPS_MAGFPOINT |
3272 WINED3DPTFILTERCAPS_MINFLINEAR |
3273 WINED3DPTFILTERCAPS_MINFPOINT |
3274 WINED3DPTFILTERCAPS_MIPFLINEAR |
3275 WINED3DPTFILTERCAPS_MIPFPOINT |
3276 WINED3DPTFILTERCAPS_LINEAR |
3277 WINED3DPTFILTERCAPS_LINEARMIPLINEAR |
3278 WINED3DPTFILTERCAPS_LINEARMIPNEAREST |
3279 WINED3DPTFILTERCAPS_MIPLINEAR |
3280 WINED3DPTFILTERCAPS_MIPNEAREST |
3281 WINED3DPTFILTERCAPS_NEAREST;
3282 } else
3283 pCaps->VolumeTextureFilterCaps = 0;
3284
3285 pCaps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
3286 WINED3DPTADDRESSCAPS_CLAMP |
3287 WINED3DPTADDRESSCAPS_WRAP;
3288
3289 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
3290 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
3291 }
3292 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
3293 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
3294 }
3295 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
3296 pCaps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
3297 }
3298
3299 if (GL_SUPPORT(EXT_TEXTURE3D)) {
3300 pCaps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV |
3301 WINED3DPTADDRESSCAPS_CLAMP |
3302 WINED3DPTADDRESSCAPS_WRAP;
3303 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP)) {
3304 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
3305 }
3306 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT)) {
3307 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
3308 }
3309 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE)) {
3310 pCaps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
3311 }
3312 } else
3313 pCaps->VolumeTextureAddressCaps = 0;
3314
3315 pCaps->LineCaps = WINED3DLINECAPS_TEXTURE |
3316 WINED3DLINECAPS_ZTEST |
3317 WINED3DLINECAPS_BLEND |
3318 WINED3DLINECAPS_ALPHACMP |
3319 WINED3DLINECAPS_FOG;
3320 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
3321 * idea how generating the smoothing alpha values works; the result is different
3322 */
3323
3324 pCaps->MaxTextureWidth = GL_LIMITS(texture_size);
3325 pCaps->MaxTextureHeight = GL_LIMITS(texture_size);
3326
3327 if(GL_SUPPORT(EXT_TEXTURE3D))
3328 pCaps->MaxVolumeExtent = GL_LIMITS(texture3d_size);
3329 else
3330 pCaps->MaxVolumeExtent = 0;
3331
3332 pCaps->MaxTextureRepeat = 32768;
3333 pCaps->MaxTextureAspectRatio = GL_LIMITS(texture_size);
3334 pCaps->MaxVertexW = 1.0;
3335
3336 pCaps->GuardBandLeft = 0;
3337 pCaps->GuardBandTop = 0;
3338 pCaps->GuardBandRight = 0;
3339 pCaps->GuardBandBottom = 0;
3340
3341 pCaps->ExtentsAdjust = 0;
3342
3343 pCaps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT |
3344 WINED3DSTENCILCAPS_INCRSAT |
3345 WINED3DSTENCILCAPS_INVERT |
3346 WINED3DSTENCILCAPS_KEEP |
3347 WINED3DSTENCILCAPS_REPLACE |
3348 WINED3DSTENCILCAPS_ZERO;
3349 if (GL_SUPPORT(EXT_STENCIL_WRAP)) {
3350 pCaps->StencilCaps |= WINED3DSTENCILCAPS_DECR |
3351 WINED3DSTENCILCAPS_INCR;
3352 }
3353 if ( This->dxVersion > 8 &&
3354 ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE) ||
3355 GL_SUPPORT(ATI_SEPARATE_STENCIL) ) ) {
3356 pCaps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
3357 }
3358
3359 pCaps->FVFCaps = WINED3DFVFCAPS_PSIZE | 0x0008; /* 8 texture coords */
3360
3361 pCaps->MaxUserClipPlanes = GL_LIMITS(clipplanes);
3362 pCaps->MaxActiveLights = GL_LIMITS(lights);
3363
3364 pCaps->MaxVertexBlendMatrices = GL_LIMITS(blends);
3365 pCaps->MaxVertexBlendMatrixIndex = 0;
3366
3367 pCaps->MaxAnisotropy = GL_LIMITS(anisotropy);
3368 pCaps->MaxPointSize = GL_LIMITS(pointsize);
3369
3370
3371 pCaps->VertexProcessingCaps = WINED3DVTXPCAPS_DIRECTIONALLIGHTS |
3372 WINED3DVTXPCAPS_MATERIALSOURCE7 |
3373 WINED3DVTXPCAPS_POSITIONALLIGHTS |
3374 WINED3DVTXPCAPS_LOCALVIEWER |
3375 WINED3DVTXPCAPS_VERTEXFOG |
3376 WINED3DVTXPCAPS_TEXGEN;
3377 /* FIXME: Add
3378 D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
3379
3380 pCaps->MaxPrimitiveCount = 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
3381 pCaps->MaxVertexIndex = 0xFFFFF;
3382 pCaps->MaxStreams = MAX_STREAMS;
3383 pCaps->MaxStreamStride = 1024;
3384
3385 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
3386 pCaps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET |
3387 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET;
3388 pCaps->MaxNpatchTessellationLevel = 0;
3389 pCaps->MasterAdapterOrdinal = 0;
3390 pCaps->AdapterOrdinalInGroup = 0;
3391 pCaps->NumberOfAdaptersInGroup = 1;
3392
3393 pCaps->NumSimultaneousRTs = GL_LIMITS(buffers);
3394
3395 pCaps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT |
3396 WINED3DPTFILTERCAPS_MAGFPOINT |
3397 WINED3DPTFILTERCAPS_MINFLINEAR |
3398 WINED3DPTFILTERCAPS_MAGFLINEAR;
3399 pCaps->VertexTextureFilterCaps = 0;
3400
3401 memset(&shader_caps, 0, sizeof(shader_caps));
3402 shader_backend = select_shader_backend(Adapter, DeviceType);
3403 shader_backend->shader_get_caps(DeviceType, &GLINFO_LOCATION, &shader_caps);
3404
3405 memset(&fragment_caps, 0, sizeof(fragment_caps));
3406 frag_pipeline = select_fragment_implementation(Adapter, DeviceType);
3407 frag_pipeline->get_caps(DeviceType, &GLINFO_LOCATION, &fragment_caps);
3408
3409 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
3410 pCaps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps;
3411
3412 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
3413 * Ignore shader model capabilities if disabled in config
3414 */
3415 if(vs_selected_mode == SHADER_NONE) {
3416 TRACE_(d3d_caps)("Vertex shader disabled in config, reporting version 0.0\n");
3417 pCaps->VertexShaderVersion = WINED3DVS_VERSION(0,0);
3418 pCaps->MaxVertexShaderConst = 0;
3419 } else {
3420 pCaps->VertexShaderVersion = shader_caps.VertexShaderVersion;
3421 pCaps->MaxVertexShaderConst = shader_caps.MaxVertexShaderConst;
3422 }
3423
3424 if(ps_selected_mode == SHADER_NONE) {
3425 TRACE_(d3d_caps)("Pixel shader disabled in config, reporting version 0.0\n");
3426 pCaps->PixelShaderVersion = WINED3DPS_VERSION(0,0);
3427 pCaps->PixelShader1xMaxValue = 0.0;
3428 } else {
3429 pCaps->PixelShaderVersion = shader_caps.PixelShaderVersion;
3430 pCaps->PixelShader1xMaxValue = shader_caps.PixelShader1xMaxValue;
3431 }
3432
3433 pCaps->TextureOpCaps = fragment_caps.TextureOpCaps;
3434 pCaps->MaxTextureBlendStages = fragment_caps.MaxTextureBlendStages;
3435 pCaps->MaxSimultaneousTextures = fragment_caps.MaxSimultaneousTextures;
3436
3437 pCaps->VS20Caps = shader_caps.VS20Caps;
3438 pCaps->MaxVShaderInstructionsExecuted = shader_caps.MaxVShaderInstructionsExecuted;
3439 pCaps->MaxVertexShader30InstructionSlots= shader_caps.MaxVertexShader30InstructionSlots;
3440 pCaps->PS20Caps = shader_caps.PS20Caps;
3441 pCaps->MaxPShaderInstructionsExecuted = shader_caps.MaxPShaderInstructionsExecuted;
3442 pCaps->MaxPixelShader30InstructionSlots = shader_caps.MaxPixelShader30InstructionSlots;
3443
3444 /* The following caps are shader specific, but they are things we cannot detect, or which
3445 * are the same among all shader models. So to avoid code duplication set the shader version
3446 * specific, but otherwise constant caps here
3447 */
3448 if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(3,0)) {
3449 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3450 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
3451 pCaps->VS20Caps.Caps = WINED3DVS20CAPS_PREDICATION;
3452 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3453 pCaps->VS20Caps.NumTemps = max(32, GLINFO_LOCATION.vs_arb_max_temps);
3454 pCaps->VS20Caps.StaticFlowControlDepth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH ; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
3455
3456 pCaps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
3457 pCaps->MaxVertexShader30InstructionSlots = max(512, GLINFO_LOCATION.vs_arb_max_instructions);
3458 } else if(pCaps->VertexShaderVersion == WINED3DVS_VERSION(2,0)) {
3459 pCaps->VS20Caps.Caps = 0;
3460 pCaps->VS20Caps.DynamicFlowControlDepth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH;
3461 pCaps->VS20Caps.NumTemps = max(12, GLINFO_LOCATION.vs_arb_max_temps);
3462 pCaps->VS20Caps.StaticFlowControlDepth = 1;
3463
3464 pCaps->MaxVShaderInstructionsExecuted = 65535;
3465 pCaps->MaxVertexShader30InstructionSlots = 0;
3466 } else { /* VS 1.x */
3467 pCaps->VS20Caps.Caps = 0;
3468 pCaps->VS20Caps.DynamicFlowControlDepth = 0;
3469 pCaps->VS20Caps.NumTemps = 0;
3470 pCaps->VS20Caps.StaticFlowControlDepth = 0;
3471
3472 pCaps->MaxVShaderInstructionsExecuted = 0;
3473 pCaps->MaxVertexShader30InstructionSlots = 0;
3474 }
3475
3476 if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(3,0)) {
3477 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3478 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
3479
3480 /* 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 */
3481 pCaps->PS20Caps.Caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE |
3482 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS |
3483 WINED3DPS20CAPS_PREDICATION |
3484 WINED3DPS20CAPS_NODEPENDENTREADLIMIT |
3485 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT;
3486 pCaps->PS20Caps.DynamicFlowControlDepth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3487 pCaps->PS20Caps.NumTemps = max(32, GLINFO_LOCATION.ps_arb_max_temps);
3488 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
3489 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
3490
3491 pCaps->MaxPShaderInstructionsExecuted = 65535;
3492 pCaps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS, GLINFO_LOCATION.ps_arb_max_instructions);
3493 } else if(pCaps->PixelShaderVersion == WINED3DPS_VERSION(2,0)) {
3494 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
3495 pCaps->PS20Caps.Caps = 0;
3496 pCaps->PS20Caps.DynamicFlowControlDepth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
3497 pCaps->PS20Caps.NumTemps = max(12, GLINFO_LOCATION.ps_arb_max_temps);
3498 pCaps->PS20Caps.StaticFlowControlDepth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */
3499 pCaps->PS20Caps.NumInstructionSlots = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
3500
3501 pCaps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */
3502 pCaps->MaxPixelShader30InstructionSlots = 0;
3503 } else { /* PS 1.x */
3504 pCaps->PS20Caps.Caps = 0;
3505 pCaps->PS20Caps.DynamicFlowControlDepth = 0;
3506 pCaps->PS20Caps.NumTemps = 0;
3507 pCaps->PS20Caps.StaticFlowControlDepth = 0;
3508 pCaps->PS20Caps.NumInstructionSlots = 0;
3509
3510 pCaps->MaxPShaderInstructionsExecuted = 0;
3511 pCaps->MaxPixelShader30InstructionSlots = 0;
3512 }
3513
3514 if(pCaps->VertexShaderVersion >= WINED3DVS_VERSION(2,0)) {
3515 /* OpenGL supports all the formats below, perhaps not always
3516 * without conversion, but it supports them.
3517 * Further GLSL doesn't seem to have an official unsigned type so
3518 * don't advertise it yet as I'm not sure how we handle it.
3519 * We might need to add some clamping in the shader engine to
3520 * support it.
3521 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
3522 pCaps->DeclTypes = WINED3DDTCAPS_UBYTE4 |
3523 WINED3DDTCAPS_UBYTE4N |
3524 WINED3DDTCAPS_SHORT2N |
3525 WINED3DDTCAPS_SHORT4N;
3526 if (GL_SUPPORT(NV_HALF_FLOAT)) {
3527 pCaps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 |
3528 WINED3DDTCAPS_FLOAT16_4;
3529 }
3530 } else
3531 pCaps->DeclTypes = 0;
3532
3533 /* Set DirectDraw helper Caps */
3534 ckey_caps = WINEDDCKEYCAPS_DESTBLT |
3535 WINEDDCKEYCAPS_SRCBLT;
3536 fx_caps = WINEDDFXCAPS_BLTALPHA |
3537 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT |
3538 WINEDDFXCAPS_BLTMIRRORUPDOWN |
3539 WINEDDFXCAPS_BLTROTATION90 |
3540 WINEDDFXCAPS_BLTSHRINKX |
3541 WINEDDFXCAPS_BLTSHRINKXN |
3542 WINEDDFXCAPS_BLTSHRINKY |
3543 WINEDDFXCAPS_BLTSHRINKXN |
3544 WINEDDFXCAPS_BLTSTRETCHX |
3545 WINEDDFXCAPS_BLTSTRETCHXN |
3546 WINEDDFXCAPS_BLTSTRETCHY |
3547 WINEDDFXCAPS_BLTSTRETCHYN;
3548 blit_caps = WINEDDCAPS_BLT |
3549 WINEDDCAPS_BLTCOLORFILL |
3550 WINEDDCAPS_BLTDEPTHFILL |
3551 WINEDDCAPS_BLTSTRETCH |
3552 WINEDDCAPS_CANBLTSYSMEM |
3553 WINEDDCAPS_CANCLIP |
3554 WINEDDCAPS_CANCLIPSTRETCHED |
3555 WINEDDCAPS_COLORKEY |
3556 WINEDDCAPS_COLORKEYHWASSIST |
3557 WINEDDCAPS_ALIGNBOUNDARYSRC;
3558
3559 /* Fill the ddraw caps structure */
3560 pCaps->DirectDrawCaps.Caps = WINEDDCAPS_GDI |
3561 WINEDDCAPS_PALETTE |
3562 blit_caps;
3563 pCaps->DirectDrawCaps.Caps2 = WINEDDCAPS2_CERTIFIED |
3564 WINEDDCAPS2_NOPAGELOCKREQUIRED |
3565 WINEDDCAPS2_PRIMARYGAMMA |
3566 WINEDDCAPS2_WIDESURFACES |
3567 WINEDDCAPS2_CANRENDERWINDOWED;
3568 pCaps->DirectDrawCaps.SVBCaps = blit_caps;
3569 pCaps->DirectDrawCaps.SVBCKeyCaps = ckey_caps;
3570 pCaps->DirectDrawCaps.SVBFXCaps = fx_caps;
3571 pCaps->DirectDrawCaps.VSBCaps = blit_caps;
3572 pCaps->DirectDrawCaps.VSBCKeyCaps = ckey_caps;
3573 pCaps->DirectDrawCaps.VSBFXCaps = fx_caps;
3574 pCaps->DirectDrawCaps.SSBCaps = blit_caps;
3575 pCaps->DirectDrawCaps.SSBCKeyCaps = ckey_caps;
3576 pCaps->DirectDrawCaps.SSBFXCaps = fx_caps;
3577
3578 pCaps->DirectDrawCaps.ddsCaps = WINEDDSCAPS_ALPHA |
3579 WINEDDSCAPS_BACKBUFFER |
3580 WINEDDSCAPS_FLIP |
3581 WINEDDSCAPS_FRONTBUFFER |
3582 WINEDDSCAPS_OFFSCREENPLAIN |
3583 WINEDDSCAPS_PALETTE |
3584 WINEDDSCAPS_PRIMARYSURFACE |
3585 WINEDDSCAPS_SYSTEMMEMORY |
3586 WINEDDSCAPS_VIDEOMEMORY |
3587 WINEDDSCAPS_VISIBLE;
3588 pCaps->DirectDrawCaps.StrideAlign = DDRAW_PITCH_ALIGNMENT;
3589
3590 /* Set D3D caps if OpenGL is available. */
3591 if(Adapters[Adapter].opengl) {
3592 pCaps->DirectDrawCaps.ddsCaps |=WINEDDSCAPS_3DDEVICE |
3593 WINEDDSCAPS_MIPMAP |
3594 WINEDDSCAPS_TEXTURE |
3595 WINEDDSCAPS_ZBUFFER;
3596 pCaps->DirectDrawCaps.Caps |= WINEDDCAPS_3D;
3597 }
3598
3599 return WINED3D_OK;
3600 }
3601
3602 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
3603 and fields being inserted in the middle, a new structure is used in place */
3604 static HRESULT WINAPI IWineD3DImpl_CreateDevice(IWineD3D *iface, UINT Adapter, WINED3DDEVTYPE DeviceType, HWND hFocusWindow,
3605 DWORD BehaviourFlags, IWineD3DDevice** ppReturnedDeviceInterface,
3606 IUnknown *parent) {
3607
3608 IWineD3DDeviceImpl *object = NULL;
3609 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3610 WINED3DDISPLAYMODE mode;
3611 const struct fragment_pipeline *frag_pipeline = NULL;
3612 int i;
3613 struct fragment_caps ffp_caps;
3614
3615 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
3616 * number and create a device without a 3D adapter for 2D only operation.
3617 */
3618 if (IWineD3D_GetAdapterCount(iface) && Adapter >= IWineD3D_GetAdapterCount(iface)) {
3619 return WINED3DERR_INVALIDCALL;
3620 }
3621
3622 /* Create a WineD3DDevice object */
3623 object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IWineD3DDeviceImpl));
3624 *ppReturnedDeviceInterface = (IWineD3DDevice *)object;
3625 TRACE("Created WineD3DDevice object @ %p\n", object);
3626 if (NULL == object) {
3627 return WINED3DERR_OUTOFVIDEOMEMORY;
3628 }
3629
3630 /* Set up initial COM information */
3631 object->lpVtbl = &IWineD3DDevice_Vtbl;
3632 object->ref = 1;
3633 object->wineD3D = iface;
3634 object->adapter = numAdapters ? &Adapters[Adapter] : NULL;
3635 IWineD3D_AddRef(object->wineD3D);
3636 object->parent = parent;
3637 list_init(&object->resources);
3638 list_init(&object->shaders);
3639
3640 if(This->dxVersion == 7) {
3641 object->surface_alignment = DDRAW_PITCH_ALIGNMENT;
3642 } else {
3643 object->surface_alignment = D3D8_PITCH_ALIGNMENT;
3644 }
3645 object->posFixup[0] = 1.0; /* This is needed to get the x coord unmodified through a MAD */
3646
3647 /* Set the state up as invalid until the device is fully created */
3648 object->state = WINED3DERR_DRIVERINTERNALERROR;
3649
3650 TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This, Adapter, DeviceType,
3651 hFocusWindow, BehaviourFlags, ppReturnedDeviceInterface);
3652
3653 /* Save the creation parameters */
3654 object->createParms.AdapterOrdinal = Adapter;
3655 object->createParms.DeviceType = DeviceType;
3656 object->createParms.hFocusWindow = hFocusWindow;
3657 object->createParms.BehaviorFlags = BehaviourFlags;
3658
3659 /* Initialize other useful values */
3660 object->adapterNo = Adapter;
3661 object->devType = DeviceType;
3662
3663 select_shader_mode(&GLINFO_LOCATION, DeviceType, &object->ps_selected_mode, &object->vs_selected_mode);
3664 object->shader_backend = select_shader_backend(Adapter, DeviceType);
3665
3666 memset(&ffp_caps, 0, sizeof(ffp_caps));
3667 frag_pipeline = select_fragment_implementation(Adapter, DeviceType);
3668 object->frag_pipe = frag_pipeline;
3669 frag_pipeline->get_caps(DeviceType, &GLINFO_LOCATION, &ffp_caps);
3670 object->max_ffp_textures = ffp_caps.MaxSimultaneousTextures;
3671 object->max_ffp_texture_stages = ffp_caps.MaxTextureBlendStages;
3672 compile_state_table(object->StateTable, object->multistate_funcs, &GLINFO_LOCATION,
3673 ffp_vertexstate_template, frag_pipeline, misc_state_template);
3674
3675 object->blitter = select_blit_implementation(Adapter, DeviceType);
3676
3677 /* Prefer the vtable with functions optimized for single dirtifyable objects if the shader
3678 * model can deal with that. It is essentially the same, just with adjusted
3679 * Set*ShaderConstantF implementations
3680 */
3681 if(object->shader_backend->shader_dirtifyable_constants((IWineD3DDevice *) object)) {
3682 object->lpVtbl = &IWineD3DDevice_DirtyConst_Vtbl;
3683 }
3684
3685 /* set the state of the device to valid */
3686 object->state = WINED3D_OK;
3687
3688 /* Get the initial screen setup for ddraw */
3689 IWineD3DImpl_GetAdapterDisplayMode(iface, Adapter, &mode);
3690
3691 object->ddraw_width = mode.Width;
3692 object->ddraw_height = mode.Height;
3693 object->ddraw_format = mode.Format;
3694
3695 for(i = 0; i < PATCHMAP_SIZE; i++) {
3696 list_init(&object->patches[i]);
3697 }
3698 return WINED3D_OK;
3699 }
3700 #undef GLINFO_LOCATION
3701
3702 static HRESULT WINAPI IWineD3DImpl_GetParent(IWineD3D *iface, IUnknown **pParent) {
3703 IWineD3DImpl *This = (IWineD3DImpl *)iface;
3704 IUnknown_AddRef(This->parent);
3705 *pParent = This->parent;
3706 return WINED3D_OK;
3707 }
3708
3709 ULONG WINAPI D3DCB_DefaultDestroySurface(IWineD3DSurface *pSurface) {
3710 IUnknown* surfaceParent;
3711 TRACE("(%p) call back\n", pSurface);
3712
3713 /* Now, release the parent, which will take care of cleaning up the surface for us */
3714 IWineD3DSurface_GetParent(pSurface, &surfaceParent);
3715 IUnknown_Release(surfaceParent);
3716 return IUnknown_Release(surfaceParent);
3717 }
3718
3719 ULONG WINAPI D3DCB_DefaultDestroyVolume(IWineD3DVolume *pVolume) {
3720 IUnknown* volumeParent;
3721 TRACE("(%p) call back\n", pVolume);
3722
3723 /* Now, release the parent, which will take care of cleaning up the volume for us */
3724 IWineD3DVolume_GetParent(pVolume, &volumeParent);
3725 IUnknown_Release(volumeParent);
3726 return IUnknown_Release(volumeParent);
3727 }
3728
3729 static BOOL implementation_is_apple(WineD3D_GL_Info *gl_info) {
3730 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
3731 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
3732 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
3733 *
3734 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
3735 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
3736 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
3737 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
3738 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
3739 * the chance that other implementations support them is rather small since Win32 QuickTime uses
3740 * DirectDraw, not OpenGL.
3741 */
3742 if(gl_info->supported[APPLE_FENCE] &&
3743 gl_info->supported[APPLE_CLIENT_STORAGE] &&
3744 gl_info->supported[APPLE_FLUSH_RENDER] &&
3745 gl_info->supported[APPLE_YCBCR_422]) {
3746 TRACE_(d3d_caps)("GL_APPLE_fence, GL_APPLE_client_storage, GL_APPLE_flush_render and GL_ycbcr_422 are supported\n");
3747 TRACE_(d3d_caps)("Activating MacOS fixups\n");
3748 return TRUE;
3749 } else {
3750 TRACE_(d3d_caps)("Apple extensions are not supported\n");
3751 TRACE_(d3d_caps)("Not activating MacOS fixups\n");
3752 return FALSE;
3753 }
3754 }
3755
3756 #define GLINFO_LOCATION (*gl_info)
3757 static void test_pbo_functionality(WineD3D_GL_Info *gl_info) {
3758 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
3759 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
3760 * all the texture. This function detects this bug by its symptom and disables PBOs
3761 * if the test fails.
3762 *
3763 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
3764 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
3765 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
3766 * read back is compared to the original. If they are equal PBOs are assumed to work,
3767 * otherwise the PBO extension is disabled.
3768 */
3769 GLuint texture, pbo;
3770 static const unsigned int pattern[] = {
3771 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
3772 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
3773 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
3774 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
3775 };
3776 unsigned int check[sizeof(pattern) / sizeof(pattern[0])];
3777
3778 if(!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) {
3779 /* No PBO -> No point in testing them */
3780 return;
3781 }
3782
3783 while(glGetError());
3784 glGenTextures(1, &texture);
3785 glBindTexture(GL_TEXTURE_2D, texture);
3786 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
3787 checkGLcall("Specifying the PBO test texture\n");
3788
3789 GL_EXTCALL(glGenBuffersARB(1, &pbo));
3790 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbo));
3791 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, sizeof(pattern), pattern, GL_STREAM_DRAW_ARB));
3792 checkGLcall("Specifying the PBO test pbo\n");
3793
3794 glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL);
3795 checkGLcall("Loading the PBO test texture\n");
3796
3797 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0));
3798 glFinish(); /* just to be sure */
3799
3800 memset(check, 0, sizeof(check));
3801 glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
3802 checkGLcall("Reading back the PBO test texture\n");
3803
3804 glDeleteTextures(1, &texture);
3805 GL_EXTCALL(glDeleteBuffersARB(1, &pbo));
3806 checkGLcall("PBO test cleanup\n");
3807
3808 if(memcmp(check, pattern, sizeof(check)) != 0) {
3809 WARN_(d3d_caps)("PBO test failed, read back data doesn't match original\n");
3810 WARN_(d3d_caps)("Disabling PBOs. This may result in slower performance\n");
3811 gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
3812 } else {
3813 TRACE_(d3d_caps)("PBO test successful\n");
3814 }
3815 }
3816 #undef GLINFO_LOCATION
3817
3818 /* Certain applications(Steam) complain if we report an outdated driver version. In general,
3819 * reporting a driver version is moot because we are not the Windows driver, and we have different
3820 * bugs, features, etc.
3821 *
3822 * If a card is not found in this table, the gl driver version is reported
3823 */
3824 struct driver_version_information {
3825 WORD vendor; /* reported PCI card vendor ID */
3826 WORD card; /* reported PCI card device ID */
3827 WORD hipart_hi, hipart_lo; /* driver hiword to report */
3828 WORD lopart_hi, lopart_lo; /* driver loword to report */
3829 };
3830
3831 static const struct driver_version_information driver_version_table[] = {
3832 /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (177.x)*/
3833 /* GeforceFX support is up to 173.x, Geforce2MX/3/4 up to 96.x, TNT/Geforce1/2 up to 71.x */
3834 /* Note that version numbers >100 lets say 123.45 use >= x.y.11.2345 and not x.y.10.12345 */
3835 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, 7, 15, 11, 7341 },
3836 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, 7, 15, 11, 7341 },
3837 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, 7, 15, 11, 7341 },
3838 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, 7, 15, 11, 7341 },
3839 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, 7, 15, 11, 7341 },
3840 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, 7, 15, 11, 7341 },
3841 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, 7, 15, 11, 7341 },
3842 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, 7, 15, 11, 7341 },
3843 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, 7, 15, 11, 7341 },
3844 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, 7, 15, 11, 7341 },
3845 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, 7, 15, 11, 7341 },
3846 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, 7, 15, 11, 7341 },
3847 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, 7, 15, 11, 7341 },
3848 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, 7, 15, 11, 7341 },
3849 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, 7, 15, 11, 7341 },
3850 {VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, 7, 15, 11, 7341 },
3851
3852 /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode */
3853 {VENDOR_ATI, CARD_ATI_RADEON_9500, 6, 14, 10, 6764 },
3854 {VENDOR_ATI, CARD_ATI_RADEON_X700, 6, 14, 10, 6764 },
3855 {VENDOR_ATI, CARD_ATI_RADEON_X1600, 6, 14, 10, 6764 },
3856 {VENDOR_ATI, CARD_ATI_RADEON_HD2300, 6, 14, 10, 6764 },
3857 {VENDOR_ATI, CARD_ATI_RADEON_HD2600, 6, 14, 10, 6764 },
3858 {VENDOR_ATI, CARD_ATI_RADEON_HD2900, 6, 14, 10, 6764 },
3859
3860 /* TODO: Add information about legacy nvidia and ATI hardware, Intel and other cards */
3861 };
3862
3863 static void fixup_extensions(WineD3D_GL_Info *gl_info) {
3864 unsigned int i;
3865 BOOL apple = implementation_is_apple(gl_info);
3866
3867 if(apple) {
3868 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
3869 * used it falls back to software. While the compiler can detect if the shader uses all declared
3870 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
3871 * using relative addressing falls back to software.
3872 *
3873 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL
3874 */
3875 if(gl_info->vs_glsl_constantsF <= gl_info->vs_arb_constantsF) {
3876 FIXME("GLSL doesn't advertise more vertex shader uniforms than ARB. Driver fixup outdated?\n");
3877 } else {
3878 TRACE("Driver claims %u GLSL vs uniforms, replacing with %u ARB vp uniforms\n",
3879 gl_info->vs_glsl_constantsF, gl_info->vs_arb_constantsF);
3880 gl_info->vs_glsl_constantsF = gl_info->vs_arb_constantsF;
3881 }
3882
3883 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
3884 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
3885 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
3886 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
3887 * according to the spec.
3888 *
3889 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
3890 * makes the shader slower and eats instruction slots which should be available to the d3d app.
3891 *
3892 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
3893 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
3894 * this workaround is activated on cards that do not need it, it won't break things, just affect
3895 * performance negatively.
3896 */
3897 if(gl_info->gl_vendor == VENDOR_INTEL ||
3898 (gl_info->gl_vendor == VENDOR_ATI && gl_info->gl_card != CARD_ATI_RADEON_X1600)) {
3899 TRACE("Enabling vertex texture coord fixes in vertex shaders\n");
3900 gl_info->set_texcoord_w = TRUE;
3901 }
3902 }
3903
3904 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
3905 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
3906 * If real NP2 textures are used, the driver falls back to software. We could just remove the
3907 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
3908 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
3909 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
3910 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
3911 *
3912 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
3913 * has this extension promoted to core. The extension loading code sets this extension supported
3914 * due to that, so this code works on fglrx as well.
3915 */
3916 if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] && gl_info->gl_vendor == VENDOR_ATI) {
3917 if(gl_info->gl_card == CARD_ATI_RADEON_X700 || gl_info->gl_card == CARD_ATI_RADEON_X1600 ||
3918 gl_info->gl_card == CARD_ATI_RADEON_9500 || gl_info->gl_card == CARD_ATI_RADEON_8500 ||
3919 gl_info->gl_card == CARD_ATI_RADEON_7200 || gl_info->gl_card == CARD_ATI_RAGE_128PRO) {
3920 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing\n");
3921 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
3922 gl_info->supported[WINE_NORMALIZED_TEXRECT] = TRUE;
3923 }
3924 }
3925
3926 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
3927 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
3928 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
3929 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
3930 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
3931 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
3932 *
3933 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
3934 * triggering the software fallback. There is not much we can do here apart from disabling the
3935 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
3936 * in IWineD3DImpl_FillGLCaps).
3937 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
3938 * post-processing effects in the game "Max Payne 2").
3939 * The behaviour can be verified through a simple test app attached in bugreport #14724.
3940 */
3941 if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] && gl_info->gl_vendor == VENDOR_NVIDIA) {
3942 if(gl_info->gl_card == CARD_NVIDIA_GEFORCEFX_5800 || gl_info->gl_card == CARD_NVIDIA_GEFORCEFX_5600) {
3943 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing\n");
3944 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
3945 gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
3946 }
3947 }
3948
3949 /* Find out if PBOs work as they are supposed to */
3950 test_pbo_functionality(gl_info);
3951
3952 /* Fixup the driver version */
3953 for(i = 0; i < (sizeof(driver_version_table) / sizeof(driver_version_table[0])); i++) {
3954 if(gl_info->gl_vendor == driver_version_table[i].vendor &&
3955 gl_info->gl_card == driver_version_table[i].card) {
3956 TRACE_(d3d_caps)("Found card 0x%04x, 0x%04x in driver version DB\n", gl_info->gl_vendor, gl_info->gl_card);
3957
3958 gl_info->driver_version = MAKEDWORD_VERSION(driver_version_table[i].lopart_hi,
3959 driver_version_table[i].lopart_lo);
3960 gl_info->driver_version_hipart = MAKEDWORD_VERSION(driver_version_table[i].hipart_hi,
3961 driver_version_table[i].hipart_lo);
3962 break;
3963 }
3964 }
3965 }
3966
3967 static void WINE_GLAPI invalid_func(void *data) {
3968 ERR("Invalid vertex attribute function called\n");
3969 DebugBreak();
3970 }
3971
3972 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, void * data) {
3973 ERR("Invalid texcoord function called\n");
3974 DebugBreak();
3975 }
3976
3977 #define GLINFO_LOCATION (Adapters[0].gl_info)
3978
3979 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
3980 * the extension detection and are used in drawStridedSlow
3981 */
3982 static void WINE_GLAPI position_d3dcolor(void *data) {
3983 DWORD pos = *((DWORD *) data);
3984
3985 FIXME("Add a test for fixed function position from d3dcolor type\n");
3986 glVertex4s(D3DCOLOR_B_R(pos),
3987 D3DCOLOR_B_G(pos),
3988 D3DCOLOR_B_B(pos),
3989 D3DCOLOR_B_A(pos));
3990 }
3991 static void WINE_GLAPI position_float4(void *data) {
3992 GLfloat *pos = (float *) data;
3993
3994 if (pos[3] < eps && pos[3] > -eps)
3995 glVertex3fv(pos);
3996 else {
3997 float w = 1.0 / pos[3];
3998
3999 glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
4000 }
4001 }
4002
4003 static void WINE_GLAPI diffuse_d3dcolor(void *data) {
4004 DWORD diffuseColor = *((DWORD *) data);
4005
4006 glColor4ub(D3DCOLOR_B_R(diffuseColor),
4007 D3DCOLOR_B_G(diffuseColor),
4008 D3DCOLOR_B_B(diffuseColor),
4009 D3DCOLOR_B_A(diffuseColor));
4010 }
4011
4012 static void WINE_GLAPI specular_d3dcolor(void *data) {
4013 DWORD specularColor = *((DWORD *) data);
4014
4015 GL_EXTCALL(glSecondaryColor3ubEXT)(D3DCOLOR_B_R(specularColor),
4016 D3DCOLOR_B_G(specularColor),
4017 D3DCOLOR_B_B(specularColor));
4018 }
4019 static void WINE_GLAPI warn_no_specular_func(void *data) {
4020 WARN("GL_EXT_secondary_color not supported\n");
4021 }
4022
4023 void fillGLAttribFuncs(WineD3D_GL_Info *gl_info) {
4024 position_funcs[WINED3DDECLTYPE_FLOAT1] = (void *) invalid_func;
4025 position_funcs[WINED3DDECLTYPE_FLOAT2] = (void *) invalid_func;
4026 position_funcs[WINED3DDECLTYPE_FLOAT3] = (void *) glVertex3fv;
4027 position_funcs[WINED3DDECLTYPE_FLOAT4] = (void *) position_float4;
4028 position_funcs[WINED3DDECLTYPE_D3DCOLOR] = (void *) position_d3dcolor;
4029 position_funcs[WINED3DDECLTYPE_UBYTE4] = (void *) invalid_func;
4030 position_funcs[WINED3DDECLTYPE_SHORT2] = (void *) invalid_func;
4031 position_funcs[WINED3DDECLTYPE_SHORT4] = (void *) glVertex2sv;
4032 position_funcs[WINED3DDECLTYPE_UBYTE4N] = (void *) invalid_func;
4033 position_funcs[WINED3DDECLTYPE_SHORT2N] = (void *) invalid_func;
4034 position_funcs[WINED3DDECLTYPE_SHORT4N] = (void *) invalid_func;
4035 position_funcs[WINED3DDECLTYPE_USHORT2N] = (void *) invalid_func;
4036 position_funcs[WINED3DDECLTYPE_USHORT4N] = (void *) invalid_func;
4037 position_funcs[WINED3DDECLTYPE_UDEC3] = (void *) invalid_func;
4038 position_funcs[WINED3DDECLTYPE_DEC3N] = (void *) invalid_func;
4039 position_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) invalid_func;
4040 position_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) invalid_func;
4041
4042 diffuse_funcs[WINED3DDECLTYPE_FLOAT1] = (void *) invalid_func;
4043 diffuse_funcs[WINED3DDECLTYPE_FLOAT2] = (void *) invalid_func;
4044 diffuse_funcs[WINED3DDECLTYPE_FLOAT3] = (void *) glColor3fv;
4045 diffuse_funcs[WINED3DDECLTYPE_FLOAT4] = (void *) glColor4fv;
4046 diffuse_funcs[WINED3DDECLTYPE_D3DCOLOR] = (void *) diffuse_d3dcolor;
4047 diffuse_funcs[WINED3DDECLTYPE_UBYTE4] = (void *) invalid_func;
4048 diffuse_funcs[WINED3DDECLTYPE_SHORT2] = (void *) invalid_func;
4049 diffuse_funcs[WINED3DDECLTYPE_SHORT4] = (void *) invalid_func;
4050 diffuse_funcs[WINED3DDECLTYPE_UBYTE4N] = (void *) glColor4ubv;
4051 diffuse_funcs[WINED3DDECLTYPE_SHORT2N] = (void *) invalid_func;
4052 diffuse_funcs[WINED3DDECLTYPE_SHORT4N] = (void *) glColor4sv;
4053 diffuse_funcs[WINED3DDECLTYPE_USHORT2N] = (void *) invalid_func;
4054 diffuse_funcs[WINED3DDECLTYPE_USHORT4N] = (void *) glColor4usv;
4055 diffuse_funcs[WINED3DDECLTYPE_UDEC3] = (void *) invalid_func;
4056 diffuse_funcs[WINED3DDECLTYPE_DEC3N] = (void *) invalid_func;
4057 diffuse_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) invalid_func;
4058 diffuse_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) invalid_func;
4059
4060 /* No 4 component entry points here */
4061 specular_funcs[WINED3DDECLTYPE_FLOAT1] = (void *) invalid_func;
4062 specular_funcs[WINED3DDECLTYPE_FLOAT2] = (void *) invalid_func;
4063 if(GL_SUPPORT(EXT_SECONDARY_COLOR)) {
4064 specular_funcs[WINED3DDECLTYPE_FLOAT3] = (void *) GL_EXTCALL(glSecondaryColor3fvEXT);
4065 } else {
4066 specular_funcs[WINED3DDECLTYPE_FLOAT3] = (void *) warn_no_specular_func;
4067 }
4068 specular_funcs[WINED3DDECLTYPE_FLOAT4] = (void *) invalid_func;
4069 if(GL_SUPPORT(EXT_SECONDARY_COLOR)) {
4070 specular_funcs[WINED3DDECLTYPE_D3DCOLOR] = (void *) specular_d3dcolor;
4071 } else {
4072 specular_funcs[WINED3DDECLTYPE_D3DCOLOR] = (void *) warn_no_specular_func;
4073 }
4074 specular_funcs[WINED3DDECLTYPE_UBYTE4] = (void *) invalid_func;
4075 specular_funcs[WINED3DDECLTYPE_SHORT2] = (void *) invalid_func;
4076 specular_funcs[WINED3DDECLTYPE_SHORT4] = (void *) invalid_func;
4077 specular_funcs[WINED3DDECLTYPE_UBYTE4N] = (void *) invalid_func;
4078 specular_funcs[WINED3DDECLTYPE_SHORT2N] = (void *) invalid_func;
4079 specular_funcs[WINED3DDECLTYPE_SHORT4N] = (void *) invalid_func;
4080 specular_funcs[WINED3DDECLTYPE_USHORT2N] = (void *) invalid_func;
4081 specular_funcs[WINED3DDECLTYPE_USHORT4N] = (void *) invalid_func;
4082 specular_funcs[WINED3DDECLTYPE_UDEC3] = (void *) invalid_func;
4083 specular_funcs[WINED3DDECLTYPE_DEC3N] = (void *) invalid_func;
4084 specular_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) invalid_func;
4085 specular_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) invalid_func;
4086
4087 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4088 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4089 */
4090 normal_funcs[WINED3DDECLTYPE_FLOAT1] = (void *) invalid_func;
4091 normal_funcs[WINED3DDECLTYPE_FLOAT2] = (void *) invalid_func;
4092 normal_funcs[WINED3DDECLTYPE_FLOAT3] = (void *) glNormal3fv;
4093 normal_funcs[WINED3DDECLTYPE_FLOAT4] = (void *) glNormal3fv; /* Just ignore the 4th value */
4094 normal_funcs[WINED3DDECLTYPE_D3DCOLOR] = (void *) invalid_func;
4095 normal_funcs[WINED3DDECLTYPE_UBYTE4] = (void *) invalid_func;
4096 normal_funcs[WINED3DDECLTYPE_SHORT2] = (void *) invalid_func;
4097 normal_funcs[WINED3DDECLTYPE_SHORT4] = (void *) invalid_func;
4098 normal_funcs[WINED3DDECLTYPE_UBYTE4N] = (void *) invalid_func;
4099 normal_funcs[WINED3DDECLTYPE_SHORT2N] = (void *) invalid_func;
4100 normal_funcs[WINED3DDECLTYPE_SHORT4N] = (void *) invalid_func;
4101 normal_funcs[WINED3DDECLTYPE_USHORT2N] = (void *) invalid_func;
4102 normal_funcs[WINED3DDECLTYPE_USHORT4N] = (void *) invalid_func;
4103 normal_funcs[WINED3DDECLTYPE_UDEC3] = (void *) invalid_func;
4104 normal_funcs[WINED3DDECLTYPE_DEC3N] = (void *) invalid_func;
4105 normal_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) invalid_func;
4106 normal_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) invalid_func;
4107
4108 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT1] = (void *) GL_EXTCALL(glMultiTexCoord1fvARB);
4109 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT2] = (void *) GL_EXTCALL(glMultiTexCoord2fvARB);
4110 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT3] = (void *) GL_EXTCALL(glMultiTexCoord3fvARB);
4111 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT4] = (void *) GL_EXTCALL(glMultiTexCoord4fvARB);
4112 multi_texcoord_funcs[WINED3DDECLTYPE_D3DCOLOR] = (void *) invalid_texcoord_func;
4113 multi_texcoord_funcs[WINED3DDECLTYPE_UBYTE4] = (void *) invalid_texcoord_func;
4114 multi_texcoord_funcs[WINED3DDECLTYPE_SHORT2] = (void *) GL_EXTCALL(glMultiTexCoord2svARB);
4115 multi_texcoord_funcs[WINED3DDECLTYPE_SHORT4] = (void *) GL_EXTCALL(glMultiTexCoord4svARB);
4116 multi_texcoord_funcs[WINED3DDECLTYPE_UBYTE4N] = (void *) invalid_texcoord_func;
4117 multi_texcoord_funcs[WINED3DDECLTYPE_SHORT2N] = (void *) invalid_texcoord_func;
4118 multi_texcoord_funcs[WINED3DDECLTYPE_SHORT4N] = (void *) invalid_texcoord_func;
4119 multi_texcoord_funcs[WINED3DDECLTYPE_USHORT2N] = (void *) invalid_texcoord_func;
4120 multi_texcoord_funcs[WINED3DDECLTYPE_USHORT4N] = (void *) invalid_texcoord_func;
4121 multi_texcoord_funcs[WINED3DDECLTYPE_UDEC3] = (void *) invalid_texcoord_func;
4122 multi_texcoord_funcs[WINED3DDECLTYPE_DEC3N] = (void *) invalid_texcoord_func;
4123 if (GL_SUPPORT(NV_HALF_FLOAT))
4124 {
4125 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) GL_EXTCALL(glMultiTexCoord2hvNV);
4126 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) GL_EXTCALL(glMultiTexCoord4hvNV);
4127 } else {
4128 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) invalid_texcoord_func;
4129 multi_texcoord_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) invalid_texcoord_func;
4130 }
4131
4132 texcoord_funcs[WINED3DDECLTYPE_FLOAT1] = (void *) glTexCoord1fv;
4133 texcoord_funcs[WINED3DDECLTYPE_FLOAT2] = (void *) glTexCoord2fv;
4134 texcoord_funcs[WINED3DDECLTYPE_FLOAT3] = (void *) glTexCoord3fv;
4135 texcoord_funcs[WINED3DDECLTYPE_FLOAT4] = (void *) glTexCoord4fv;
4136 texcoord_funcs[WINED3DDECLTYPE_D3DCOLOR] = (void *) invalid_func;
4137 texcoord_funcs[WINED3DDECLTYPE_UBYTE4] = (void *) invalid_func;
4138 texcoord_funcs[WINED3DDECLTYPE_SHORT2] = (void *) glTexCoord2sv;
4139 texcoord_funcs[WINED3DDECLTYPE_SHORT4] = (void *) glTexCoord4sv;
4140 texcoord_funcs[WINED3DDECLTYPE_UBYTE4N] = (void *) invalid_func;
4141 texcoord_funcs[WINED3DDECLTYPE_SHORT2N] = (void *) invalid_func;
4142 texcoord_funcs[WINED3DDECLTYPE_SHORT4N] = (void *) invalid_func;
4143 texcoord_funcs[WINED3DDECLTYPE_USHORT2N] = (void *) invalid_func;
4144 texcoord_funcs[WINED3DDECLTYPE_USHORT4N] = (void *) invalid_func;
4145 texcoord_funcs[WINED3DDECLTYPE_UDEC3] = (void *) invalid_func;
4146 texcoord_funcs[WINED3DDECLTYPE_DEC3N] = (void *) invalid_func;
4147 if (GL_SUPPORT(NV_HALF_FLOAT))
4148 {
4149 texcoord_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) GL_EXTCALL(glTexCoord2hvNV);
4150 texcoord_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) GL_EXTCALL(glTexCoord4hvNV);
4151 } else {
4152 texcoord_funcs[WINED3DDECLTYPE_FLOAT16_2] = (void *) invalid_func;
4153 texcoord_funcs[WINED3DDECLTYPE_FLOAT16_4] = (void *) invalid_func;
4154 }
4155 }
4156
4157 #define PUSH1(att) attribs[nAttribs++] = (att);
4158 BOOL InitAdapters(void) {
4159 static HMODULE mod_gl, mod_win32gl;
4160 BOOL ret;
4161 int ps_selected_mode, vs_selected_mode;
4162
4163 /* No need to hold any lock. The calling library makes sure only one thread calls
4164 * wined3d simultaneously
4165 */
4166 if(numAdapters > 0) return Adapters[0].opengl;
4167
4168 TRACE("Initializing adapters\n");
4169
4170 if(!mod_gl) {
4171 #ifdef USE_WIN32_OPENGL
4172 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
4173 mod_gl = LoadLibraryA("opengl32.dll");
4174 if(!mod_gl) {
4175 ERR("Can't load opengl32.dll!\n");
4176 goto nogl_adapter;
4177 }
4178 mod_win32gl = mod_gl;
4179 #else
4180 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
4181 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
4182 mod_gl = GetModuleHandleA("gdi32.dll");
4183 mod_win32gl = LoadLibraryA("opengl32.dll");
4184 if(!mod_win32gl) {
4185 ERR("Can't load opengl32.dll!\n");
4186 goto nogl_adapter;
4187 }
4188 #endif
4189 }
4190
4191 /* Load WGL core functions from opengl32.dll */
4192 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
4193 WGL_FUNCS_GEN;
4194 #undef USE_WGL_FUNC
4195
4196 if(!pwglGetProcAddress) {
4197 ERR("Unable to load wglGetProcAddress!\n");
4198 goto nogl_adapter;
4199 }
4200
4201 /* Dynamically load all GL core functions */
4202 GL_FUNCS_GEN;
4203 #undef USE_GL_FUNC
4204
4205 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
4206 * otherwise because we have to use winex11.drv's override
4207 */
4208 glFinish = (void*)GetProcAddress(mod_win32gl, "glFinish");
4209 glFlush = (void*)GetProcAddress(mod_win32gl, "glFlush");
4210
4211 /* For now only one default adapter */
4212 {
4213 int iPixelFormat;
4214 int attribs[10];
4215 int values[10];
4216 int nAttribs = 0;
4217 int res;
4218 int i;
4219 WineD3D_PixelFormat *cfgs;
4220 int attribute;
4221 DISPLAY_DEVICEW DisplayDevice;
4222 HDC hdc;
4223
4224 TRACE("Initializing default adapter\n");
4225 Adapters[0].num = 0;
4226 Adapters[0].monitorPoint.x = -1;
4227 Adapters[0].monitorPoint.y = -1;
4228
4229 if (!WineD3D_CreateFakeGLContext()) {
4230 ERR("Failed to get a gl context for default adapter\n");
4231 WineD3D_ReleaseFakeGLContext();
4232 goto nogl_adapter;
4233 }
4234
4235 ret = IWineD3DImpl_FillGLCaps(&Adapters[0].gl_info);
4236 if(!ret) {
4237 ERR("Failed to initialize gl caps for default adapter\n");
4238 WineD3D_ReleaseFakeGLContext();
4239 goto nogl_adapter;
4240 }
4241 ret = initPixelFormats(&Adapters[0].gl_info);
4242 if(!ret) {
4243 ERR("Failed to init gl formats\n");
4244 WineD3D_ReleaseFakeGLContext();
4245 goto nogl_adapter;
4246 }
4247
4248 hdc = pwglGetCurrentDC();
4249 if(!hdc) {
4250 ERR("Failed to get gl HDC\n");
4251 WineD3D_ReleaseFakeGLContext();
4252 goto nogl_adapter;
4253 }
4254
4255 Adapters[0].driver = "Display";
4256 Adapters[0].description = "Direct3D HAL";
4257
4258 /* Use the VideoRamSize registry setting when set */
4259 if(wined3d_settings.emulated_textureram)
4260 Adapters[0].TextureRam = wined3d_settings.emulated_textureram;
4261 else
4262 Adapters[0].TextureRam = Adapters[0].gl_info.vidmem;
4263 Adapters[0].UsedTextureRam = 0;
4264 TRACE("Emulating %dMB of texture ram\n", Adapters[0].TextureRam/(1024*1024));
4265
4266 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
4267 DisplayDevice.cb = sizeof(DisplayDevice);
4268 EnumDisplayDevicesW(NULL, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice, 0);
4269 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice.DeviceName));
4270 strcpyW(Adapters[0].DeviceName, DisplayDevice.DeviceName);
4271
4272 attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
4273 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, &attribute, &Adapters[0].nCfgs));
4274
4275 Adapters[0].cfgs = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Adapters[0].nCfgs *sizeof(WineD3D_PixelFormat));
4276 cfgs = Adapters[0].cfgs;
4277 PUSH1(WGL_RED_BITS_ARB)
4278 PUSH1(WGL_GREEN_BITS_ARB)
4279 PUSH1(WGL_BLUE_BITS_ARB)
4280 PUSH1(WGL_ALPHA_BITS_ARB)
4281 PUSH1(WGL_DEPTH_BITS_ARB)
4282 PUSH1(WGL_STENCIL_BITS_ARB)
4283 PUSH1(WGL_DRAW_TO_WINDOW_ARB)
4284 PUSH1(WGL_PIXEL_TYPE_ARB)
4285 PUSH1(WGL_DOUBLE_BUFFER_ARB)
4286 PUSH1(WGL_AUX_BUFFERS_ARB)
4287
4288 for(iPixelFormat=1; iPixelFormat<=Adapters[0].nCfgs; iPixelFormat++) {
4289 res = GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, nAttribs, attribs, values));
4290
4291 if(!res)
4292 continue;
4293
4294 /* Cache the pixel format */
4295 cfgs->iPixelFormat = iPixelFormat;
4296 cfgs->redSize = values[0];
4297 cfgs->greenSize = values[1];
4298 cfgs->blueSize = values[2];
4299 cfgs->alphaSize = values[3];
4300 cfgs->depthSize = values[4];
4301 cfgs->stencilSize = values[5];
4302 cfgs->windowDrawable = values[6];
4303 cfgs->iPixelType = values[7];
4304 cfgs->doubleBuffer = values[8];
4305 cfgs->auxBuffers = values[9];
4306
4307 cfgs->pbufferDrawable = FALSE;
4308 /* Check for pbuffer support when it is around as wglGetPixelFormatAttribiv fails for unknown attributes. */
4309 if(GL_SUPPORT(WGL_ARB_PBUFFER)) {
4310 int attrib = WGL_DRAW_TO_PBUFFER_ARB;
4311 int value;
4312 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 1, &attrib, &value)))
4313 cfgs->pbufferDrawable = value;
4314 }
4315
4316 cfgs->numSamples = 0;
4317 /* Check multisample support */
4318 if(GL_SUPPORT(ARB_MULTISAMPLE)) {
4319 int attrib[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
4320 int value[2];
4321 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0, 2, attrib, value))) {
4322 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
4323 * value[1] = number of multi sample buffers*/
4324 if(value[0])
4325 cfgs->numSamples = value[1];
4326 }
4327 }
4328
4329 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d, windowDrawable=%d, pbufferDrawable=%d\n", cfgs->iPixelFormat, cfgs->iPixelType, cfgs->doubleBuffer, cfgs->redSize, cfgs->greenSize, cfgs->blueSize, cfgs->alphaSize, cfgs->depthSize, cfgs->stencilSize, cfgs->windowDrawable, cfgs->pbufferDrawable);
4330 cfgs++;
4331 }
4332
4333 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
4334 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
4335 * but just fake it using D24(X8?) which is fine. D3D also allows that.
4336 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
4337 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
4338 * driver is allowed to consume more bits EXCEPT for stencil bits.
4339 *
4340 * Mark an adapter with this broken stencil behavior.
4341 */
4342 Adapters[0].brokenStencil = TRUE;
4343 for(i=0, cfgs=Adapters[0].cfgs; i<Adapters[0].nCfgs; i++) {
4344 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
4345 if(cfgs[i].depthSize && !cfgs[i].stencilSize) {
4346 Adapters[0].brokenStencil = FALSE;
4347 break;
4348 }
4349 }
4350
4351 fixup_extensions(&Adapters[0].gl_info);
4352
4353 WineD3D_ReleaseFakeGLContext();
4354
4355 select_shader_mode(&Adapters[0].gl_info, WINED3DDEVTYPE_HAL, &ps_selected_mode, &vs_selected_mode);
4356 select_shader_max_constants(ps_selected_mode, vs_selected_mode, &Adapters[0].gl_info);
4357 fillGLAttribFuncs(&Adapters[0].gl_info);
4358 init_type_lookup(&Adapters[0].gl_info);
4359 Adapters[0].opengl = TRUE;
4360 }
4361 numAdapters = 1;
4362 TRACE("%d adapters successfully initialized\n", numAdapters);
4363
4364 return TRUE;
4365
4366 nogl_adapter:
4367 /* Initialize an adapter for ddraw-only memory counting */
4368 memset(Adapters, 0, sizeof(Adapters));
4369 Adapters[0].num = 0;
4370 Adapters[0].opengl = FALSE;
4371 Adapters[0].monitorPoint.x = -1;
4372 Adapters[0].monitorPoint.y = -1;
4373
4374 Adapters[0].driver = "Display";
4375 Adapters[0].description = "WineD3D DirectDraw Emulation";
4376 if(wined3d_settings.emulated_textureram) {
4377 Adapters[0].TextureRam = wined3d_settings.emulated_textureram;
4378 } else {
4379 Adapters[0].TextureRam = 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
4380 }
4381
4382 numAdapters = 1;
4383 return FALSE;
4384 }
4385 #undef PUSH1
4386 #undef GLINFO_LOCATION
4387
4388 /**********************************************************
4389 * IWineD3D VTbl follows
4390 **********************************************************/
4391
4392 const IWineD3DVtbl IWineD3D_Vtbl =
4393 {
4394 /* IUnknown */
4395 IWineD3DImpl_QueryInterface,
4396 IWineD3DImpl_AddRef,
4397 IWineD3DImpl_Release,
4398 /* IWineD3D */
4399 IWineD3DImpl_GetParent,
4400 IWineD3DImpl_GetAdapterCount,
4401 IWineD3DImpl_RegisterSoftwareDevice,
4402 IWineD3DImpl_GetAdapterMonitor,
4403 IWineD3DImpl_GetAdapterModeCount,
4404 IWineD3DImpl_EnumAdapterModes,
4405 IWineD3DImpl_GetAdapterDisplayMode,
4406 IWineD3DImpl_GetAdapterIdentifier,
4407 IWineD3DImpl_CheckDeviceMultiSampleType,
4408 IWineD3DImpl_CheckDepthStencilMatch,
4409 IWineD3DImpl_CheckDeviceType,
4410 IWineD3DImpl_CheckDeviceFormat,
4411 IWineD3DImpl_CheckDeviceFormatConversion,
4412 IWineD3DImpl_GetDeviceCaps,
4413 IWineD3DImpl_CreateDevice
4414 };
useful hacks and other patches not (yet) suitable for mainline