projects / reactos.git / blob
? search:


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