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