2 * IWineD3D implementation
4 * Copyright 2002-2004 Jason Edmeades
5 * Copyright 2003-2004 Raphael Junqueira
6 * Copyright 2004 Christian Costa
7 * Copyright 2005 Oliver Stieber
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 /* Compile time diagnostics: */
26 #ifndef DEBUG_SINGLE_MODE
27 /* Set to 1 to force only a single display mode to be exposed: */
28 #define DEBUG_SINGLE_MODE 0
34 #include "wined3d_private.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
37 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps
);
39 /* The d3d device ID */
40 static const GUID IID_D3DDEVICE_D3DUID
= { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
42 /* Extension detection */
44 const char *extension_string
;
45 GL_SupportedExt extension
;
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 },
56 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL
, 0 },
57 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3
, 0 },
58 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE
, 0 },
59 {"GL_ATI_envmap_bumpmap", ATI_ENVMAP_BUMPMAP
, 0 },
62 {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS
, 0 },
63 {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM
, 0 },
64 {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER
, 0 },
65 {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL
, 0 },
66 {"GL_ARB_imaging", ARB_IMAGING
, 0 },
67 {"GL_ARB_multisample", ARB_MULTISAMPLE
, 0 }, /* needs GLX_ARB_MULTISAMPLE as well */
68 {"GL_ARB_multitexture", ARB_MULTITEXTURE
, 0 },
69 {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY
, 0 },
70 {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT
, 0 },
71 {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS
, 0 },
72 {"GL_ARB_point_sprite", ARB_POINT_SPRITE
, 0 },
73 {"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP
, 0 },
74 {"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION
, 0 },
75 {"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP
, 0 },
76 {"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD
, 0 },
77 {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE
, 0 },
78 {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3
, 0 },
79 {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT
, 0 },
80 {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT
, 0 },
81 {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO
, 0 },
82 {"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE
, 0 },
83 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND
, 0 },
84 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT
, 0 },
85 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM
, 0 },
86 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER
, 0 },
87 {"GL_ARB_shader_objects", ARB_SHADER_OBJECTS
, 0 },
90 {"GL_EXT_blend_color", EXT_BLEND_COLOR
, 0 },
91 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX
, 0 },
92 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE
, 0 },
93 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE
, 0 },
94 {"GL_EXT_fog_coord", EXT_FOG_COORD
, 0 },
95 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT
, 0 },
96 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT
, 0 },
97 {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE
, 0 },
98 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS
, 0 },
99 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR
, 0 },
100 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE
, 0 },
101 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP
, 0 },
102 {"GL_EXT_texture3D", EXT_TEXTURE3D
, MAKEDWORD_VERSION(1, 2) },
103 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC
, 0 },
104 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD
, 0 },
105 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE
, 0 },
106 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3
, 0 },
107 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB
, 0 },
108 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC
, 0 },
109 {"GL_EXT_texture_lod", EXT_TEXTURE_LOD
, 0 },
110 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS
, 0 },
111 {"GL_EXT_vertex_shader", EXT_VERTEX_SHADER
, 0 },
112 {"GL_EXT_vertex_weighting", EXT_VERTEX_WEIGHTING
, 0 },
113 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS
, 0 },
116 {"GL_NV_half_float", NV_HALF_FLOAT
, 0 },
117 {"GL_NV_fence", NV_FENCE
, 0 },
118 {"GL_NV_fog_distance", NV_FOG_DISTANCE
, 0 },
119 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM
, 0 },
120 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2
, 0 },
121 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS
, 0 },
122 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2
, 0 },
123 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION
, 0 },
124 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4
, 0 },
125 {"GL_NV_texture_shader", NV_TEXTURE_SHADER
, 0 },
126 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2
, 0 },
127 {"GL_NV_texture_shader3", NV_TEXTURE_SHADER3
, 0 },
128 {"GL_NV_occlusion_query", NV_OCCLUSION_QUERY
, 0 },
129 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM
, 0 },
130 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1
, 0 },
131 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2
, 0 },
132 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3
, 0 },
133 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP
, 0 },
134 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT
, 0 },
137 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP
, 0 },
140 /**********************************************************
141 * Utility functions follow
142 **********************************************************/
145 static int numAdapters
= 0;
146 static struct WineD3DAdapter Adapters
[1];
148 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
);
151 int minLookup
[MAX_LOOKUPS
];
152 int maxLookup
[MAX_LOOKUPS
];
153 DWORD
*stateLookup
[MAX_LOOKUPS
];
155 DWORD minMipLookup
[WINED3DTEXF_ANISOTROPIC
+ 1][WINED3DTEXF_LINEAR
+ 1];
157 /* drawStridedSlow attributes */
158 glAttribFunc position_funcs
[WINED3DDECLTYPE_UNUSED
];
159 glAttribFunc diffuse_funcs
[WINED3DDECLTYPE_UNUSED
];
160 glAttribFunc specular_funcs
[WINED3DDECLTYPE_UNUSED
];
161 glAttribFunc normal_funcs
[WINED3DDECLTYPE_UNUSED
];
162 glTexAttribFunc texcoord_funcs
[WINED3DDECLTYPE_UNUSED
];
165 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created
166 * ie there is no GL Context - Get a default rendering context to enable the
167 * function query some info from GL
170 static int wined3d_fake_gl_context_ref
= 0;
171 static BOOL wined3d_fake_gl_context_foreign
;
172 static BOOL wined3d_fake_gl_context_available
= FALSE
;
173 static HDC wined3d_fake_gl_context_hdc
= NULL
;
174 static HWND wined3d_fake_gl_context_hwnd
= NULL
;
176 static CRITICAL_SECTION wined3d_fake_gl_context_cs
;
177 static CRITICAL_SECTION_DEBUG wined3d_fake_gl_context_cs_debug
=
179 0, 0, &wined3d_fake_gl_context_cs
,
180 { &wined3d_fake_gl_context_cs_debug
.ProcessLocksList
,
181 &wined3d_fake_gl_context_cs_debug
.ProcessLocksList
},
182 0, 0, { (DWORD_PTR
)(__FILE__
": wined3d_fake_gl_context_cs") }
184 static CRITICAL_SECTION wined3d_fake_gl_context_cs
= { &wined3d_fake_gl_context_cs_debug
, -1, 0, 0, 0, 0 };
186 static void WineD3D_ReleaseFakeGLContext(void) {
189 EnterCriticalSection(&wined3d_fake_gl_context_cs
);
191 if(!wined3d_fake_gl_context_available
) {
192 TRACE_(d3d_caps
)("context not available\n");
193 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
197 glCtx
= pwglGetCurrentContext();
199 TRACE_(d3d_caps
)("decrementing ref from %i\n", wined3d_fake_gl_context_ref
);
200 if (0 == (--wined3d_fake_gl_context_ref
) ) {
201 if(!wined3d_fake_gl_context_foreign
&& glCtx
) {
202 TRACE_(d3d_caps
)("destroying fake GL context\n");
203 pwglMakeCurrent(NULL
, NULL
);
204 pwglDeleteContext(glCtx
);
206 if(wined3d_fake_gl_context_hdc
)
207 ReleaseDC(wined3d_fake_gl_context_hwnd
, wined3d_fake_gl_context_hdc
);
208 wined3d_fake_gl_context_hdc
= NULL
; /* Make sure we don't think that it is still around */
209 if(wined3d_fake_gl_context_hwnd
)
210 DestroyWindow(wined3d_fake_gl_context_hwnd
);
211 wined3d_fake_gl_context_hwnd
= NULL
;
212 wined3d_fake_gl_context_available
= FALSE
;
214 assert(wined3d_fake_gl_context_ref
>= 0);
216 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
219 static BOOL
WineD3D_CreateFakeGLContext(void) {
222 EnterCriticalSection(&wined3d_fake_gl_context_cs
);
224 TRACE("getting context...\n");
225 if(wined3d_fake_gl_context_ref
> 0) goto ret
;
226 assert(0 == wined3d_fake_gl_context_ref
);
228 wined3d_fake_gl_context_foreign
= TRUE
;
230 glCtx
= pwglGetCurrentContext();
232 PIXELFORMATDESCRIPTOR pfd
;
235 wined3d_fake_gl_context_foreign
= FALSE
;
237 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes */
238 wined3d_fake_gl_context_hwnd
= CreateWindowA("WineD3D_OpenGL", "WineD3D fake window", WS_OVERLAPPEDWINDOW
, 10, 10, 10, 10, NULL
, NULL
, NULL
, NULL
);
239 if(!wined3d_fake_gl_context_hwnd
) {
240 ERR("HWND creation failed!\n");
243 wined3d_fake_gl_context_hdc
= GetDC(wined3d_fake_gl_context_hwnd
);
244 if(!wined3d_fake_gl_context_hdc
) {
245 ERR("GetDC failed!\n");
249 /* PixelFormat selection */
250 ZeroMemory(&pfd
, sizeof(pfd
));
251 pfd
.nSize
= sizeof(pfd
);
253 pfd
.dwFlags
= PFD_SUPPORT_OPENGL
| PFD_DOUBLEBUFFER
| PFD_DRAW_TO_WINDOW
;/*PFD_GENERIC_ACCELERATED*/
254 pfd
.iPixelType
= PFD_TYPE_RGBA
;
256 pfd
.iLayerType
= PFD_MAIN_PLANE
;
258 iPixelFormat
= ChoosePixelFormat(wined3d_fake_gl_context_hdc
, &pfd
);
260 /* If this happens something is very wrong as ChoosePixelFormat barely fails */
261 ERR("Can't find a suitable iPixelFormat\n");
264 DescribePixelFormat(wined3d_fake_gl_context_hdc
, iPixelFormat
, sizeof(pfd
), &pfd
);
265 SetPixelFormat(wined3d_fake_gl_context_hdc
, iPixelFormat
, &pfd
);
267 /* Create a GL context */
268 glCtx
= pwglCreateContext(wined3d_fake_gl_context_hdc
);
270 WARN_(d3d_caps
)("Error creating default context for capabilities initialization\n");
274 /* Make it the current GL context */
275 if (!pwglMakeCurrent(wined3d_fake_gl_context_hdc
, glCtx
)) {
276 WARN_(d3d_caps
)("Error setting default context as current for capabilities initialization\n");
282 TRACE("incrementing ref from %i\n", wined3d_fake_gl_context_ref
);
283 wined3d_fake_gl_context_ref
++;
284 wined3d_fake_gl_context_available
= TRUE
;
285 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
288 if(wined3d_fake_gl_context_hdc
)
289 ReleaseDC(wined3d_fake_gl_context_hwnd
, wined3d_fake_gl_context_hdc
);
290 wined3d_fake_gl_context_hdc
= NULL
;
291 if(wined3d_fake_gl_context_hwnd
)
292 DestroyWindow(wined3d_fake_gl_context_hwnd
);
293 wined3d_fake_gl_context_hwnd
= NULL
;
294 if(glCtx
) pwglDeleteContext(glCtx
);
295 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
299 /* Adjust the amount of used texture memory */
300 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl
*D3DDevice
, long glram
){
301 UINT Adapter
= D3DDevice
->adapterNo
;
303 Adapters
[Adapter
].UsedTextureRam
+= glram
;
304 TRACE("Adjusted gl ram by %ld to %d\n", glram
, Adapters
[Adapter
].UsedTextureRam
);
305 return Adapters
[Adapter
].UsedTextureRam
;
308 /**********************************************************
309 * IUnknown parts follows
310 **********************************************************/
312 static HRESULT WINAPI
IWineD3DImpl_QueryInterface(IWineD3D
*iface
,REFIID riid
,LPVOID
*ppobj
)
314 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
316 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
317 if (IsEqualGUID(riid
, &IID_IUnknown
)
318 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
319 || IsEqualGUID(riid
, &IID_IWineD3DDevice
)) {
320 IUnknown_AddRef(iface
);
325 return E_NOINTERFACE
;
328 static ULONG WINAPI
IWineD3DImpl_AddRef(IWineD3D
*iface
) {
329 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
330 ULONG refCount
= InterlockedIncrement(&This
->ref
);
332 TRACE("(%p) : AddRef increasing from %d\n", This
, refCount
- 1);
336 static ULONG WINAPI
IWineD3DImpl_Release(IWineD3D
*iface
) {
337 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
339 TRACE("(%p) : Releasing from %d\n", This
, This
->ref
);
340 ref
= InterlockedDecrement(&This
->ref
);
342 HeapFree(GetProcessHeap(), 0, This
);
348 /* Set the shader type for this device, depending on the given capabilities,
349 * the device type, and the user preferences in wined3d_settings */
351 static void select_shader_mode(
352 WineD3D_GL_Info
*gl_info
,
353 WINED3DDEVTYPE DeviceType
,
357 if (wined3d_settings
.vs_mode
== VS_NONE
) {
358 *vs_selected
= SHADER_NONE
;
359 } else if (gl_info
->supported
[ARB_VERTEX_SHADER
] && wined3d_settings
.glslRequested
) {
360 /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
361 * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
362 * shaders only on this card. */
363 if(gl_info
->vs_nv_version
&& gl_info
->vs_nv_version
< VS_VERSION_20
)
364 *vs_selected
= SHADER_ARB
;
366 *vs_selected
= SHADER_GLSL
;
367 } else if (gl_info
->supported
[ARB_VERTEX_PROGRAM
]) {
368 *vs_selected
= SHADER_ARB
;
370 *vs_selected
= SHADER_NONE
;
373 if (wined3d_settings
.ps_mode
== PS_NONE
) {
374 *ps_selected
= SHADER_NONE
;
375 } else if (gl_info
->supported
[ARB_FRAGMENT_SHADER
] && wined3d_settings
.glslRequested
) {
376 *ps_selected
= SHADER_GLSL
;
377 } else if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) {
378 *ps_selected
= SHADER_ARB
;
380 *ps_selected
= SHADER_NONE
;
384 /** Select the number of report maximum shader constants based on the selected shader modes */
385 static void select_shader_max_constants(
386 int ps_selected_mode
,
387 int vs_selected_mode
,
388 WineD3D_GL_Info
*gl_info
) {
390 switch (vs_selected_mode
) {
392 /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
393 gl_info
->max_vshader_constantsF
= gl_info
->vs_glsl_constantsF
- (MAX_CONST_B
/ 4) - MAX_CONST_I
- 1;
396 /* We have to subtract any other PARAMs that we might use in our shader programs.
397 * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
398 * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
399 gl_info
->max_vshader_constantsF
= gl_info
->vs_arb_constantsF
- 3;
402 gl_info
->max_vshader_constantsF
= 0;
406 switch (ps_selected_mode
) {
408 /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
409 * In theory the texbem instruction may need one more shader constant too. But lets assume
410 * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
411 * and lets not take away a uniform needlessly from all other shaders.
413 gl_info
->max_pshader_constantsF
= gl_info
->ps_glsl_constantsF
- (MAX_CONST_B
/ 4) - MAX_CONST_I
- 2;
416 /* The arb shader only loads the bump mapping environment matrix into the shader if it finds
417 * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
419 gl_info
->max_pshader_constantsF
= gl_info
->ps_arb_constantsF
- 2;
422 gl_info
->max_pshader_constantsF
= 0;
427 /**********************************************************
428 * IWineD3D parts follows
429 **********************************************************/
431 #define GLINFO_LOCATION (*gl_info)
432 static inline BOOL
test_arb_vs_offset_limit(WineD3D_GL_Info
*gl_info
) {
435 const char *testcode
=
437 "PARAM C[66] = { program.env[0..65] };\n"
439 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
440 "ARL A0.x, zero.x;\n"
441 "MOV result.position, C[A0.x + 65];\n"
445 GL_EXTCALL(glGenProgramsARB(1, &prog
));
447 ERR("Failed to create an ARB offset limit test program\n");
449 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, prog
));
450 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
,
451 strlen(testcode
), testcode
));
452 if(glGetError() != 0) {
453 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
454 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB
)));
456 } else TRACE("OpenGL implementation allows offsets > 63\n");
458 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, 0));
459 GL_EXTCALL(glDeleteProgramsARB(1, &prog
));
460 checkGLcall("ARB vp offset limit test cleanup\n");
465 static DWORD
ver_for_ext(GL_SupportedExt ext
)
468 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
469 if(EXTENSION_MAP
[i
].extension
== ext
) {
470 return EXTENSION_MAP
[i
].version
;
476 BOOL
IWineD3DImpl_FillGLCaps(WineD3D_GL_Info
*gl_info
) {
477 const char *GL_Extensions
= NULL
;
478 const char *WGL_Extensions
= NULL
;
479 const char *gl_string
= NULL
;
480 const char *gl_string_cursor
= NULL
;
482 GLfloat gl_floatv
[2];
483 int major
= 1, minor
= 0;
484 BOOL return_value
= TRUE
;
487 unsigned int vidmem
=0;
489 TRACE_(d3d_caps
)("(%p)\n", gl_info
);
493 gl_string
= (const char *) glGetString(GL_RENDERER
);
494 if (NULL
== gl_string
)
496 strcpy(gl_info
->gl_renderer
, gl_string
);
498 gl_string
= (const char *) glGetString(GL_VENDOR
);
499 TRACE_(d3d_caps
)("Filling vendor string %s\n", gl_string
);
500 if (gl_string
!= NULL
) {
501 /* Fill in the GL vendor */
502 if (strstr(gl_string
, "NVIDIA")) {
503 gl_info
->gl_vendor
= VENDOR_NVIDIA
;
504 } else if (strstr(gl_string
, "ATI")) {
505 gl_info
->gl_vendor
= VENDOR_ATI
;
506 } else if (strstr(gl_string
, "Intel(R)") ||
507 strstr(gl_info
->gl_renderer
, "Intel(R)") ||
508 strstr(gl_string
, "Intel Inc.")) {
509 gl_info
->gl_vendor
= VENDOR_INTEL
;
510 } else if (strstr(gl_string
, "Mesa")) {
511 gl_info
->gl_vendor
= VENDOR_MESA
;
513 gl_info
->gl_vendor
= VENDOR_WINE
;
516 gl_info
->gl_vendor
= VENDOR_WINE
;
520 TRACE_(d3d_caps
)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string
), gl_info
->gl_vendor
);
522 /* Parse the GL_VERSION field into major and minor information */
523 gl_string
= (const char *) glGetString(GL_VERSION
);
524 if (gl_string
!= NULL
) {
526 /* First, parse the generic opengl version. This is supposed not to be convoluted with
527 * driver specific information
529 gl_string_cursor
= gl_string
;
530 major
= atoi(gl_string_cursor
);
532 ERR("Invalid opengl major version: %d\n", major
);
534 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
537 if (*gl_string_cursor
++ != '.') {
538 ERR_(d3d_caps
)("Invalid opengl version string: %s\n", debugstr_a(gl_string
));
540 minor
= atoi(gl_string_cursor
);
541 TRACE_(d3d_caps
)("Found OpenGL version: %d.%d\n", major
, minor
);
542 gl_info
->gl_version
= MAKEDWORD_VERSION(major
, minor
);
544 /* Now parse the driver specific string which we'll report to the app */
545 switch (gl_info
->gl_vendor
) {
547 gl_string_cursor
= strstr(gl_string
, "NVIDIA");
548 if (!gl_string_cursor
) {
549 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
553 gl_string_cursor
= strstr(gl_string_cursor
, " ");
554 if (!gl_string_cursor
) {
555 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
559 while (*gl_string_cursor
== ' ') {
563 if (!*gl_string_cursor
) {
564 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
568 major
= atoi(gl_string_cursor
);
569 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
573 if (*gl_string_cursor
++ != '.') {
574 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
578 minor
= atoi(gl_string_cursor
);
579 minor
= major
*100+minor
;
586 gl_string_cursor
= strchr(gl_string
, '-');
587 if (gl_string_cursor
) {
591 /* Check if version number is of the form x.y.z */
592 if (*gl_string_cursor
> '9' && *gl_string_cursor
< '0')
594 if (!error
&& *(gl_string_cursor
+2) > '9' && *(gl_string_cursor
+2) < '0')
596 if (!error
&& *(gl_string_cursor
+4) > '9' && *(gl_string_cursor
+4) < '0')
598 if (!error
&& *(gl_string_cursor
+1) != '.' && *(gl_string_cursor
+3) != '.')
601 /* Mark version number as malformed */
603 gl_string_cursor
= 0;
606 if (!gl_string_cursor
)
607 WARN_(d3d_caps
)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string
));
609 major
= *gl_string_cursor
- '0';
610 minor
= (*(gl_string_cursor
+2) - '0') * 256 + (*(gl_string_cursor
+4) - '0');
615 /* Apple and Mesa version strings look differently, but both provide intel drivers */
616 if(strstr(gl_string
, "APPLE")) {
617 /* [0-9]+.[0-9]+ APPLE-[0-9]+.[0.9]+.[0.9]+
618 * We only need the first part, and use the APPLE as identification
621 gl_string_cursor
= gl_string
;
622 major
= atoi(gl_string_cursor
);
623 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
627 if (*gl_string_cursor
++ != '.') {
628 ERR_(d3d_caps
)("Invalid MacOS-Intel version string: %s\n", debugstr_a(gl_string
));
632 minor
= atoi(gl_string_cursor
);
637 gl_string_cursor
= strstr(gl_string
, "Mesa");
638 gl_string_cursor
= strstr(gl_string_cursor
, " ");
639 while (*gl_string_cursor
&& ' ' == *gl_string_cursor
) ++gl_string_cursor
;
640 if (*gl_string_cursor
) {
644 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
645 tmp
[cursor
++] = *gl_string_cursor
;
651 if (*gl_string_cursor
!= '.') WARN_(d3d_caps
)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string
));
655 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
656 tmp
[cursor
++] = *gl_string_cursor
;
668 gl_info
->driver_version
= MAKEDWORD_VERSION(major
, minor
);
669 TRACE_(d3d_caps
)("found driver version (%s)->%i.%i->(0x%08x)\n", debugstr_a(gl_string
), major
, minor
, gl_info
->driver_version
);
670 /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
671 gl_info
->driver_version_hipart
= MAKEDWORD_VERSION(6, 14);
673 FIXME("OpenGL driver did not return version information\n");
674 gl_info
->driver_version
= MAKEDWORD_VERSION(0, 0);
675 gl_info
->driver_version_hipart
= MAKEDWORD_VERSION(6, 14);
678 TRACE_(d3d_caps
)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(gl_info
->gl_renderer
), gl_info
->gl_card
);
681 * Initialize openGL extension related variables
682 * with Default values
684 memset(&gl_info
->supported
, 0, sizeof(gl_info
->supported
));
685 gl_info
->max_buffers
= 1;
686 gl_info
->max_textures
= 1;
687 gl_info
->max_texture_stages
= 1;
688 gl_info
->max_fragment_samplers
= 1;
689 gl_info
->max_vertex_samplers
= 0;
690 gl_info
->max_combined_samplers
= 0;
691 gl_info
->max_sampler_stages
= 1;
692 gl_info
->ps_arb_version
= PS_VERSION_NOT_SUPPORTED
;
693 gl_info
->ps_arb_max_temps
= 0;
694 gl_info
->ps_arb_max_instructions
= 0;
695 gl_info
->vs_arb_version
= VS_VERSION_NOT_SUPPORTED
;
696 gl_info
->vs_arb_max_temps
= 0;
697 gl_info
->vs_arb_max_instructions
= 0;
698 gl_info
->vs_nv_version
= VS_VERSION_NOT_SUPPORTED
;
699 gl_info
->vs_ati_version
= VS_VERSION_NOT_SUPPORTED
;
700 gl_info
->vs_glsl_constantsF
= 0;
701 gl_info
->ps_glsl_constantsF
= 0;
702 gl_info
->vs_arb_constantsF
= 0;
703 gl_info
->ps_arb_constantsF
= 0;
705 /* Retrieve opengl defaults */
706 glGetIntegerv(GL_MAX_CLIP_PLANES
, &gl_max
);
707 gl_info
->max_clipplanes
= min(WINED3DMAXUSERCLIPPLANES
, gl_max
);
708 TRACE_(d3d_caps
)("ClipPlanes support - num Planes=%d\n", gl_max
);
710 glGetIntegerv(GL_MAX_LIGHTS
, &gl_max
);
711 gl_info
->max_lights
= gl_max
;
712 TRACE_(d3d_caps
)("Lights support - max lights=%d\n", gl_max
);
714 glGetIntegerv(GL_MAX_TEXTURE_SIZE
, &gl_max
);
715 gl_info
->max_texture_size
= gl_max
;
716 TRACE_(d3d_caps
)("Maximum texture size support - max texture size=%d\n", gl_max
);
718 glGetFloatv(GL_POINT_SIZE_RANGE
, gl_floatv
);
719 gl_info
->max_pointsizemin
= gl_floatv
[0];
720 gl_info
->max_pointsize
= gl_floatv
[1];
721 TRACE_(d3d_caps
)("Maximum point size support - max point size=%f\n", gl_floatv
[1]);
723 glGetIntegerv(GL_AUX_BUFFERS
, &gl_max
);
724 gl_info
->max_aux_buffers
= gl_max
;
725 TRACE_(d3d_caps
)("Offscreen rendering support - number of aux buffers=%d\n", gl_max
);
727 /* Parse the gl supported features, in theory enabling parts of our code appropriately */
728 GL_Extensions
= (const char *) glGetString(GL_EXTENSIONS
);
729 TRACE_(d3d_caps
)("GL_Extensions reported:\n");
731 if (NULL
== GL_Extensions
) {
732 ERR(" GL_Extensions returns NULL\n");
734 while (*GL_Extensions
!= 0x00) {
739 while (isspace(*GL_Extensions
)) GL_Extensions
++;
740 Start
= GL_Extensions
;
741 while (!isspace(*GL_Extensions
) && *GL_Extensions
!= 0x00) {
745 len
= GL_Extensions
- Start
;
746 if (len
== 0 || len
>= sizeof(ThisExtn
))
749 memcpy(ThisExtn
, Start
, len
);
750 ThisExtn
[len
] = '\0';
751 TRACE_(d3d_caps
)("- %s\n", ThisExtn
);
753 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
754 if (!strcmp(ThisExtn
, EXTENSION_MAP
[i
].extension_string
)) {
755 TRACE_(d3d_caps
)(" FOUND: %s support\n", EXTENSION_MAP
[i
].extension_string
);
756 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
761 /* Now work out what GL support this card really has */
762 #define USE_GL_FUNC(type, pfn, ext, replace) { \
763 DWORD ver = ver_for_ext(ext); \
764 if(gl_info->supported[ext]) gl_info->pfn = (type) pwglGetProcAddress(#pfn); \
765 else if(ver && ver <= gl_info->gl_version) gl_info->pfn = (type) pwglGetProcAddress(#replace); \
766 else gl_info->pfn = NULL; \
771 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
775 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
776 * loading the functions, otherwise the code above will load the extension entry points instead of the
777 * core functions, which may not work
779 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
780 if (gl_info
->supported
[EXTENSION_MAP
[i
].extension
] == FALSE
&&
781 EXTENSION_MAP
[i
].version
<= gl_info
->gl_version
&& EXTENSION_MAP
[i
].version
) {
782 TRACE_(d3d_caps
)(" GL CORE: %s support\n", EXTENSION_MAP
[i
].extension_string
);
783 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
787 if (gl_info
->supported
[APPLE_FENCE
]) {
788 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
789 * The apple extension interacts with some other apple exts. Disable the NV
790 * extension if the apple one is support to prevent confusion in other parts
793 gl_info
->supported
[NV_FENCE
] = FALSE
;
795 if (gl_info
->supported
[APPLE_FLOAT_PIXELS
]) {
796 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
798 * The enums are the same:
799 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
800 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
801 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
802 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
803 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
805 if(!gl_info
->supported
[ARB_TEXTURE_FLOAT
]) {
806 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels\n");
807 gl_info
->supported
[ARB_TEXTURE_FLOAT
] = TRUE
;
809 if(!gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
]) {
810 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels\n");
811 gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
] = TRUE
;
814 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
]) {
815 TRACE_(d3d_caps
)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
816 gl_info
->supported
[NV_TEXGEN_REFLECTION
] = TRUE
;
818 if (gl_info
->supported
[NV_TEXTURE_SHADER2
]) {
819 /* GL_ATI_envmap_bumpmap won't play nice with texture shaders, so disable it
820 * Won't occur in any real world situation though
822 gl_info
->supported
[ATI_ENVMAP_BUMPMAP
] = FALSE
;
824 if (gl_info
->supported
[ARB_DRAW_BUFFERS
]) {
825 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB
, &gl_max
);
826 gl_info
->max_buffers
= gl_max
;
827 TRACE_(d3d_caps
)("Max draw buffers: %u\n", gl_max
);
829 if (gl_info
->supported
[ARB_MULTITEXTURE
]) {
830 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB
, &gl_max
);
831 gl_info
->max_textures
= min(MAX_TEXTURES
, gl_max
);
832 TRACE_(d3d_caps
)("Max textures: %d\n", gl_info
->max_textures
);
834 if (gl_info
->supported
[NV_REGISTER_COMBINERS
]) {
836 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV
, &tmp
);
837 gl_info
->max_texture_stages
= min(MAX_TEXTURES
, tmp
);
839 gl_info
->max_texture_stages
= min(MAX_TEXTURES
, gl_max
);
841 TRACE_(d3d_caps
)("Max texture stages: %d\n", gl_info
->max_texture_stages
);
843 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) {
845 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
846 gl_info
->max_fragment_samplers
= min(MAX_FRAGMENT_SAMPLERS
, tmp
);
848 gl_info
->max_fragment_samplers
= max(gl_info
->max_fragment_samplers
, gl_max
);
850 TRACE_(d3d_caps
)("Max fragment samplers: %d\n", gl_info
->max_fragment_samplers
);
852 if (gl_info
->supported
[ARB_VERTEX_SHADER
]) {
854 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
855 gl_info
->max_vertex_samplers
= tmp
;
856 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
857 gl_info
->max_combined_samplers
= tmp
;
859 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
860 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
861 * an issue because then the sampler setup only depends on the two shaders. If a pixel
862 * shader is used with fixed function vertex processing we're fine too because fixed function
863 * vertex processing doesn't use any samplers. If fixed function fragment processing is
864 * used we have to make sure that all vertex sampler setups are valid together with all
865 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
866 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
867 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
868 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
869 * a fixed function pipeline anymore.
871 * So this is just a check to check that our assumption holds true. If not, write a warning
872 * and reduce the number of vertex samplers or probably disable vertex texture fetch.
874 if(gl_info
->max_vertex_samplers
&&
875 MAX_TEXTURES
+ gl_info
->max_vertex_samplers
> gl_info
->max_combined_samplers
) {
876 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers\n",
877 gl_info
->max_vertex_samplers
, gl_info
->max_combined_samplers
);
878 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers\n");
879 if( gl_info
->max_combined_samplers
> MAX_TEXTURES
)
880 gl_info
->max_vertex_samplers
=
881 gl_info
->max_combined_samplers
- MAX_TEXTURES
;
883 gl_info
->max_vertex_samplers
= 0;
886 gl_info
->max_combined_samplers
= gl_info
->max_fragment_samplers
;
888 TRACE_(d3d_caps
)("Max vertex samplers: %u\n", gl_info
->max_vertex_samplers
);
889 TRACE_(d3d_caps
)("Max combined samplers: %u\n", gl_info
->max_combined_samplers
);
891 if (gl_info
->supported
[ARB_VERTEX_BLEND
]) {
892 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB
, &gl_max
);
893 gl_info
->max_blends
= gl_max
;
894 TRACE_(d3d_caps
)("Max blends: %u\n", gl_info
->max_blends
);
896 if (gl_info
->supported
[EXT_TEXTURE3D
]) {
897 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT
, &gl_max
);
898 gl_info
->max_texture3d_size
= gl_max
;
899 TRACE_(d3d_caps
)("Max texture3D size: %d\n", gl_info
->max_texture3d_size
);
901 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
]) {
902 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
, &gl_max
);
903 gl_info
->max_anisotropy
= gl_max
;
904 TRACE_(d3d_caps
)("Max anisotropy: %d\n", gl_info
->max_anisotropy
);
906 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) {
907 gl_info
->ps_arb_version
= PS_VERSION_11
;
908 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
909 gl_info
->ps_arb_constantsF
= gl_max
;
910 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM float constants: %d\n", gl_info
->ps_arb_constantsF
);
911 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
912 gl_info
->ps_arb_max_temps
= gl_max
;
913 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d\n", gl_info
->ps_arb_max_temps
);
914 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
915 gl_info
->ps_arb_max_instructions
= gl_max
;
916 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native instructions: %d\n", gl_info
->ps_arb_max_instructions
);
918 if (gl_info
->supported
[ARB_VERTEX_PROGRAM
]) {
919 gl_info
->vs_arb_version
= VS_VERSION_11
;
920 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
921 gl_info
->vs_arb_constantsF
= gl_max
;
922 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM float constants: %d\n", gl_info
->vs_arb_constantsF
);
923 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
924 gl_info
->vs_arb_max_temps
= gl_max
;
925 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native temporaries: %d\n", gl_info
->vs_arb_max_temps
);
926 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
927 gl_info
->vs_arb_max_instructions
= gl_max
;
928 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native instructions: %d\n", gl_info
->vs_arb_max_instructions
);
930 gl_info
->arb_vs_offset_limit
= test_arb_vs_offset_limit(gl_info
);
932 if (gl_info
->supported
[ARB_VERTEX_SHADER
]) {
933 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
, &gl_max
);
934 gl_info
->vs_glsl_constantsF
= gl_max
/ 4;
935 TRACE_(d3d_caps
)("Max ARB_VERTEX_SHADER float constants: %u\n", gl_info
->vs_glsl_constantsF
);
937 if (gl_info
->supported
[ARB_FRAGMENT_SHADER
]) {
938 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB
, &gl_max
);
939 gl_info
->ps_glsl_constantsF
= gl_max
/ 4;
940 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_SHADER float constants: %u\n", gl_info
->ps_glsl_constantsF
);
941 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB
, &gl_max
);
942 gl_info
->max_glsl_varyings
= gl_max
;
943 TRACE_(d3d_caps
)("Max GLSL varyings: %u (%u 4 component varyings)\n", gl_max
, gl_max
/ 4);
945 if (gl_info
->supported
[EXT_VERTEX_SHADER
]) {
946 gl_info
->vs_ati_version
= VS_VERSION_11
;
948 if (gl_info
->supported
[NV_VERTEX_PROGRAM3
]) {
949 gl_info
->vs_nv_version
= VS_VERSION_30
;
950 } else if (gl_info
->supported
[NV_VERTEX_PROGRAM2
]) {
951 gl_info
->vs_nv_version
= VS_VERSION_20
;
952 } else if (gl_info
->supported
[NV_VERTEX_PROGRAM1_1
]) {
953 gl_info
->vs_nv_version
= VS_VERSION_11
;
954 } else if (gl_info
->supported
[NV_VERTEX_PROGRAM
]) {
955 gl_info
->vs_nv_version
= VS_VERSION_10
;
957 if (gl_info
->supported
[NV_FRAGMENT_PROGRAM2
]) {
958 gl_info
->ps_nv_version
= PS_VERSION_30
;
959 } else if (gl_info
->supported
[NV_FRAGMENT_PROGRAM
]) {
960 gl_info
->ps_nv_version
= PS_VERSION_20
;
962 if (gl_info
->supported
[NV_LIGHT_MAX_EXPONENT
]) {
963 glGetFloatv(GL_MAX_SHININESS_NV
, &gl_info
->max_shininess
);
965 gl_info
->max_shininess
= 128.0;
967 if (gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
]) {
968 /* If we have full NP2 texture support, disable GL_ARB_texture_rectangle because we will never use it.
969 * This saves a few redundant glDisable calls
971 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = FALSE
;
975 checkGLcall("extension detection\n");
977 /* In some cases the number of texture stages can be larger than the number
978 * of samplers. The GF4 for example can use only 2 samplers (no fragment
979 * shaders), but 8 texture stages (register combiners). */
980 gl_info
->max_sampler_stages
= max(gl_info
->max_fragment_samplers
, gl_info
->max_texture_stages
);
982 /* We can only use ORM_FBO when the hardware supports it. */
983 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& !gl_info
->supported
[EXT_FRAMEBUFFER_OBJECT
]) {
984 WARN_(d3d_caps
)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
985 wined3d_settings
.offscreen_rendering_mode
= ORM_PBUFFER
;
988 /* MRTs are currently only supported when FBOs are used. */
989 if (wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
) {
990 gl_info
->max_buffers
= 1;
993 /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
994 * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
995 * in case of the latest videocards in the number of pixel/vertex pipelines.
997 * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
998 * rendering. Various games use this information to get a rough estimation of the features of the card
999 * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
1000 * games might even use it to work around bugs which happen on certain videocards/driver combinations.
1001 * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
1004 * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
1005 * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
1006 * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
1007 * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
1008 * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
1009 * is used for rendering which is not always the case). This would work but it is not very portable. Second
1010 * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
1013 * As said most games only use the PCI id to get an indication of the capabilities of the card.
1014 * It doesn't really matter if the given id is the correct one if we return the id of a card with
1015 * similar 3d features.
1017 * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
1018 * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
1019 * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
1020 * won't pass we return a default card. This way is better than maintaining a full card database as even
1021 * without a full database we can return a card with similar features. Second the size of the database
1022 * can be made quite small because when you know what type of 3d functionality a card has, you know to which
1023 * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
1024 * to distinguishes between different models from that family.
1026 * The code also selects a default amount of video memory which we will use for an estimation of the amount
1027 * of free texture memory. In case of real D3D the amount of texture memory includes video memory and system
1028 * memory (to be specific AGP memory or in case of PCIE TurboCache/HyperMemory). We don't know how much
1029 * system memory can be addressed by the system but we can make a reasonable estimation about the amount of
1030 * video memory. If the value is slightly wrong it doesn't matter as we didn't include AGP-like memory which
1031 * makes the amount of addressable memory higher and second OpenGL isn't that critical it moves to system
1032 * memory behind our backs if really needed.
1033 * Note that the amount of video memory can be overruled using a registry setting.
1035 switch (gl_info
->gl_vendor
) {
1037 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1038 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1040 if(WINE_D3D9_CAPABLE(gl_info
) && (gl_info
->vs_nv_version
== VS_VERSION_30
)) {
1041 /* Geforce8 - highend */
1042 if (strstr(gl_info
->gl_renderer
, "8800")) {
1043 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8800GTS
;
1044 vidmem
= 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1046 /* Geforce8 - midend mobile */
1047 else if(strstr(gl_info
->gl_renderer
, "8600 M")) {
1048 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8600MGT
;
1051 /* Geforce8 - midend */
1052 else if(strstr(gl_info
->gl_renderer
, "8600") ||
1053 strstr(gl_info
->gl_renderer
, "8700"))
1055 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8600GT
;
1058 /* Geforce8 - lowend */
1059 else if(strstr(gl_info
->gl_renderer
, "8300") ||
1060 strstr(gl_info
->gl_renderer
, "8400") ||
1061 strstr(gl_info
->gl_renderer
, "8500"))
1063 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8300GS
;
1064 vidmem
= 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1066 /* Geforce7 - highend */
1067 else if(strstr(gl_info
->gl_renderer
, "7800") ||
1068 strstr(gl_info
->gl_renderer
, "7900") ||
1069 strstr(gl_info
->gl_renderer
, "7950") ||
1070 strstr(gl_info
->gl_renderer
, "Quadro FX 4") ||
1071 strstr(gl_info
->gl_renderer
, "Quadro FX 5"))
1073 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7800GT
;
1074 vidmem
= 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1076 /* Geforce7 midend */
1077 else if(strstr(gl_info
->gl_renderer
, "7600") ||
1078 strstr(gl_info
->gl_renderer
, "7700")) {
1079 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7600
;
1080 vidmem
= 256; /* The 7600 uses 256-512MB */
1081 /* Geforce7 lower medium */
1082 } else if(strstr(gl_info
->gl_renderer
, "7400")) {
1083 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7400
;
1084 vidmem
= 256; /* The 7400 uses 256-512MB */
1086 /* Geforce7 lowend */
1087 else if(strstr(gl_info
->gl_renderer
, "7300")) {
1088 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7300
;
1089 vidmem
= 256; /* Mac Pros with this card have 256 MB */
1091 /* Geforce6 highend */
1092 else if(strstr(gl_info
->gl_renderer
, "6800"))
1094 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_6800
;
1095 vidmem
= 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1097 /* Geforce6 - midend */
1098 else if(strstr(gl_info
->gl_renderer
, "6600") ||
1099 strstr(gl_info
->gl_renderer
, "6610") ||
1100 strstr(gl_info
->gl_renderer
, "6700"))
1102 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_6600GT
;
1103 vidmem
= 128; /* A 6600GT has 128-256MB */
1105 /* Geforce6/7 lowend */
1107 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_6200
; /* Geforce 6100/6150/6200/7300/7400/7500 */
1110 } else if(WINE_D3D9_CAPABLE(gl_info
)) {
1111 /* GeforceFX - highend */
1112 if (strstr(gl_info
->gl_renderer
, "5800") ||
1113 strstr(gl_info
->gl_renderer
, "5900") ||
1114 strstr(gl_info
->gl_renderer
, "5950") ||
1115 strstr(gl_info
->gl_renderer
, "Quadro FX"))
1117 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5800
;
1118 vidmem
= 256; /* 5800-5900 cards use 256MB */
1120 /* GeforceFX - midend */
1121 else if(strstr(gl_info
->gl_renderer
, "5600") ||
1122 strstr(gl_info
->gl_renderer
, "5650") ||
1123 strstr(gl_info
->gl_renderer
, "5700") ||
1124 strstr(gl_info
->gl_renderer
, "5750"))
1126 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5600
;
1127 vidmem
= 128; /* A 5600 uses 128-256MB */
1129 /* GeforceFX - lowend */
1131 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5200
; /* GeforceFX 5100/5200/5250/5300/5500 */
1132 vidmem
= 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1134 } else if(WINE_D3D8_CAPABLE(gl_info
)) {
1135 if (strstr(gl_info
->gl_renderer
, "GeForce4 Ti") || strstr(gl_info
->gl_renderer
, "Quadro4")) {
1136 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE4_TI4200
; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1137 vidmem
= 64; /* Geforce4 Ti cards have 64-128MB */
1140 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE3
; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1141 vidmem
= 64; /* Geforce3 cards have 64-128MB */
1143 } else if(WINE_D3D7_CAPABLE(gl_info
)) {
1144 if (strstr(gl_info
->gl_renderer
, "GeForce4 MX")) {
1145 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE4_MX
; /* MX420/MX440/MX460/MX4000 */
1146 vidmem
= 64; /* Most Geforce4MX GPUs have at least 64MB of memory, some early models had 32MB but most have 64MB or even 128MB */
1148 else if(strstr(gl_info
->gl_renderer
, "GeForce2 MX") || strstr(gl_info
->gl_renderer
, "Quadro2 MXR")) {
1149 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE2_MX
; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1150 vidmem
= 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1152 else if(strstr(gl_info
->gl_renderer
, "GeForce2") || strstr(gl_info
->gl_renderer
, "Quadro2")) {
1153 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE2
; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1154 vidmem
= 32; /* Geforce2 GPUs have 32-64MB of video memory */
1157 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE
; /* Geforce 256/DDR, Quadro */
1158 vidmem
= 32; /* Most Geforce1 cards have 32MB, there are also some rare 16 and 64MB (Dell) models */
1161 if (strstr(gl_info
->gl_renderer
, "TNT2")) {
1162 gl_info
->gl_card
= CARD_NVIDIA_RIVA_TNT2
; /* Riva TNT2 standard/M64/Pro/Ultra */
1163 vidmem
= 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1166 gl_info
->gl_card
= CARD_NVIDIA_RIVA_TNT
; /* Riva TNT, Vanta */
1167 vidmem
= 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1172 if(WINE_D3D9_CAPABLE(gl_info
)) {
1173 /* Radeon R6xx HD2900 - highend */
1174 if (strstr(gl_info
->gl_renderer
, "HD 2900")) {
1175 gl_info
->gl_card
= CARD_ATI_RADEON_HD2900
;
1176 vidmem
= 512; /* HD2900 uses 512-1024MB */
1178 /* Radeon R6xx HD2600- midend */
1179 else if (strstr(gl_info
->gl_renderer
, "HD 2600")) {
1180 gl_info
->gl_card
= CARD_ATI_RADEON_HD2600
;
1181 vidmem
= 256; /* HD2600 uses 256-512MB */
1183 /* Radeon R6xx HD2300/HD2400 - lowend */
1184 else if (strstr(gl_info
->gl_renderer
, "HD 2300") ||
1185 strstr(gl_info
->gl_renderer
, "HD 2400"))
1187 gl_info
->gl_card
= CARD_ATI_RADEON_HD2300
;
1188 vidmem
= 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1191 else if (strstr(gl_info
->gl_renderer
, "X1600") ||
1192 strstr(gl_info
->gl_renderer
, "X1650") ||
1193 strstr(gl_info
->gl_renderer
, "X1800") ||
1194 strstr(gl_info
->gl_renderer
, "X1900") ||
1195 strstr(gl_info
->gl_renderer
, "X1950"))
1197 gl_info
->gl_card
= CARD_ATI_RADEON_X1600
;
1198 vidmem
= 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1200 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1201 else if(strstr(gl_info
->gl_renderer
, "X700") ||
1202 strstr(gl_info
->gl_renderer
, "X800") ||
1203 strstr(gl_info
->gl_renderer
, "X850") ||
1204 strstr(gl_info
->gl_renderer
, "X1300") ||
1205 strstr(gl_info
->gl_renderer
, "X1400") ||
1206 strstr(gl_info
->gl_renderer
, "X1450") ||
1207 strstr(gl_info
->gl_renderer
, "X1550"))
1209 gl_info
->gl_card
= CARD_ATI_RADEON_X700
;
1210 vidmem
= 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1214 gl_info
->gl_card
= CARD_ATI_RADEON_9500
; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1215 vidmem
= 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1217 } else if(WINE_D3D8_CAPABLE(gl_info
)) {
1218 gl_info
->gl_card
= CARD_ATI_RADEON_8500
; /* Radeon 8500/9000/9100/9200/9300 */
1219 vidmem
= 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1220 } else if(WINE_D3D7_CAPABLE(gl_info
)) {
1221 gl_info
->gl_card
= CARD_ATI_RADEON_7200
; /* Radeon 7000/7100/7200/7500 */
1222 vidmem
= 32; /* There are models with up to 64MB */
1224 gl_info
->gl_card
= CARD_ATI_RAGE_128PRO
;
1225 vidmem
= 16; /* There are 16-32MB models */
1229 if (strstr(gl_info
->gl_renderer
, "GMA 950")) {
1230 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1231 gl_info
->gl_card
= CARD_INTEL_I945GM
;
1233 } else if (strstr(gl_info
->gl_renderer
, "915GM")) {
1234 gl_info
->gl_card
= CARD_INTEL_I915GM
;
1235 } else if (strstr(gl_info
->gl_renderer
, "915G")) {
1236 gl_info
->gl_card
= CARD_INTEL_I915G
;
1237 } else if (strstr(gl_info
->gl_renderer
, "865G")) {
1238 gl_info
->gl_card
= CARD_INTEL_I865G
;
1239 } else if (strstr(gl_info
->gl_renderer
, "855G")) {
1240 gl_info
->gl_card
= CARD_INTEL_I855G
;
1241 } else if (strstr(gl_info
->gl_renderer
, "830G")) {
1242 gl_info
->gl_card
= CARD_INTEL_I830G
;
1244 gl_info
->gl_card
= CARD_INTEL_I915G
;
1250 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1251 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1252 * them a good generic choice.
1254 gl_info
->gl_vendor
= VENDOR_NVIDIA
;
1255 if(WINE_D3D9_CAPABLE(gl_info
))
1256 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5600
;
1257 else if(WINE_D3D8_CAPABLE(gl_info
))
1258 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE3
;
1259 else if(WINE_D3D7_CAPABLE(gl_info
))
1260 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE
;
1261 else if(WINE_D3D6_CAPABLE(gl_info
))
1262 gl_info
->gl_card
= CARD_NVIDIA_RIVA_TNT
;
1264 gl_info
->gl_card
= CARD_NVIDIA_RIVA_128
;
1266 TRACE_(d3d_caps
)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info
->gl_vendor
, gl_info
->gl_card
);
1268 /* If we have an estimate use it, else default to 64MB; */
1270 gl_info
->vidmem
= vidmem
*1024*1024; /* convert from MBs to bytes */
1272 gl_info
->vidmem
= WINE_DEFAULT_VIDMEM
;
1274 /* Load all the lookup tables
1275 TODO: It may be a good idea to make minLookup and maxLookup const and populate them in wined3d_private.h where they are declared */
1276 minLookup
[WINELOOKUP_WARPPARAM
] = WINED3DTADDRESS_WRAP
;
1277 maxLookup
[WINELOOKUP_WARPPARAM
] = WINED3DTADDRESS_MIRRORONCE
;
1279 minLookup
[WINELOOKUP_MAGFILTER
] = WINED3DTEXF_NONE
;
1280 maxLookup
[WINELOOKUP_MAGFILTER
] = WINED3DTEXF_ANISOTROPIC
;
1283 for (i
= 0; i
< MAX_LOOKUPS
; i
++) {
1284 stateLookup
[i
] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup
[i
]) * (1 + maxLookup
[i
] - minLookup
[i
]) );
1287 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_WRAP
- minLookup
[WINELOOKUP_WARPPARAM
]] = GL_REPEAT
;
1288 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_CLAMP
- minLookup
[WINELOOKUP_WARPPARAM
]] = GL_CLAMP_TO_EDGE
;
1289 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_BORDER
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1290 gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
] ? GL_CLAMP_TO_BORDER_ARB
: GL_REPEAT
;
1291 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_BORDER
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1292 gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
] ? GL_CLAMP_TO_BORDER_ARB
: GL_REPEAT
;
1293 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_MIRROR
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1294 gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
] ? GL_MIRRORED_REPEAT_ARB
: GL_REPEAT
;
1295 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_MIRRORONCE
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1296 gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
] ? GL_MIRROR_CLAMP_TO_EDGE_ATI
: GL_REPEAT
;
1298 stateLookup
[WINELOOKUP_MAGFILTER
][WINED3DTEXF_NONE
- minLookup
[WINELOOKUP_MAGFILTER
]] = GL_NEAREST
;
1299 stateLookup
[WINELOOKUP_MAGFILTER
][WINED3DTEXF_POINT
- minLookup
[WINELOOKUP_MAGFILTER
]] = GL_NEAREST
;
1300 stateLookup
[WINELOOKUP_MAGFILTER
][WINED3DTEXF_LINEAR
- minLookup
[WINELOOKUP_MAGFILTER
]] = GL_LINEAR
;
1301 stateLookup
[WINELOOKUP_MAGFILTER
][WINED3DTEXF_ANISOTROPIC
- minLookup
[WINELOOKUP_MAGFILTER
]] =
1302 gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ? GL_LINEAR
: GL_NEAREST
;
1305 minMipLookup
[WINED3DTEXF_NONE
][WINED3DTEXF_NONE
] = GL_LINEAR
;
1306 minMipLookup
[WINED3DTEXF_NONE
][WINED3DTEXF_POINT
] = GL_LINEAR
;
1307 minMipLookup
[WINED3DTEXF_NONE
][WINED3DTEXF_LINEAR
] = GL_LINEAR
;
1308 minMipLookup
[WINED3DTEXF_POINT
][WINED3DTEXF_NONE
] = GL_NEAREST
;
1309 minMipLookup
[WINED3DTEXF_POINT
][WINED3DTEXF_POINT
] = GL_NEAREST_MIPMAP_NEAREST
;
1310 minMipLookup
[WINED3DTEXF_POINT
][WINED3DTEXF_LINEAR
] = GL_NEAREST_MIPMAP_LINEAR
;
1311 minMipLookup
[WINED3DTEXF_LINEAR
][WINED3DTEXF_NONE
] = GL_LINEAR
;
1312 minMipLookup
[WINED3DTEXF_LINEAR
][WINED3DTEXF_POINT
] = GL_LINEAR_MIPMAP_NEAREST
;
1313 minMipLookup
[WINED3DTEXF_LINEAR
][WINED3DTEXF_LINEAR
] = GL_LINEAR_MIPMAP_LINEAR
;
1314 minMipLookup
[WINED3DTEXF_ANISOTROPIC
][WINED3DTEXF_NONE
] = gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ?
1315 GL_LINEAR_MIPMAP_LINEAR
: GL_LINEAR
;
1316 minMipLookup
[WINED3DTEXF_ANISOTROPIC
][WINED3DTEXF_POINT
] = gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ? GL_LINEAR_MIPMAP_NEAREST
: GL_LINEAR
;
1317 minMipLookup
[WINED3DTEXF_ANISOTROPIC
][WINED3DTEXF_LINEAR
] = gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ? GL_LINEAR_MIPMAP_LINEAR
: GL_LINEAR
;
1319 /* TODO: config lookups */
1321 /* Make sure there's an active HDC else the WGL extensions will fail */
1322 hdc
= pwglGetCurrentDC();
1324 WGL_Extensions
= GL_EXTCALL(wglGetExtensionsStringARB(hdc
));
1325 TRACE_(d3d_caps
)("WGL_Extensions reported:\n");
1327 if (NULL
== WGL_Extensions
) {
1328 ERR(" WGL_Extensions returns NULL\n");
1330 while (*WGL_Extensions
!= 0x00) {
1335 while (isspace(*WGL_Extensions
)) WGL_Extensions
++;
1336 Start
= WGL_Extensions
;
1337 while (!isspace(*WGL_Extensions
) && *WGL_Extensions
!= 0x00) {
1341 len
= WGL_Extensions
- Start
;
1342 if (len
== 0 || len
>= sizeof(ThisExtn
))
1345 memcpy(ThisExtn
, Start
, len
);
1346 ThisExtn
[len
] = '\0';
1347 TRACE_(d3d_caps
)("- %s\n", ThisExtn
);
1349 if (!strcmp(ThisExtn
, "WGL_ARB_pbuffer")) {
1350 gl_info
->supported
[WGL_ARB_PBUFFER
] = TRUE
;
1351 TRACE_(d3d_caps
)("FOUND: WGL_ARB_pbuffer support\n");
1358 return return_value
;
1360 #undef GLINFO_LOCATION
1362 /**********************************************************
1363 * IWineD3D implementation follows
1364 **********************************************************/
1366 static UINT WINAPI
IWineD3DImpl_GetAdapterCount (IWineD3D
*iface
) {
1367 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1369 TRACE_(d3d_caps
)("(%p): Reporting %d adapters\n", This
, numAdapters
);
1373 static HRESULT WINAPI
IWineD3DImpl_RegisterSoftwareDevice(IWineD3D
*iface
, void* pInitializeFunction
) {
1374 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1375 FIXME("(%p)->(%p): stub\n", This
, pInitializeFunction
);
1379 static HMONITOR WINAPI
IWineD3DImpl_GetAdapterMonitor(IWineD3D
*iface
, UINT Adapter
) {
1380 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1382 if (Adapter
>= IWineD3DImpl_GetAdapterCount(iface
)) {
1386 TRACE_(d3d_caps
)("(%p)->(%d)\n", This
, Adapter
);
1387 return MonitorFromPoint(Adapters
[Adapter
].monitorPoint
, MONITOR_DEFAULTTOPRIMARY
);
1390 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1391 of the same bpp but different resolutions */
1393 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1394 static UINT WINAPI
IWineD3DImpl_GetAdapterModeCount(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
) {
1395 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1396 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Format: %s)\n", This
, Adapter
, debug_d3dformat(Format
));
1398 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1402 /* TODO: Store modes per adapter and read it from the adapter structure */
1403 if (Adapter
== 0) { /* Display */
1407 if (!DEBUG_SINGLE_MODE
) {
1410 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
1411 DevModeW
.dmSize
= sizeof(DevModeW
);
1412 while (EnumDisplaySettingsExW(NULL
, j
, &DevModeW
, 0)) {
1416 case WINED3DFMT_UNKNOWN
:
1417 /* This is for D3D8, do not enumerate P8 here */
1418 if (DevModeW
.dmBitsPerPel
== 32 ||
1419 DevModeW
.dmBitsPerPel
== 16) i
++;
1421 case WINED3DFMT_X8R8G8B8
:
1422 if (DevModeW
.dmBitsPerPel
== 32) i
++;
1424 case WINED3DFMT_R5G6B5
:
1425 if (DevModeW
.dmBitsPerPel
== 16) i
++;
1428 if (DevModeW
.dmBitsPerPel
== 8) i
++;
1431 /* Skip other modes as they do not match the requested format */
1440 TRACE_(d3d_caps
)("(%p}->(Adapter: %d) => %d (out of %d)\n", This
, Adapter
, i
, j
);
1443 FIXME_(d3d_caps
)("Adapter not primary display\n");
1448 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1449 static HRESULT WINAPI
IWineD3DImpl_EnumAdapterModes(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
, UINT Mode
, WINED3DDISPLAYMODE
* pMode
) {
1450 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1451 TRACE_(d3d_caps
)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This
, Adapter
, Mode
, pMode
, debug_d3dformat(Format
));
1453 /* Validate the parameters as much as possible */
1454 if (NULL
== pMode
||
1455 Adapter
>= IWineD3DImpl_GetAdapterCount(iface
) ||
1456 Mode
>= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, Format
)) {
1457 return WINED3DERR_INVALIDCALL
;
1460 /* TODO: Store modes per adapter and read it from the adapter structure */
1461 if (Adapter
== 0 && !DEBUG_SINGLE_MODE
) { /* Display */
1467 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
1468 DevModeW
.dmSize
= sizeof(DevModeW
);
1470 /* If we are filtering to a specific format (D3D9), then need to skip
1471 all unrelated modes, but if mode is irrelevant (D3D8), then we can
1472 just count through the ones with valid bit depths */
1473 while ((i
<=Mode
) && EnumDisplaySettingsExW(NULL
, j
++, &DevModeW
, 0)) {
1476 case WINED3DFMT_UNKNOWN
:
1477 /* This is D3D8. Do not enumerate P8 here */
1478 if (DevModeW
.dmBitsPerPel
== 32 ||
1479 DevModeW
.dmBitsPerPel
== 16) i
++;
1481 case WINED3DFMT_X8R8G8B8
:
1482 if (DevModeW
.dmBitsPerPel
== 32) i
++;
1484 case WINED3DFMT_R5G6B5
:
1485 if (DevModeW
.dmBitsPerPel
== 16) i
++;
1488 if (DevModeW
.dmBitsPerPel
== 8) i
++;
1491 /* Modes that don't match what we support can get an early-out */
1492 TRACE_(d3d_caps
)("Searching for %s, returning D3DERR_INVALIDCALL\n", debug_d3dformat(Format
));
1493 return WINED3DERR_INVALIDCALL
;
1498 TRACE_(d3d_caps
)("No modes found for format (%x - %s)\n", Format
, debug_d3dformat(Format
));
1499 return WINED3DERR_INVALIDCALL
;
1503 /* Now get the display mode via the calculated index */
1504 if (EnumDisplaySettingsExW(NULL
, ModeIdx
, &DevModeW
, 0)) {
1505 pMode
->Width
= DevModeW
.dmPelsWidth
;
1506 pMode
->Height
= DevModeW
.dmPelsHeight
;
1507 pMode
->RefreshRate
= WINED3DADAPTER_DEFAULT
;
1508 if (DevModeW
.dmFields
& DM_DISPLAYFREQUENCY
)
1509 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
1511 if (Format
== WINED3DFMT_UNKNOWN
) {
1512 pMode
->Format
= pixelformat_for_depth(DevModeW
.dmBitsPerPel
);
1514 pMode
->Format
= Format
;
1517 TRACE_(d3d_caps
)("Requested mode out of range %d\n", Mode
);
1518 return WINED3DERR_INVALIDCALL
;
1521 TRACE_(d3d_caps
)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode
->Width
, pMode
->Height
,
1522 pMode
->RefreshRate
, pMode
->Format
, debug_d3dformat(pMode
->Format
),
1523 DevModeW
.dmBitsPerPel
);
1525 } else if (DEBUG_SINGLE_MODE
) {
1526 /* Return one setting of the format requested */
1527 if (Mode
> 0) return WINED3DERR_INVALIDCALL
;
1529 pMode
->Height
= 600;
1530 pMode
->RefreshRate
= 60;
1531 pMode
->Format
= (Format
== WINED3DFMT_UNKNOWN
) ? WINED3DFMT_X8R8G8B8
: Format
;
1533 FIXME_(d3d_caps
)("Adapter not primary display\n");
1539 static HRESULT WINAPI
IWineD3DImpl_GetAdapterDisplayMode(IWineD3D
*iface
, UINT Adapter
, WINED3DDISPLAYMODE
* pMode
) {
1540 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1541 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, pMode: %p)\n", This
, Adapter
, pMode
);
1543 if (NULL
== pMode
||
1544 Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1545 return WINED3DERR_INVALIDCALL
;
1548 if (Adapter
== 0) { /* Display */
1552 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
1553 DevModeW
.dmSize
= sizeof(DevModeW
);
1555 EnumDisplaySettingsExW(NULL
, ENUM_CURRENT_SETTINGS
, &DevModeW
, 0);
1556 pMode
->Width
= DevModeW
.dmPelsWidth
;
1557 pMode
->Height
= DevModeW
.dmPelsHeight
;
1558 bpp
= DevModeW
.dmBitsPerPel
;
1559 pMode
->RefreshRate
= WINED3DADAPTER_DEFAULT
;
1560 if (DevModeW
.dmFields
&DM_DISPLAYFREQUENCY
)
1562 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
1565 pMode
->Format
= pixelformat_for_depth(bpp
);
1567 FIXME_(d3d_caps
)("Adapter not primary display\n");
1570 TRACE_(d3d_caps
)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode
->Width
,
1571 pMode
->Height
, pMode
->RefreshRate
, debug_d3dformat(pMode
->Format
));
1575 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1576 and fields being inserted in the middle, a new structure is used in place */
1577 static HRESULT WINAPI
IWineD3DImpl_GetAdapterIdentifier(IWineD3D
*iface
, UINT Adapter
, DWORD Flags
,
1578 WINED3DADAPTER_IDENTIFIER
* pIdentifier
) {
1579 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1581 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This
, Adapter
, Flags
, pIdentifier
);
1583 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1584 return WINED3DERR_INVALIDCALL
;
1587 /* Return the information requested */
1588 TRACE_(d3d_caps
)("device/Vendor Name and Version detection using FillGLCaps\n");
1589 strcpy(pIdentifier
->Driver
, Adapters
[Adapter
].driver
);
1590 strcpy(pIdentifier
->Description
, Adapters
[Adapter
].description
);
1592 /* Note dx8 doesn't supply a DeviceName */
1593 if (NULL
!= pIdentifier
->DeviceName
) strcpy(pIdentifier
->DeviceName
, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1594 pIdentifier
->DriverVersion
->u
.HighPart
= Adapters
[Adapter
].gl_info
.driver_version_hipart
;
1595 pIdentifier
->DriverVersion
->u
.LowPart
= Adapters
[Adapter
].gl_info
.driver_version
;
1596 *(pIdentifier
->VendorId
) = Adapters
[Adapter
].gl_info
.gl_vendor
;
1597 *(pIdentifier
->DeviceId
) = Adapters
[Adapter
].gl_info
.gl_card
;
1598 *(pIdentifier
->SubSysId
) = 0;
1599 *(pIdentifier
->Revision
) = 0;
1600 *pIdentifier
->DeviceIdentifier
= IID_D3DDEVICE_D3DUID
;
1602 if (Flags
& WINED3DENUM_NO_WHQL_LEVEL
) {
1603 *(pIdentifier
->WHQLLevel
) = 0;
1605 *(pIdentifier
->WHQLLevel
) = 1;
1611 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const WineD3D_PixelFormat
*cfg
, WINED3DFORMAT Format
) {
1612 short redSize
, greenSize
, blueSize
, alphaSize
, colorBits
;
1617 if(!getColorBits(Format
, &redSize
, &greenSize
, &blueSize
, &alphaSize
, &colorBits
)) {
1618 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format
));
1622 if(cfg
->redSize
< redSize
)
1625 if(cfg
->greenSize
< greenSize
)
1628 if(cfg
->blueSize
< blueSize
)
1631 if(cfg
->alphaSize
< alphaSize
)
1637 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const WineD3D_PixelFormat
*cfg
, WINED3DFORMAT Format
) {
1638 short depthSize
, stencilSize
;
1643 if(!getDepthStencilBits(Format
, &depthSize
, &stencilSize
)) {
1644 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(Format
));
1648 if(cfg
->depthSize
!= depthSize
)
1651 if(cfg
->stencilSize
!= stencilSize
)
1657 static HRESULT WINAPI
IWineD3DImpl_CheckDepthStencilMatch(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
1658 WINED3DFORMAT AdapterFormat
,
1659 WINED3DFORMAT RenderTargetFormat
,
1660 WINED3DFORMAT DepthStencilFormat
) {
1661 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1663 WineD3D_PixelFormat
*cfgs
;
1666 WARN_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1668 DeviceType
, debug_d3ddevicetype(DeviceType
),
1669 AdapterFormat
, debug_d3dformat(AdapterFormat
),
1670 RenderTargetFormat
, debug_d3dformat(RenderTargetFormat
),
1671 DepthStencilFormat
, debug_d3dformat(DepthStencilFormat
));
1673 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1674 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This
, Adapter
, IWineD3D_GetAdapterCount(iface
));
1675 return WINED3DERR_INVALIDCALL
;
1678 cfgs
= Adapters
[Adapter
].cfgs
;
1679 nCfgs
= Adapters
[Adapter
].nCfgs
;
1680 for (it
= 0; it
< nCfgs
; ++it
) {
1681 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs
[it
], RenderTargetFormat
)) {
1682 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs
[it
], DepthStencilFormat
)) {
1683 TRACE_(d3d_caps
)("(%p) : Formats matched\n", This
);
1688 WARN_(d3d_caps
)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat
), debug_d3dformat(DepthStencilFormat
));
1690 return WINED3DERR_NOTAVAILABLE
;
1693 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
1694 WINED3DFORMAT SurfaceFormat
,
1695 BOOL Windowed
, WINED3DMULTISAMPLE_TYPE MultiSampleType
, DWORD
* pQualityLevels
) {
1697 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1698 TRACE_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1701 DeviceType
, debug_d3ddevicetype(DeviceType
),
1702 SurfaceFormat
, debug_d3dformat(SurfaceFormat
),
1707 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1708 return WINED3DERR_INVALIDCALL
;
1711 /* TODO: Store in Adapter structure */
1712 if (pQualityLevels
!= NULL
) {
1713 static int s_single_shot
= 0;
1714 if (!s_single_shot
) {
1715 FIXME("Quality levels unsupported at present\n");
1718 *pQualityLevels
= 1; /* Guess at a value! */
1721 if (WINED3DMULTISAMPLE_NONE
== MultiSampleType
) return WINED3D_OK
;
1722 return WINED3DERR_NOTAVAILABLE
;
1725 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
1726 WINED3DFORMAT DisplayFormat
, WINED3DFORMAT BackBufferFormat
, BOOL Windowed
) {
1728 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1729 HRESULT hr
= WINED3DERR_NOTAVAILABLE
;
1732 TRACE_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1735 DeviceType
, debug_d3ddevicetype(DeviceType
),
1736 DisplayFormat
, debug_d3dformat(DisplayFormat
),
1737 BackBufferFormat
, debug_d3dformat(BackBufferFormat
),
1740 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1741 WARN_(d3d_caps
)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
1742 return WINED3DERR_INVALIDCALL
;
1745 /* The task of this function is to check whether a certain display / backbuffer format
1746 * combination is available on the given adapter. In fullscreen mode microsoft specified
1747 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
1748 * and display format should match exactly.
1749 * In windowed mode format conversion can occur and this depends on the driver. When format
1750 * conversion is done, this function should nevertheless fail and applications need to use
1751 * CheckDeviceFormatConversion.
1752 * At the moment we assume that fullscreen and windowed have the same capabilities */
1754 /* There are only 4 display formats */
1755 if(!((DisplayFormat
== WINED3DFMT_R5G6B5
) ||
1756 (DisplayFormat
== WINED3DFMT_X1R5G5B5
) ||
1757 (DisplayFormat
== WINED3DFMT_X8R8G8B8
) ||
1758 (DisplayFormat
== WINED3DFMT_A2R10G10B10
)))
1760 TRACE_(d3d_caps
)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat
));
1761 return WINED3DERR_NOTAVAILABLE
;
1764 /* If the requested DisplayFormat is not available, don't continue */
1765 nmodes
= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, DisplayFormat
);
1767 TRACE_(d3d_caps
)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat
));
1768 return WINED3DERR_NOTAVAILABLE
;
1771 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
1772 if(!Windowed
&& BackBufferFormat
== WINED3DFMT_UNKNOWN
) {
1773 TRACE_(d3d_caps
)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
1774 return WINED3DERR_NOTAVAILABLE
;
1777 /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
1778 if( (DisplayFormat
== WINED3DFMT_R5G6B5
) && (BackBufferFormat
!= WINED3DFMT_R5G6B5
) ) {
1779 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1780 return WINED3DERR_NOTAVAILABLE
;
1783 /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
1784 if( (DisplayFormat
== WINED3DFMT_X1R5G5B5
) && !((BackBufferFormat
== WINED3DFMT_X1R5G5B5
) || (BackBufferFormat
== WINED3DFMT_A1R5G5B5
)) ) {
1785 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1786 return WINED3DERR_NOTAVAILABLE
;
1789 /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
1790 if( (DisplayFormat
== WINED3DFMT_X8R8G8B8
) && !((BackBufferFormat
== WINED3DFMT_X8R8G8B8
) || (BackBufferFormat
== WINED3DFMT_A8R8G8B8
)) ) {
1791 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1792 return WINED3DERR_NOTAVAILABLE
;
1795 /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
1796 if( (DisplayFormat
== WINED3DFMT_A2R10G10B10
) && ((BackBufferFormat
!= WINED3DFMT_A2R10G10B10
) || Windowed
)) {
1797 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1798 return WINED3DERR_NOTAVAILABLE
;
1801 /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
1802 hr
= IWineD3DImpl_CheckDeviceFormat(iface
, Adapter
, DeviceType
, DisplayFormat
, WINED3DUSAGE_RENDERTARGET
, WINED3DRTYPE_SURFACE
, BackBufferFormat
);
1804 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1810 #define GLINFO_LOCATION Adapters[Adapter].gl_info
1811 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
1812 static BOOL
CheckDepthStencilCapability(UINT Adapter
, WINED3DFORMAT DisplayFormat
,
1813 WINED3DFORMAT DepthStencilFormat
)
1816 WineD3D_PixelFormat
*cfgs
= Adapters
[Adapter
].cfgs
;
1818 /* Only allow depth/stencil formats */
1819 switch (DepthStencilFormat
) {
1820 case WINED3DFMT_D16_LOCKABLE
:
1821 case WINED3DFMT_D16
:
1822 case WINED3DFMT_D15S1
:
1823 case WINED3DFMT_D24X8
:
1824 case WINED3DFMT_D24X4S4
:
1825 case WINED3DFMT_D24S8
:
1826 case WINED3DFMT_D24FS8
:
1827 case WINED3DFMT_D32
:
1828 case WINED3DFMT_D32F_LOCKABLE
:
1835 /* Walk through all WGL pixel formats to find a match */
1836 cfgs
= Adapters
[Adapter
].cfgs
;
1837 for (it
= 0; it
< Adapters
[Adapter
].nCfgs
; ++it
) {
1838 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs
[it
], DisplayFormat
)) {
1839 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&cfgs
[it
], DepthStencilFormat
)) {
1848 /* Check the render target capabilities of a format */
1849 static BOOL
CheckRenderTargetCapability(WINED3DFORMAT AdapterFormat
, WINED3DFORMAT CheckFormat
)
1853 /* Filter out non-RT formats */
1856 /* Don't offer 8bit, windows doesn't either although we could emulate it */
1857 case WINED3DFMT_A8P8
:
1860 /* No DXTC render targets */
1861 case WINED3DFMT_DXT1
:
1862 case WINED3DFMT_DXT2
:
1863 case WINED3DFMT_DXT3
:
1864 case WINED3DFMT_DXT4
:
1865 case WINED3DFMT_DXT5
:
1871 if(wined3d_settings
.offscreen_rendering_mode
== ORM_BACKBUFFER
) {
1872 WineD3D_PixelFormat
*cfgs
= Adapters
[Adapter
].cfgs
;
1874 short AdapterRed
, AdapterGreen
, AdapterBlue
, AdapterAlpha
, AdapterTotalSize
;
1875 short CheckRed
, CheckGreen
, CheckBlue
, CheckAlpha
, CheckTotalSize
;
1877 getColorBits(AdapterFormat
, &AdapterRed
, &AdapterGreen
, &AdapterBlue
, &AdapterAlpha
, &AdapterTotalSize
);
1878 getColorBits(CheckFormat
, &CheckRed
, &CheckGreen
, &CheckBlue
, &CheckAlpha
, &CheckTotalSize
);
1880 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
1881 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
1882 if(!((AdapterRed
== CheckRed
) && (AdapterGreen
== CheckGreen
) && (AdapterBlue
== CheckBlue
))) {
1883 TRACE_(d3d_caps
)("[FAILED]\n");
1887 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
1888 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
1889 for (it
= 0; it
< Adapters
[Adapter
].nCfgs
; ++it
) {
1890 if (cfgs
[it
].windowDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs
[it
], CheckFormat
)) {
1891 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs
[it
].iPixelFormat
, debug_d3dformat(CheckFormat
));
1895 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_PBUFFER
) {
1896 /* We can propably use this function in FBO mode too on some drivers to get some basic indication of the capabilities. */
1897 WineD3D_PixelFormat
*cfgs
= Adapters
[Adapter
].cfgs
;
1900 /* Check if there is a WGL pixel format matching the requirements, the pixel format should also be usable with pbuffers */
1901 for (it
= 0; it
< Adapters
[Adapter
].nCfgs
; ++it
) {
1902 if (cfgs
[it
].pbufferDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&cfgs
[it
], CheckFormat
)) {
1903 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n", cfgs
[it
].iPixelFormat
, debug_d3dformat(CheckFormat
));
1907 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
){
1908 /* For now return TRUE for FBOs until we have some proper checks.
1909 * Note that this function will only be called when the format is around for texturing. */
1915 /* Check if a texture format is supported on the given adapter */
1916 static BOOL
CheckTextureCapability(UINT Adapter
, WINED3DFORMAT CheckFormat
)
1918 switch (CheckFormat
) {
1921 * supported: RGB(A) formats
1923 case WINED3DFMT_R8G8B8
: /* Enable for dx7, blacklisted for 8 and 9 above */
1924 case WINED3DFMT_A8R8G8B8
:
1925 case WINED3DFMT_X8R8G8B8
:
1926 case WINED3DFMT_R5G6B5
:
1927 case WINED3DFMT_X1R5G5B5
:
1928 case WINED3DFMT_A1R5G5B5
:
1929 case WINED3DFMT_A4R4G4B4
:
1930 case WINED3DFMT_R3G3B2
:
1932 case WINED3DFMT_X4R4G4B4
:
1933 case WINED3DFMT_A8B8G8R8
:
1934 case WINED3DFMT_X8B8G8R8
:
1935 case WINED3DFMT_A2R10G10B10
:
1936 case WINED3DFMT_A2B10G10R10
:
1937 case WINED3DFMT_G16R16
:
1938 TRACE_(d3d_caps
)("[OK]\n");
1942 * supported: Palettized
1945 TRACE_(d3d_caps
)("[OK]\n");
1947 /* No Windows driver offers A8P8, so don't offer it either */
1948 case WINED3DFMT_A8P8
:
1952 * Supported: (Alpha)-Luminance
1955 case WINED3DFMT_A8L8
:
1956 case WINED3DFMT_A4L4
:
1957 case WINED3DFMT_L16
:
1958 TRACE_(d3d_caps
)("[OK]\n");
1961 /* Depth/stencil is handled using checkDepthStencilCapability, return FALSE here */
1962 case WINED3DFMT_D16_LOCKABLE
:
1963 case WINED3DFMT_D16
:
1964 case WINED3DFMT_D15S1
:
1965 case WINED3DFMT_D24X8
:
1966 case WINED3DFMT_D24X4S4
:
1967 case WINED3DFMT_D24S8
:
1968 case WINED3DFMT_D24FS8
:
1969 case WINED3DFMT_D32
:
1970 case WINED3DFMT_D32F_LOCKABLE
:
1974 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
1975 * GL_NV_texture_shader), but advertized to make apps happy.
1976 * Enable some because games often fail when they are not available
1977 * and are still playable even without bump mapping
1979 case WINED3DFMT_V8U8
:
1980 if(GL_SUPPORT(NV_TEXTURE_SHADER
) || GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
1983 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
1986 case WINED3DFMT_X8L8V8U8
:
1987 case WINED3DFMT_L6V5U5
:
1988 WARN_(d3d_caps
)("[FAILED]\n");
1991 case WINED3DFMT_Q8W8V8U8
:
1992 case WINED3DFMT_V16U16
:
1993 if(GL_SUPPORT(NV_TEXTURE_SHADER
)) {
1994 WARN_(d3d_caps
)("[Not supported, but pretended to do]\n");
1997 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
2000 /* Those are not advertized by the nvidia windows driver, and not
2001 * supported natively by GL_NV_texture_shader or GL_ATI_envmap_bumpmap.
2002 * WINED3DFMT_A2W10V10U10 could be loaded into shaders using the unsigned
2003 * ARGB format if needed
2005 case WINED3DFMT_W11V11U10
:
2006 case WINED3DFMT_A2W10V10U10
:
2007 WARN_(d3d_caps
)("[FAILED]\n");
2010 case WINED3DFMT_DXT1
:
2011 case WINED3DFMT_DXT2
:
2012 case WINED3DFMT_DXT3
:
2013 case WINED3DFMT_DXT4
:
2014 case WINED3DFMT_DXT5
:
2015 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
2016 TRACE_(d3d_caps
)("[OK]\n");
2019 TRACE_(d3d_caps
)("[FAILED]\n");
2024 * Odd formats - not supported
2026 case WINED3DFMT_VERTEXDATA
:
2027 case WINED3DFMT_INDEX16
:
2028 case WINED3DFMT_INDEX32
:
2029 case WINED3DFMT_Q16W16V16U16
:
2030 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2034 * WINED3DFMT_CxV8U8: Not supported right now
2036 case WINED3DFMT_CxV8U8
:
2037 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2040 /* YUV formats, not supported for now */
2041 case WINED3DFMT_UYVY
:
2042 case WINED3DFMT_YUY2
:
2043 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2047 case WINED3DFMT_A16B16G16R16
:
2048 case WINED3DFMT_A8R3G3B2
:
2049 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2052 /* Floating point formats */
2053 case WINED3DFMT_R16F
:
2054 case WINED3DFMT_A16B16G16R16F
:
2055 if(GL_SUPPORT(ARB_HALF_FLOAT_PIXEL
)) {
2056 TRACE_(d3d_caps
)("[OK]\n");
2059 TRACE_(d3d_caps
)("[FAILED]\n");
2062 case WINED3DFMT_R32F
:
2063 case WINED3DFMT_A32B32G32R32F
:
2064 if (GL_SUPPORT(ARB_TEXTURE_FLOAT
)) {
2065 TRACE_(d3d_caps
)("[OK]\n");
2068 TRACE_(d3d_caps
)("[FAILED]\n");
2071 case WINED3DFMT_G16R16F
:
2072 case WINED3DFMT_G32R32F
:
2073 TRACE_(d3d_caps
)("[FAILED]\n");
2076 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
2077 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
2078 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
2079 * We can do instancing with all shader versions, but we need vertex shaders.
2081 * Additionally applications have to set the D3DRS_POINTSIZE render state to
2082 MAKEFOURCC('I','N','S','T') once
2083 * to enable instancing. WineD3D doesn't need that and just ignores it.
2085 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
2087 case WINEMAKEFOURCC('I','N','S','T'):
2088 TRACE("ATI Instancing check hack\n");
2089 if(GL_SUPPORT(ARB_VERTEX_PROGRAM
) || GL_SUPPORT(ARB_VERTEX_SHADER
)) {
2090 TRACE_(d3d_caps
)("[OK]\n");
2093 TRACE_(d3d_caps
)("[FAILED]\n");
2096 /* Some weird FOURCC formats */
2097 case WINED3DFMT_R8G8_B8G8
:
2098 case WINED3DFMT_G8R8_G8B8
:
2099 case WINED3DFMT_MULTI2_ARGB8
:
2100 TRACE_(d3d_caps
)("[FAILED]\n");
2103 case WINED3DFMT_UNKNOWN
:
2107 ERR("Unhandled format=%s\n", debug_d3dformat(CheckFormat
));
2113 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2114 WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
) {
2115 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2116 DWORD UsageCaps
= 0;
2118 TRACE_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
2121 DeviceType
, debug_d3ddevicetype(DeviceType
),
2122 AdapterFormat
, debug_d3dformat(AdapterFormat
),
2123 Usage
, debug_d3dusage(Usage
), debug_d3dusagequery(Usage
),
2124 RType
, debug_d3dresourcetype(RType
),
2125 CheckFormat
, debug_d3dformat(CheckFormat
));
2127 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2128 return WINED3DERR_INVALIDCALL
;
2131 if (Usage
& WINED3DUSAGE_QUERY_FILTER
) {
2132 switch (CheckFormat
) {
2133 /* Filtering not supported */
2134 case WINED3DFMT_R32F
:
2135 case WINED3DFMT_A32B32G32R32F
:
2136 TRACE_(d3d_caps
)("[FAILED]\n");
2137 return WINED3DERR_NOTAVAILABLE
;
2143 if (Usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
2144 if(!GL_SUPPORT(SGIS_GENERATE_MIPMAP
)) {
2145 TRACE_(d3d_caps
)("[FAILED] - No mipmap generation support\n");
2146 return WINED3DERR_NOTAVAILABLE
;
2150 if(RType
== WINED3DRTYPE_CUBETEXTURE
) {
2151 /* Cubetexture allows:
2152 * - D3DUSAGE_AUTOGENMIPMAP
2153 * - D3DUSAGE_DEPTHSTENCIL
2154 * - D3DUSAGE_DYNAMIC
2155 * - D3DUSAGE_NONSECURE (d3d9ex)
2156 * - D3DUSAGE_RENDERTARGET
2157 * - D3DUSAGE_SOFTWAREPROCESSING
2159 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2160 /* Check if the texture format is around */
2161 if(CheckTextureCapability(Adapter
, CheckFormat
)) {
2162 /* No usage checks were requested, so return because we know that the format is supported */
2166 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
2167 if(CheckRenderTargetCapability(AdapterFormat
, CheckFormat
)) {
2168 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
2170 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
2171 return WINED3DERR_NOTAVAILABLE
;
2176 } else if(RType
== WINED3DRTYPE_SURFACE
) {
2178 * - D3DUSAGE_DEPTHSTENCIL
2179 * - D3DUSAGE_NONSECURE (d3d9ex)
2180 * - D3DUSAGE_RENDERTARGET
2183 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
2184 if(CheckDepthStencilCapability(Adapter
, AdapterFormat
, CheckFormat
)) {
2185 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
2187 TRACE_(d3d_caps
)("[FAILED] - No depthstencil support\n");
2188 return WINED3DERR_NOTAVAILABLE
;
2192 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
2193 if(CheckRenderTargetCapability(AdapterFormat
, CheckFormat
)) {
2194 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
2196 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
2197 return WINED3DERR_NOTAVAILABLE
;
2200 } else if(RType
== WINED3DRTYPE_TEXTURE
) {
2202 * - D3DUSAGE_AUTOGENMIPMAP
2203 * - D3DUSAGE_DEPTHSTENCIL
2205 * - D3DUSAGE_DYNAMIC
2206 * - D3DUSAGE_NONSECURE (d3d9ex)
2207 * - D3DUSAGE_RENDERTARGET
2208 * - D3DUSAGE_SOFTWAREPROCESSING
2209 * - D3DUSAGE_TEXTAPI (d3d9ex)
2212 /* Check if the texture format is around */
2213 if(CheckTextureCapability(Adapter
, CheckFormat
)) {
2214 /* No usage checks were requested, so return because we know that the format is supported */
2218 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
2219 if(CheckRenderTargetCapability(AdapterFormat
, CheckFormat
)) {
2220 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
2222 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
2223 return WINED3DERR_NOTAVAILABLE
;
2226 } else if(CheckDepthStencilCapability(Adapter
, AdapterFormat
, CheckFormat
)) {
2227 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
)
2228 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
2230 } else if(RType
== WINED3DRTYPE_VOLUMETEXTURE
) {
2231 /* Check volume texture and volume usage caps */
2232 if(GL_SUPPORT(EXT_TEXTURE3D
)) {
2233 if(CheckTextureCapability(Adapter
, CheckFormat
) == FALSE
) {
2234 TRACE_(d3d_caps
)("[FAILED] - Format not supported\n");
2235 return WINED3DERR_NOTAVAILABLE
;
2239 /* Filter formats that need conversion; For one part, this conversion is unimplemented,
2240 * and volume textures are huge, so it would be a big performance hit. Unless we hit an
2241 * app needing one of those formats, don't advertize them to avoid leading apps into
2242 * temptation. The windows drivers don't support most of those formats on volumes anyway,
2245 switch(CheckFormat
) {
2247 case WINED3DFMT_A4L4
:
2248 case WINED3DFMT_R32F
:
2249 case WINED3DFMT_R16F
:
2250 case WINED3DFMT_X8L8V8U8
:
2251 case WINED3DFMT_L6V5U5
:
2252 case WINED3DFMT_G16R16
:
2253 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
2254 return WINED3DERR_NOTAVAILABLE
;
2256 case WINED3DFMT_Q8W8V8U8
:
2257 case WINED3DFMT_V16U16
:
2258 if(!GL_SUPPORT(NV_TEXTURE_SHADER
)) {
2259 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
2260 return WINED3DERR_NOTAVAILABLE
;
2264 case WINED3DFMT_V8U8
:
2265 if(!GL_SUPPORT(NV_TEXTURE_SHADER
) || !GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
2266 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
2267 return WINED3DERR_NOTAVAILABLE
;
2271 case WINED3DFMT_DXT1
:
2272 case WINED3DFMT_DXT2
:
2273 case WINED3DFMT_DXT3
:
2274 case WINED3DFMT_DXT4
:
2275 case WINED3DFMT_DXT5
:
2276 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
2277 * compressed texture results in an error. While the D3D refrast does
2278 * support s3tc volumes, at least the nvidia windows driver does not, so
2279 * we're free not to support this format.
2281 TRACE_(d3d_caps
)("[FAILED] - DXTn does not support 3D textures\n");
2282 return WINED3DERR_NOTAVAILABLE
;
2285 /* Do nothing, continue with checking the format below */
2289 /* TODO: Check support against more of the WINED3DUSAGE_QUERY_* constants */
2290 if (Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
2291 if (!GL_LIMITS(vertex_samplers
)) {
2292 TRACE_(d3d_caps
)("[FAILED]\n");
2293 return WINED3DERR_NOTAVAILABLE
;
2296 switch (CheckFormat
) {
2297 case WINED3DFMT_A32B32G32R32F
:
2298 if (!GL_SUPPORT(ARB_TEXTURE_FLOAT
)) {
2299 TRACE_(d3d_caps
)("[FAILED]\n");
2300 return WINED3DERR_NOTAVAILABLE
;
2302 TRACE_(d3d_caps
)("[OK]\n");
2306 TRACE_(d3d_caps
)("[FAILED]\n");
2307 return WINED3DERR_NOTAVAILABLE
;
2311 if(Usage
& WINED3DUSAGE_QUERY_LEGACYBUMPMAP
) {
2312 if(GL_SUPPORT(NV_REGISTER_COMBINERS
) && GL_SUPPORT(NV_TEXTURE_SHADER2
)) {
2313 switch (CheckFormat
) {
2314 case WINED3DFMT_V8U8
:
2315 TRACE_(d3d_caps
)("[OK]\n");
2317 /* TODO: Other bump map formats */
2319 TRACE_(d3d_caps
)("[FAILED]\n");
2320 return WINED3DERR_NOTAVAILABLE
;
2323 if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
2324 switch (CheckFormat
) {
2325 case WINED3DFMT_V8U8
:
2326 TRACE_(d3d_caps
)("[OK]\n");
2329 TRACE_(d3d_caps
)("[FAILED]\n");
2330 return WINED3DERR_NOTAVAILABLE
;
2333 TRACE_(d3d_caps
)("[FAILED]\n");
2334 return WINED3DERR_NOTAVAILABLE
;
2337 /* Check for supported sRGB formats (Texture loading and framebuffer) */
2338 if (Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
2339 if(!GL_SUPPORT(EXT_TEXTURE_SRGB
)) {
2340 TRACE_(d3d_caps
)("[FAILED] GL_EXT_texture_sRGB not supported\n");
2343 switch (CheckFormat
) {
2344 case WINED3DFMT_A8R8G8B8
:
2345 case WINED3DFMT_X8R8G8B8
:
2346 case WINED3DFMT_A4R4G4B4
:
2348 case WINED3DFMT_A8L8
:
2349 case WINED3DFMT_DXT1
:
2350 case WINED3DFMT_DXT2
:
2351 case WINED3DFMT_DXT3
:
2352 case WINED3DFMT_DXT4
:
2353 case WINED3DFMT_DXT5
:
2354 TRACE_(d3d_caps
)("[OK]\n");
2355 break; /* Continue with checking other flags */
2358 TRACE_(d3d_caps
)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(CheckFormat
));
2359 return WINED3DERR_NOTAVAILABLE
;
2363 /* This format is nothing special and it is supported perfectly.
2364 * However, ati and nvidia driver on windows do not mark this format as
2365 * supported (tested with the dxCapsViewer) and pretending to
2366 * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
2367 * So do the same as Windows drivers and pretend not to support it on dx8 and 9
2368 * Enable it on dx7. It will need additional checking on dx10 when we support it.
2370 if(This
->dxVersion
> 7 && CheckFormat
== WINED3DFMT_R8G8B8
) {
2371 TRACE_(d3d_caps
)("[FAILED]\n");
2372 return WINED3DERR_NOTAVAILABLE
;
2375 switch (CheckFormat
) {
2378 * supported: RGB(A) formats
2380 case WINED3DFMT_R8G8B8
: /* Enable for dx7, blacklisted for 8 and 9 above */
2381 case WINED3DFMT_A8R8G8B8
:
2382 case WINED3DFMT_X8R8G8B8
:
2383 case WINED3DFMT_R5G6B5
:
2384 case WINED3DFMT_X1R5G5B5
:
2385 case WINED3DFMT_A1R5G5B5
:
2386 case WINED3DFMT_A4R4G4B4
:
2387 case WINED3DFMT_R3G3B2
:
2389 case WINED3DFMT_X4R4G4B4
:
2390 case WINED3DFMT_A8B8G8R8
:
2391 case WINED3DFMT_X8B8G8R8
:
2392 case WINED3DFMT_A2R10G10B10
:
2393 case WINED3DFMT_A2B10G10R10
:
2394 case WINED3DFMT_G16R16
:
2395 TRACE_(d3d_caps
)("[OK]\n");
2399 * supported: Palettized
2402 TRACE_(d3d_caps
)("[OK]\n");
2406 * Supported: (Alpha)-Luminance
2409 case WINED3DFMT_A8L8
:
2410 case WINED3DFMT_A4L4
:
2411 TRACE_(d3d_caps
)("[OK]\n");
2415 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
2416 * GL_NV_texture_shader), but advertized to make apps happy.
2417 * Enable some because games often fail when they are not available
2418 * and are still playable even without bump mapping
2420 case WINED3DFMT_V8U8
:
2421 case WINED3DFMT_V16U16
:
2422 case WINED3DFMT_L6V5U5
:
2423 case WINED3DFMT_X8L8V8U8
:
2424 case WINED3DFMT_Q8W8V8U8
:
2425 WARN_(d3d_caps
)("[Not supported, but pretended to do]\n");
2428 /* Those are not advertized by the nvidia windows driver, and not
2429 * supported natively by GL_NV_texture_shader or GL_ATI_envmap_bumpmap.
2430 * WINED3DFMT_A2W10V10U10 could be loaded into shaders using the unsigned
2431 * ARGB format if needed
2433 case WINED3DFMT_W11V11U10
:
2434 case WINED3DFMT_A2W10V10U10
:
2435 WARN_(d3d_caps
)("[FAILED]\n");
2436 return WINED3DERR_NOTAVAILABLE
;
2438 case WINED3DFMT_DXT1
:
2439 case WINED3DFMT_DXT2
:
2440 case WINED3DFMT_DXT3
:
2441 case WINED3DFMT_DXT4
:
2442 case WINED3DFMT_DXT5
:
2443 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
2444 TRACE_(d3d_caps
)("[OK]\n");
2447 TRACE_(d3d_caps
)("[FAILED]\n");
2448 return WINED3DERR_NOTAVAILABLE
;
2453 * Odd formats - not supported
2455 case WINED3DFMT_VERTEXDATA
:
2456 case WINED3DFMT_INDEX16
:
2457 case WINED3DFMT_INDEX32
:
2458 case WINED3DFMT_Q16W16V16U16
:
2459 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2460 return WINED3DERR_NOTAVAILABLE
;
2463 * WINED3DFMT_CxV8U8: Not supported right now
2465 case WINED3DFMT_CxV8U8
:
2466 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2467 return WINED3DERR_NOTAVAILABLE
;
2470 case WINED3DFMT_A16B16G16R16
:
2471 case WINED3DFMT_A8R3G3B2
:
2472 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2473 return WINED3DERR_NOTAVAILABLE
;
2475 /* Floating point formats */
2476 case WINED3DFMT_R16F
:
2477 case WINED3DFMT_A16B16G16R16F
:
2478 if(GL_SUPPORT(ARB_HALF_FLOAT_PIXEL
)) {
2479 TRACE_(d3d_caps
)("[OK]\n");
2482 TRACE_(d3d_caps
)("[FAILED]\n");
2483 return WINED3DERR_NOTAVAILABLE
;
2485 case WINED3DFMT_R32F
:
2486 case WINED3DFMT_A32B32G32R32F
:
2487 if (GL_SUPPORT(ARB_TEXTURE_FLOAT
)) {
2488 TRACE_(d3d_caps
)("[OK]\n");
2491 TRACE_(d3d_caps
)("[FAILED]\n");
2492 return WINED3DERR_NOTAVAILABLE
;
2495 case WINED3DFMT_G16R16F
:
2496 case WINED3DFMT_G32R32F
:
2497 TRACE_(d3d_caps
)("[FAILED]\n");
2498 return WINED3DERR_NOTAVAILABLE
;
2500 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
2501 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
2502 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
2503 * We can do instancing with all shader versions, but we need vertex shaders.
2505 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
2506 * to enable instancing. WineD3D doesn't need that and just ignores it.
2508 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
2510 case WINEMAKEFOURCC('I','N','S','T'):
2511 TRACE("ATI Instancing check hack\n");
2512 if(GL_SUPPORT(ARB_VERTEX_PROGRAM
) || GL_SUPPORT(ARB_VERTEX_SHADER
)) {
2513 TRACE_(d3d_caps
)("[OK]\n");
2516 TRACE_(d3d_caps
)("[FAILED]\n");
2517 return WINED3DERR_NOTAVAILABLE
;
2526 TRACE_(d3d_caps
)("[FAILED]\n");
2527 return WINED3DERR_NOTAVAILABLE
;
2530 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2531 WINED3DFORMAT SourceFormat
, WINED3DFORMAT TargetFormat
) {
2532 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2534 FIXME_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
2537 DeviceType
, debug_d3ddevicetype(DeviceType
),
2538 SourceFormat
, debug_d3dformat(SourceFormat
),
2539 TargetFormat
, debug_d3dformat(TargetFormat
));
2543 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
2544 subset of a D3DCAPS9 structure. However, it has to come via a void *
2545 as the d3d8 interface cannot import the d3d9 header */
2546 static HRESULT WINAPI
IWineD3DImpl_GetDeviceCaps(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DCAPS
* pCaps
) {
2548 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2549 int vs_selected_mode
;
2550 int ps_selected_mode
;
2552 TRACE_(d3d_caps
)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This
, Adapter
, DeviceType
, pCaps
);
2554 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2555 return WINED3DERR_INVALIDCALL
;
2558 select_shader_mode(&Adapters
[Adapter
].gl_info
, DeviceType
, &ps_selected_mode
, &vs_selected_mode
);
2560 /* This function should *not* be modifying GL caps
2561 * TODO: move the functionality where it belongs */
2562 select_shader_max_constants(ps_selected_mode
, vs_selected_mode
, &Adapters
[Adapter
].gl_info
);
2564 /* ------------------------------------------------
2565 The following fields apply to both d3d8 and d3d9
2566 ------------------------------------------------ */
2567 *pCaps
->DeviceType
= (DeviceType
== WINED3DDEVTYPE_HAL
) ? WINED3DDEVTYPE_HAL
: WINED3DDEVTYPE_REF
; /* Not quite true, but use h/w supported by opengl I suppose */
2568 *pCaps
->AdapterOrdinal
= Adapter
;
2571 *pCaps
->Caps2
= WINED3DCAPS2_CANRENDERWINDOWED
|
2572 WINED3DCAPS2_FULLSCREENGAMMA
|
2573 WINED3DCAPS2_DYNAMICTEXTURES
;
2574 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP
)) {
2575 *pCaps
->Caps2
|= WINED3DCAPS2_CANAUTOGENMIPMAP
;
2577 *pCaps
->Caps3
= WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD
;
2578 *pCaps
->PresentationIntervals
= WINED3DPRESENT_INTERVAL_IMMEDIATE
|
2579 WINED3DPRESENT_INTERVAL_ONE
;
2581 *pCaps
->CursorCaps
= WINED3DCURSORCAPS_COLOR
|
2582 WINED3DCURSORCAPS_LOWRES
;
2584 *pCaps
->DevCaps
= WINED3DDEVCAPS_FLOATTLVERTEX
|
2585 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY
|
2586 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY
|
2587 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY
|
2588 WINED3DDEVCAPS_DRAWPRIMTLVERTEX
|
2589 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT
|
2590 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY
|
2591 WINED3DDEVCAPS_PUREDEVICE
|
2592 WINED3DDEVCAPS_HWRASTERIZATION
|
2593 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY
|
2594 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY
|
2595 WINED3DDEVCAPS_CANRENDERAFTERFLIP
|
2596 WINED3DDEVCAPS_DRAWPRIMITIVES2
|
2597 WINED3DDEVCAPS_DRAWPRIMITIVES2EX
|
2598 WINED3DDEVCAPS_RTPATCHES
;
2600 *pCaps
->PrimitiveMiscCaps
= WINED3DPMISCCAPS_CULLNONE
|
2601 WINED3DPMISCCAPS_CULLCCW
|
2602 WINED3DPMISCCAPS_CULLCW
|
2603 WINED3DPMISCCAPS_COLORWRITEENABLE
|
2604 WINED3DPMISCCAPS_CLIPTLVERTS
|
2605 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS
|
2606 WINED3DPMISCCAPS_MASKZ
|
2607 WINED3DPMISCCAPS_BLENDOP
;
2609 WINED3DPMISCCAPS_NULLREFERENCE
2610 WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
2611 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
2612 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
2613 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING
2614 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
2616 if(GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE
) && GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE
))
2617 *pCaps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_SEPARATEALPHABLEND
;
2619 /* The caps below can be supported but aren't handled yet in utils.c 'd3dta_to_combiner_input', disable them until support is fixed */
2621 if (GL_SUPPORT(NV_REGISTER_COMBINERS
))
2622 *pCaps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_TSSARGTEMP
;
2623 if (GL_SUPPORT(NV_REGISTER_COMBINERS2
))
2624 *pCaps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_PERSTAGECONSTANT
;
2627 *pCaps
->RasterCaps
= WINED3DPRASTERCAPS_DITHER
|
2628 WINED3DPRASTERCAPS_PAT
|
2629 WINED3DPRASTERCAPS_WFOG
|
2630 WINED3DPRASTERCAPS_ZFOG
|
2631 WINED3DPRASTERCAPS_FOGVERTEX
|
2632 WINED3DPRASTERCAPS_FOGTABLE
|
2633 WINED3DPRASTERCAPS_STIPPLE
|
2634 WINED3DPRASTERCAPS_SUBPIXEL
|
2635 WINED3DPRASTERCAPS_ZTEST
|
2636 WINED3DPRASTERCAPS_SCISSORTEST
|
2637 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS
|
2638 WINED3DPRASTERCAPS_DEPTHBIAS
;
2640 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
)) {
2641 *pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_ANISOTROPY
|
2642 WINED3DPRASTERCAPS_ZBIAS
|
2643 WINED3DPRASTERCAPS_MIPMAPLODBIAS
;
2645 if(GL_SUPPORT(NV_FOG_DISTANCE
)) {
2646 *pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_FOGRANGE
;
2649 WINED3DPRASTERCAPS_COLORPERSPECTIVE
2650 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
2651 WINED3DPRASTERCAPS_ANTIALIASEDGES
2652 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
2653 WINED3DPRASTERCAPS_WBUFFER */
2655 *pCaps
->ZCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
2656 WINED3DPCMPCAPS_EQUAL
|
2657 WINED3DPCMPCAPS_GREATER
|
2658 WINED3DPCMPCAPS_GREATEREQUAL
|
2659 WINED3DPCMPCAPS_LESS
|
2660 WINED3DPCMPCAPS_LESSEQUAL
|
2661 WINED3DPCMPCAPS_NEVER
|
2662 WINED3DPCMPCAPS_NOTEQUAL
;
2664 *pCaps
->SrcBlendCaps
= WINED3DPBLENDCAPS_BOTHINVSRCALPHA
|
2665 WINED3DPBLENDCAPS_BOTHSRCALPHA
|
2666 WINED3DPBLENDCAPS_DESTALPHA
|
2667 WINED3DPBLENDCAPS_DESTCOLOR
|
2668 WINED3DPBLENDCAPS_INVDESTALPHA
|
2669 WINED3DPBLENDCAPS_INVDESTCOLOR
|
2670 WINED3DPBLENDCAPS_INVSRCALPHA
|
2671 WINED3DPBLENDCAPS_INVSRCCOLOR
|
2672 WINED3DPBLENDCAPS_ONE
|
2673 WINED3DPBLENDCAPS_SRCALPHA
|
2674 WINED3DPBLENDCAPS_SRCALPHASAT
|
2675 WINED3DPBLENDCAPS_SRCCOLOR
|
2676 WINED3DPBLENDCAPS_ZERO
;
2678 *pCaps
->DestBlendCaps
= WINED3DPBLENDCAPS_DESTALPHA
|
2679 WINED3DPBLENDCAPS_DESTCOLOR
|
2680 WINED3DPBLENDCAPS_INVDESTALPHA
|
2681 WINED3DPBLENDCAPS_INVDESTCOLOR
|
2682 WINED3DPBLENDCAPS_INVSRCALPHA
|
2683 WINED3DPBLENDCAPS_INVSRCCOLOR
|
2684 WINED3DPBLENDCAPS_ONE
|
2685 WINED3DPBLENDCAPS_SRCALPHA
|
2686 WINED3DPBLENDCAPS_SRCCOLOR
|
2687 WINED3DPBLENDCAPS_ZERO
;
2688 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
2689 * according to the glBlendFunc manpage
2691 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
2692 * legacy settings for srcblend only
2695 if( GL_SUPPORT(EXT_BLEND_COLOR
)) {
2696 *pCaps
->SrcBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
2697 *pCaps
->DestBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
2701 *pCaps
->AlphaCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
2702 WINED3DPCMPCAPS_EQUAL
|
2703 WINED3DPCMPCAPS_GREATER
|
2704 WINED3DPCMPCAPS_GREATEREQUAL
|
2705 WINED3DPCMPCAPS_LESS
|
2706 WINED3DPCMPCAPS_LESSEQUAL
|
2707 WINED3DPCMPCAPS_NEVER
|
2708 WINED3DPCMPCAPS_NOTEQUAL
;
2710 *pCaps
->ShadeCaps
= WINED3DPSHADECAPS_SPECULARGOURAUDRGB
|
2711 WINED3DPSHADECAPS_COLORGOURAUDRGB
|
2712 WINED3DPSHADECAPS_ALPHAFLATBLEND
|
2713 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND
|
2714 WINED3DPSHADECAPS_COLORFLATRGB
|
2715 WINED3DPSHADECAPS_FOGFLAT
|
2716 WINED3DPSHADECAPS_FOGGOURAUD
|
2717 WINED3DPSHADECAPS_SPECULARFLATRGB
;
2719 *pCaps
->TextureCaps
= WINED3DPTEXTURECAPS_ALPHA
|
2720 WINED3DPTEXTURECAPS_ALPHAPALETTE
|
2721 WINED3DPTEXTURECAPS_BORDER
|
2722 WINED3DPTEXTURECAPS_MIPMAP
|
2723 WINED3DPTEXTURECAPS_PROJECTED
|
2724 WINED3DPTEXTURECAPS_PERSPECTIVE
;
2726 if( !GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO
)) {
2727 *pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_POW2
|
2728 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL
;
2731 if( GL_SUPPORT(EXT_TEXTURE3D
)) {
2732 *pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_VOLUMEMAP
|
2733 WINED3DPTEXTURECAPS_MIPVOLUMEMAP
|
2734 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2
;
2737 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2738 *pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_CUBEMAP
|
2739 WINED3DPTEXTURECAPS_MIPCUBEMAP
|
2740 WINED3DPTEXTURECAPS_CUBEMAP_POW2
;
2744 *pCaps
->TextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
2745 WINED3DPTFILTERCAPS_MAGFPOINT
|
2746 WINED3DPTFILTERCAPS_MINFLINEAR
|
2747 WINED3DPTFILTERCAPS_MINFPOINT
|
2748 WINED3DPTFILTERCAPS_MIPFLINEAR
|
2749 WINED3DPTFILTERCAPS_MIPFPOINT
|
2750 WINED3DPTFILTERCAPS_LINEAR
|
2751 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
2752 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
2753 WINED3DPTFILTERCAPS_MIPLINEAR
|
2754 WINED3DPTFILTERCAPS_MIPNEAREST
|
2755 WINED3DPTFILTERCAPS_NEAREST
;
2757 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
)) {
2758 *pCaps
->TextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
2759 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
2762 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2763 *pCaps
->CubeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
2764 WINED3DPTFILTERCAPS_MAGFPOINT
|
2765 WINED3DPTFILTERCAPS_MINFLINEAR
|
2766 WINED3DPTFILTERCAPS_MINFPOINT
|
2767 WINED3DPTFILTERCAPS_MIPFLINEAR
|
2768 WINED3DPTFILTERCAPS_MIPFPOINT
|
2769 WINED3DPTFILTERCAPS_LINEAR
|
2770 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
2771 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
2772 WINED3DPTFILTERCAPS_MIPLINEAR
|
2773 WINED3DPTFILTERCAPS_MIPNEAREST
|
2774 WINED3DPTFILTERCAPS_NEAREST
;
2776 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
)) {
2777 *pCaps
->CubeTextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
2778 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
2781 *pCaps
->CubeTextureFilterCaps
= 0;
2783 if (GL_SUPPORT(EXT_TEXTURE3D
)) {
2784 *pCaps
->VolumeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
2785 WINED3DPTFILTERCAPS_MAGFPOINT
|
2786 WINED3DPTFILTERCAPS_MINFLINEAR
|
2787 WINED3DPTFILTERCAPS_MINFPOINT
|
2788 WINED3DPTFILTERCAPS_MIPFLINEAR
|
2789 WINED3DPTFILTERCAPS_MIPFPOINT
|
2790 WINED3DPTFILTERCAPS_LINEAR
|
2791 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
2792 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
2793 WINED3DPTFILTERCAPS_MIPLINEAR
|
2794 WINED3DPTFILTERCAPS_MIPNEAREST
|
2795 WINED3DPTFILTERCAPS_NEAREST
;
2797 *pCaps
->VolumeTextureFilterCaps
= 0;
2799 *pCaps
->TextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
2800 WINED3DPTADDRESSCAPS_CLAMP
|
2801 WINED3DPTADDRESSCAPS_WRAP
;
2803 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP
)) {
2804 *pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
2806 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT
)) {
2807 *pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
2809 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE
)) {
2810 *pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
2813 if (GL_SUPPORT(EXT_TEXTURE3D
)) {
2814 *pCaps
->VolumeTextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
2815 WINED3DPTADDRESSCAPS_CLAMP
|
2816 WINED3DPTADDRESSCAPS_WRAP
;
2817 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP
)) {
2818 *pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
2820 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT
)) {
2821 *pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
2823 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE
)) {
2824 *pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
2827 *pCaps
->VolumeTextureAddressCaps
= 0;
2829 *pCaps
->LineCaps
= WINED3DLINECAPS_TEXTURE
|
2830 WINED3DLINECAPS_ZTEST
;
2832 WINED3DLINECAPS_BLEND
2833 WINED3DLINECAPS_ALPHACMP
2834 WINED3DLINECAPS_FOG */
2836 *pCaps
->MaxTextureWidth
= GL_LIMITS(texture_size
);
2837 *pCaps
->MaxTextureHeight
= GL_LIMITS(texture_size
);
2839 if(GL_SUPPORT(EXT_TEXTURE3D
))
2840 *pCaps
->MaxVolumeExtent
= GL_LIMITS(texture3d_size
);
2842 *pCaps
->MaxVolumeExtent
= 0;
2844 *pCaps
->MaxTextureRepeat
= 32768;
2845 *pCaps
->MaxTextureAspectRatio
= GL_LIMITS(texture_size
);
2846 *pCaps
->MaxVertexW
= 1.0;
2848 *pCaps
->GuardBandLeft
= 0;
2849 *pCaps
->GuardBandTop
= 0;
2850 *pCaps
->GuardBandRight
= 0;
2851 *pCaps
->GuardBandBottom
= 0;
2853 *pCaps
->ExtentsAdjust
= 0;
2855 *pCaps
->StencilCaps
= WINED3DSTENCILCAPS_DECRSAT
|
2856 WINED3DSTENCILCAPS_INCRSAT
|
2857 WINED3DSTENCILCAPS_INVERT
|
2858 WINED3DSTENCILCAPS_KEEP
|
2859 WINED3DSTENCILCAPS_REPLACE
|
2860 WINED3DSTENCILCAPS_ZERO
;
2861 if (GL_SUPPORT(EXT_STENCIL_WRAP
)) {
2862 *pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_DECR
|
2863 WINED3DSTENCILCAPS_INCR
;
2865 if ( This
->dxVersion
> 8 &&
2866 ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE
) ||
2867 GL_SUPPORT(ATI_SEPARATE_STENCIL
) ) ) {
2868 *pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_TWOSIDED
;
2871 *pCaps
->FVFCaps
= WINED3DFVFCAPS_PSIZE
| 0x0008; /* 8 texture coords */
2873 *pCaps
->TextureOpCaps
= WINED3DTEXOPCAPS_ADD
|
2874 WINED3DTEXOPCAPS_ADDSIGNED
|
2875 WINED3DTEXOPCAPS_ADDSIGNED2X
|
2876 WINED3DTEXOPCAPS_MODULATE
|
2877 WINED3DTEXOPCAPS_MODULATE2X
|
2878 WINED3DTEXOPCAPS_MODULATE4X
|
2879 WINED3DTEXOPCAPS_SELECTARG1
|
2880 WINED3DTEXOPCAPS_SELECTARG2
|
2881 WINED3DTEXOPCAPS_DISABLE
;
2883 if (GL_SUPPORT(ARB_TEXTURE_ENV_COMBINE
) ||
2884 GL_SUPPORT(EXT_TEXTURE_ENV_COMBINE
) ||
2885 GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4
)) {
2886 *pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BLENDDIFFUSEALPHA
|
2887 WINED3DTEXOPCAPS_BLENDTEXTUREALPHA
|
2888 WINED3DTEXOPCAPS_BLENDFACTORALPHA
|
2889 WINED3DTEXOPCAPS_BLENDCURRENTALPHA
|
2890 WINED3DTEXOPCAPS_LERP
|
2891 WINED3DTEXOPCAPS_SUBTRACT
;
2893 if (GL_SUPPORT(ATI_TEXTURE_ENV_COMBINE3
) ||
2894 GL_SUPPORT(NV_TEXTURE_ENV_COMBINE4
)) {
2895 *pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_ADDSMOOTH
|
2896 WINED3DTEXOPCAPS_MULTIPLYADD
|
2897 WINED3DTEXOPCAPS_MODULATEALPHA_ADDCOLOR
|
2898 WINED3DTEXOPCAPS_MODULATECOLOR_ADDALPHA
|
2899 WINED3DTEXOPCAPS_BLENDTEXTUREALPHAPM
;
2901 if (GL_SUPPORT(ARB_TEXTURE_ENV_DOT3
))
2902 *pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_DOTPRODUCT3
;
2904 if (GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
2905 *pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_MODULATEINVALPHA_ADDCOLOR
|
2906 WINED3DTEXOPCAPS_MODULATEINVCOLOR_ADDALPHA
;
2909 if(GL_SUPPORT(ATI_ENVMAP_BUMPMAP
)) {
2910 *pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BUMPENVMAP
;
2911 } else if(GL_SUPPORT(NV_TEXTURE_SHADER2
)) {
2912 /* Bump mapping is supported already in NV_TEXTURE_SHADER, but that extension does
2913 * not support 3D textures. This asks for trouble if an app uses both bump mapping
2914 * and 3D textures. It also allows us to keep the code simpler by having texture
2915 * shaders constantly enabled.
2917 *pCaps
->TextureOpCaps
|= WINED3DTEXOPCAPS_BUMPENVMAP
;
2918 /* TODO: Luminance bump map? */
2922 *pCaps->TextureOpCaps |= WINED3DTEXOPCAPS_BUMPENVMAPLUMINANCE
2923 WINED3DTEXOPCAPS_PREMODULATE */
2926 *pCaps
->MaxTextureBlendStages
= GL_LIMITS(texture_stages
);
2927 *pCaps
->MaxSimultaneousTextures
= GL_LIMITS(textures
);
2928 *pCaps
->MaxUserClipPlanes
= GL_LIMITS(clipplanes
);
2929 *pCaps
->MaxActiveLights
= GL_LIMITS(lights
);
2931 *pCaps
->MaxVertexBlendMatrices
= GL_LIMITS(blends
);
2932 *pCaps
->MaxVertexBlendMatrixIndex
= 0;
2934 *pCaps
->MaxAnisotropy
= GL_LIMITS(anisotropy
);
2935 *pCaps
->MaxPointSize
= GL_LIMITS(pointsize
);
2938 *pCaps
->VertexProcessingCaps
= WINED3DVTXPCAPS_DIRECTIONALLIGHTS
|
2939 WINED3DVTXPCAPS_MATERIALSOURCE7
|
2940 WINED3DVTXPCAPS_POSITIONALLIGHTS
|
2941 WINED3DVTXPCAPS_LOCALVIEWER
|
2942 WINED3DVTXPCAPS_VERTEXFOG
|
2943 WINED3DVTXPCAPS_TEXGEN
;
2945 D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
2947 *pCaps
->MaxPrimitiveCount
= 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
2948 *pCaps
->MaxVertexIndex
= 0xFFFFF;
2949 *pCaps
->MaxStreams
= MAX_STREAMS
;
2950 *pCaps
->MaxStreamStride
= 1024;
2952 if (vs_selected_mode
== SHADER_GLSL
) {
2953 /* Nvidia Geforce6/7 or Ati R4xx/R5xx cards with GLSL support, support VS 3.0 but older Nvidia/Ati
2954 * models with GLSL support only support 2.0. In case of nvidia we can detect VS 2.0 support using
2955 * vs_nv_version which is based on NV_vertex_program.
2956 * For Ati cards there's no way using glsl (it abstracts the lowlevel info away) and also not
2957 * using ARB_vertex_program. It is safe to assume that when a card supports pixel shader 2.0 it
2958 * supports vertex shader 2.0 too and the way around. We can detect ps2.0 using the maximum number
2959 * of native instructions, so use that here. For more info see the pixel shader versioning code below. */
2960 if((GLINFO_LOCATION
.vs_nv_version
== VS_VERSION_20
) || (GLINFO_LOCATION
.ps_arb_max_instructions
<= 512))
2961 *pCaps
->VertexShaderVersion
= WINED3DVS_VERSION(2,0);
2963 *pCaps
->VertexShaderVersion
= WINED3DVS_VERSION(3,0);
2964 TRACE_(d3d_caps
)("Hardware vertex shader version %d.%d enabled (GLSL)\n", (*pCaps
->VertexShaderVersion
>> 8) & 0xff, *pCaps
->VertexShaderVersion
& 0xff);
2965 } else if (vs_selected_mode
== SHADER_ARB
) {
2966 *pCaps
->VertexShaderVersion
= WINED3DVS_VERSION(1,1);
2967 TRACE_(d3d_caps
)("Hardware vertex shader version 1.1 enabled (ARB_PROGRAM)\n");
2969 *pCaps
->VertexShaderVersion
= 0;
2970 TRACE_(d3d_caps
)("Vertex shader functionality not available\n");
2973 *pCaps
->MaxVertexShaderConst
= GL_LIMITS(vshader_constantsF
);
2975 if (ps_selected_mode
== SHADER_GLSL
) {
2976 /* Older DX9-class videocards (GeforceFX / Radeon >9500/X*00) only support pixel shader 2.0/2.0a/2.0b.
2977 * In OpenGL the extensions related to GLSL abstract lowlevel GL info away which is needed
2978 * to distinguish between 2.0 and 3.0 (and 2.0a/2.0b). In case of Nvidia we use their fragment
2979 * program extensions. On other hardware including ATI GL_ARB_fragment_program offers the info
2980 * in max native instructions. Intel and others also offer the info in this extension but they
2981 * don't support GLSL (at least on Windows).
2983 * PS2.0 requires at least 96 instructions, 2.0a/2.0b go up to 512. Assume that if the number
2984 * of instructions is 512 or less we have to do with ps2.0 hardware.
2985 * NOTE: ps3.0 hardware requires 512 or more instructions but ati and nvidia offer 'enough' (1024 vs 4096) on their most basic ps3.0 hardware.
2987 if((GLINFO_LOCATION
.ps_nv_version
== PS_VERSION_20
) || (GLINFO_LOCATION
.ps_arb_max_instructions
<= 512))
2988 *pCaps
->PixelShaderVersion
= WINED3DPS_VERSION(2,0);
2990 *pCaps
->PixelShaderVersion
= WINED3DPS_VERSION(3,0);
2991 /* FIXME: The following line is card dependent. -8.0 to 8.0 is the
2992 * Direct3D minimum requirement.
2994 * Both GL_ARB_fragment_program and GLSL require a "maximum representable magnitude"
2995 * of colors to be 2^10, and 2^32 for other floats. Should we use 1024 here?
2997 * The problem is that the refrast clamps temporary results in the shader to
2998 * [-MaxValue;+MaxValue]. If the card's max value is bigger than the one we advertize here,
2999 * then applications may miss the clamping behavior. On the other hand, if it is smaller,
3000 * the shader will generate incorrect results too. Unfortunately, GL deliberately doesn't
3001 * offer a way to query this.
3003 *pCaps
->PixelShader1xMaxValue
= 8.0;
3004 TRACE_(d3d_caps
)("Hardware pixel shader version %d.%d enabled (GLSL)\n", (*pCaps
->PixelShaderVersion
>> 8) & 0xff, *pCaps
->PixelShaderVersion
& 0xff);
3005 } else if (ps_selected_mode
== SHADER_ARB
) {
3006 *pCaps
->PixelShaderVersion
= WINED3DPS_VERSION(1,4);
3007 *pCaps
->PixelShader1xMaxValue
= 8.0;
3008 TRACE_(d3d_caps
)("Hardware pixel shader version 1.4 enabled (ARB_PROGRAM)\n");
3010 *pCaps
->PixelShaderVersion
= 0;
3011 *pCaps
->PixelShader1xMaxValue
= 0.0;
3012 TRACE_(d3d_caps
)("Pixel shader functionality not available\n");
3015 /* ------------------------------------------------
3016 The following fields apply to d3d9 only
3017 ------------------------------------------------ */
3018 if (This
->dxVersion
> 8) {
3019 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
3020 *pCaps
->DevCaps2
= WINED3DDEVCAPS2_STREAMOFFSET
;
3021 /* TODO: VS3.0 needs at least D3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET */
3022 *pCaps
->MaxNpatchTessellationLevel
= 0;
3023 *pCaps
->MasterAdapterOrdinal
= 0;
3024 *pCaps
->AdapterOrdinalInGroup
= 0;
3025 *pCaps
->NumberOfAdaptersInGroup
= 1;
3027 if(*pCaps
->VertexShaderVersion
>= WINED3DVS_VERSION(2,0)) {
3028 /* OpenGL supports all the formats below, perhaps not always
3029 * without conversion, but it supports them.
3030 * Further GLSL doesn't seem to have an official unsigned type so
3031 * don't advertise it yet as I'm not sure how we handle it.
3032 * We might need to add some clamping in the shader engine to
3034 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
3035 *pCaps
->DeclTypes
= WINED3DDTCAPS_UBYTE4
|
3036 WINED3DDTCAPS_UBYTE4N
|
3037 WINED3DDTCAPS_SHORT2N
|
3038 WINED3DDTCAPS_SHORT4N
;
3039 if (GL_SUPPORT(NV_HALF_FLOAT
)) {
3040 *pCaps
->DeclTypes
|=
3041 WINED3DDTCAPS_FLOAT16_2
|
3042 WINED3DDTCAPS_FLOAT16_4
;
3045 *pCaps
->DeclTypes
= 0;
3047 *pCaps
->NumSimultaneousRTs
= GL_LIMITS(buffers
);
3050 *pCaps
->StretchRectFilterCaps
= WINED3DPTFILTERCAPS_MINFPOINT
|
3051 WINED3DPTFILTERCAPS_MAGFPOINT
|
3052 WINED3DPTFILTERCAPS_MINFLINEAR
|
3053 WINED3DPTFILTERCAPS_MAGFLINEAR
;
3054 *pCaps
->VertexTextureFilterCaps
= 0;
3056 if(*pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(3,0)) {
3057 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3058 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
3059 *pCaps
->VS20Caps
.Caps
= WINED3DVS20CAPS_PREDICATION
;
3060 *pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3061 *pCaps
->VS20Caps
.NumTemps
= max(32, GLINFO_LOCATION
.vs_arb_max_temps
);
3062 *pCaps
->VS20Caps
.StaticFlowControlDepth
= WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH
; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
3064 *pCaps
->MaxVShaderInstructionsExecuted
= 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
3065 *pCaps
->MaxVertexShader30InstructionSlots
= max(512, GLINFO_LOCATION
.vs_arb_max_instructions
);
3066 } else if(*pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(2,0)) {
3067 *pCaps
->VS20Caps
.Caps
= 0;
3068 *pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH
;
3069 *pCaps
->VS20Caps
.NumTemps
= max(12, GLINFO_LOCATION
.vs_arb_max_temps
);
3070 *pCaps
->VS20Caps
.StaticFlowControlDepth
= 1;
3072 *pCaps
->MaxVShaderInstructionsExecuted
= 65535;
3073 *pCaps
->MaxVertexShader30InstructionSlots
= 0;
3074 } else { /* VS 1.x */
3075 *pCaps
->VS20Caps
.Caps
= 0;
3076 *pCaps
->VS20Caps
.DynamicFlowControlDepth
= 0;
3077 *pCaps
->VS20Caps
.NumTemps
= 0;
3078 *pCaps
->VS20Caps
.StaticFlowControlDepth
= 0;
3080 *pCaps
->MaxVShaderInstructionsExecuted
= 0;
3081 *pCaps
->MaxVertexShader30InstructionSlots
= 0;
3084 if(*pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(3,0)) {
3085 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3086 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
3088 /* 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 */
3089 *pCaps
->PS20Caps
.Caps
= WINED3DPS20CAPS_ARBITRARYSWIZZLE
|
3090 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS
|
3091 WINED3DPS20CAPS_PREDICATION
|
3092 WINED3DPS20CAPS_NODEPENDENTREADLIMIT
|
3093 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
;
3094 *pCaps
->PS20Caps
.DynamicFlowControlDepth
= WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3095 *pCaps
->PS20Caps
.NumTemps
= max(32, GLINFO_LOCATION
.ps_arb_max_temps
);
3096 *pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
3097 *pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS
; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
3099 *pCaps
->MaxPShaderInstructionsExecuted
= 65535;
3100 *pCaps
->MaxPixelShader30InstructionSlots
= max(WINED3DMIN30SHADERINSTRUCTIONS
, GLINFO_LOCATION
.ps_arb_max_instructions
);
3101 } else if(*pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(2,0)) {
3102 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
3103 *pCaps
->PS20Caps
.Caps
= 0;
3104 *pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
3105 *pCaps
->PS20Caps
.NumTemps
= max(12, GLINFO_LOCATION
.ps_arb_max_temps
);
3106 *pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH
; /* Minimum: 1 */
3107 *pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS
; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
3109 *pCaps
->MaxPShaderInstructionsExecuted
= 512; /* Minimum value, a GeforceFX uses 1024 */
3110 *pCaps
->MaxPixelShader30InstructionSlots
= 0;
3111 } else { /* PS 1.x */
3112 *pCaps
->PS20Caps
.Caps
= 0;
3113 *pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0;
3114 *pCaps
->PS20Caps
.NumTemps
= 0;
3115 *pCaps
->PS20Caps
.StaticFlowControlDepth
= 0;
3116 *pCaps
->PS20Caps
.NumInstructionSlots
= 0;
3118 *pCaps
->MaxPShaderInstructionsExecuted
= 0;
3119 *pCaps
->MaxPixelShader30InstructionSlots
= 0;
3126 static unsigned int glsl_program_key_hash(void *key
) {
3127 glsl_program_key_t
*k
= (glsl_program_key_t
*)key
;
3129 unsigned int hash
= k
->vshader
| k
->pshader
<< 16;
3130 hash
+= ~(hash
<< 15);
3131 hash
^= (hash
>> 10);
3132 hash
+= (hash
<< 3);
3133 hash
^= (hash
>> 6);
3134 hash
+= ~(hash
<< 11);
3135 hash
^= (hash
>> 16);
3140 static BOOL
glsl_program_key_compare(void *keya
, void *keyb
) {
3141 glsl_program_key_t
*ka
= (glsl_program_key_t
*)keya
;
3142 glsl_program_key_t
*kb
= (glsl_program_key_t
*)keyb
;
3144 return ka
->vshader
== kb
->vshader
&& ka
->pshader
== kb
->pshader
;
3147 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
3148 and fields being inserted in the middle, a new structure is used in place */
3149 static HRESULT WINAPI
IWineD3DImpl_CreateDevice(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, HWND hFocusWindow
,
3150 DWORD BehaviourFlags
, IWineD3DDevice
** ppReturnedDeviceInterface
,
3153 IWineD3DDeviceImpl
*object
= NULL
;
3154 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3155 WINED3DDISPLAYMODE mode
;
3158 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
3159 * number and create a device without a 3D adapter for 2D only operation.
3161 if (IWineD3D_GetAdapterCount(iface
) && Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
3162 return WINED3DERR_INVALIDCALL
;
3165 /* Create a WineD3DDevice object */
3166 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IWineD3DDeviceImpl
));
3167 *ppReturnedDeviceInterface
= (IWineD3DDevice
*)object
;
3168 TRACE("Created WineD3DDevice object @ %p\n", object
);
3169 if (NULL
== object
) {
3170 return WINED3DERR_OUTOFVIDEOMEMORY
;
3173 /* Set up initial COM information */
3174 object
->lpVtbl
= &IWineD3DDevice_Vtbl
;
3176 object
->wineD3D
= iface
;
3177 object
->adapter
= numAdapters
? &Adapters
[Adapter
] : NULL
;
3178 IWineD3D_AddRef(object
->wineD3D
);
3179 object
->parent
= parent
;
3180 list_init(&object
->resources
);
3181 list_init(&object
->shaders
);
3183 if(This
->dxVersion
== 7) {
3184 object
->surface_alignment
= 8;
3186 object
->surface_alignment
= 4;
3188 object
->posFixup
[0] = 1.0; /* This is needed to get the x coord unmodified through a MAD */
3190 /* Set the state up as invalid until the device is fully created */
3191 object
->state
= WINED3DERR_DRIVERINTERNALERROR
;
3193 TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This
, Adapter
, DeviceType
,
3194 hFocusWindow
, BehaviourFlags
, ppReturnedDeviceInterface
);
3196 /* Save the creation parameters */
3197 object
->createParms
.AdapterOrdinal
= Adapter
;
3198 object
->createParms
.DeviceType
= DeviceType
;
3199 object
->createParms
.hFocusWindow
= hFocusWindow
;
3200 object
->createParms
.BehaviorFlags
= BehaviourFlags
;
3202 /* Initialize other useful values */
3203 object
->adapterNo
= Adapter
;
3204 object
->devType
= DeviceType
;
3206 select_shader_mode(&GLINFO_LOCATION
, DeviceType
, &object
->ps_selected_mode
, &object
->vs_selected_mode
);
3207 if (object
->ps_selected_mode
== SHADER_GLSL
|| object
->vs_selected_mode
== SHADER_GLSL
) {
3208 object
->shader_backend
= &glsl_shader_backend
;
3209 object
->glsl_program_lookup
= hash_table_create(&glsl_program_key_hash
, &glsl_program_key_compare
);
3210 } else if (object
->ps_selected_mode
== SHADER_ARB
|| object
->vs_selected_mode
== SHADER_ARB
) {
3211 object
->shader_backend
= &arb_program_shader_backend
;
3213 object
->shader_backend
= &none_shader_backend
;
3215 if(FAILED(object
->shader_backend
->shader_alloc_private((IWineD3DDevice
*) object
))) {
3216 IWineD3D_Release(object
->wineD3D
);
3217 HeapFree(GetProcessHeap(), 0, object
);
3218 *ppReturnedDeviceInterface
= NULL
;
3219 return E_OUTOFMEMORY
;
3222 /* Prefer the vtable with functions optimized for single dirtifyable objects if the shader
3223 * model can deal with that. It is essentially the same, just with adjusted
3224 * Set*ShaderConstantF implementations
3226 if(object
->shader_backend
->shader_dirtifyable_constants((IWineD3DDevice
*) object
)) {
3227 object
->lpVtbl
= &IWineD3DDevice_DirtyConst_Vtbl
;
3230 /* set the state of the device to valid */
3231 object
->state
= WINED3D_OK
;
3233 /* Get the initial screen setup for ddraw */
3234 IWineD3DImpl_GetAdapterDisplayMode(iface
, Adapter
, &mode
);
3236 object
->ddraw_width
= mode
.Width
;
3237 object
->ddraw_height
= mode
.Height
;
3238 object
->ddraw_format
= mode
.Format
;
3240 for(i
= 0; i
< PATCHMAP_SIZE
; i
++) {
3241 list_init(&object
->patches
[i
]);
3245 #undef GLINFO_LOCATION
3247 static HRESULT WINAPI
IWineD3DImpl_GetParent(IWineD3D
*iface
, IUnknown
**pParent
) {
3248 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3249 IUnknown_AddRef(This
->parent
);
3250 *pParent
= This
->parent
;
3254 ULONG WINAPI
D3DCB_DefaultDestroySurface(IWineD3DSurface
*pSurface
) {
3255 IUnknown
* surfaceParent
;
3256 TRACE("(%p) call back\n", pSurface
);
3258 /* Now, release the parent, which will take care of cleaning up the surface for us */
3259 IWineD3DSurface_GetParent(pSurface
, &surfaceParent
);
3260 IUnknown_Release(surfaceParent
);
3261 return IUnknown_Release(surfaceParent
);
3264 ULONG WINAPI
D3DCB_DefaultDestroyVolume(IWineD3DVolume
*pVolume
) {
3265 IUnknown
* volumeParent
;
3266 TRACE("(%p) call back\n", pVolume
);
3268 /* Now, release the parent, which will take care of cleaning up the volume for us */
3269 IWineD3DVolume_GetParent(pVolume
, &volumeParent
);
3270 IUnknown_Release(volumeParent
);
3271 return IUnknown_Release(volumeParent
);
3274 static BOOL
implementation_is_apple(WineD3D_GL_Info
*gl_info
) {
3275 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
3276 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
3277 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
3279 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
3280 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
3281 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
3282 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
3283 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
3284 * the chance that other implementations support them is rather small since Win32 QuickTime uses
3285 * DirectDraw, not OpenGL.
3287 if(gl_info
->supported
[APPLE_FENCE
] &&
3288 gl_info
->supported
[APPLE_CLIENT_STORAGE
] &&
3289 gl_info
->supported
[APPLE_FLUSH_RENDER
] &&
3290 gl_info
->supported
[APPLE_YCBCR_422
]) {
3291 TRACE_(d3d_caps
)("GL_APPLE_fence, GL_APPLE_client_storage, GL_APPLE_flush_render and GL_ycbcr_422 are supported\n");
3292 TRACE_(d3d_caps
)("Activating MacOS fixups\n");
3295 TRACE_(d3d_caps
)("Apple extensions are not supported\n");
3296 TRACE_(d3d_caps
)("Not activating MacOS fixups\n");
3301 #define GLINFO_LOCATION (*gl_info)
3302 static void test_pbo_functionality(WineD3D_GL_Info
*gl_info
) {
3303 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
3304 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
3305 * all the texture. This function detects this bug by its symptom and disables PBOs
3306 * if the test fails.
3308 * The test uplaods a 4x4 texture via the PBO in the "native" format GL_BGRA,
3309 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
3310 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
3311 * read back is compared to the original. If they are equal PBOs are assumed to work,
3312 * otherwise the PBO extension is disabled.
3314 GLuint texture
, pbo
;
3315 static const unsigned int pattern
[] = {
3316 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
3317 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
3318 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
3319 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
3321 unsigned int check
[sizeof(pattern
) / sizeof(pattern
[0])];
3323 if(!gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
]) {
3324 /* No PBO -> No point in testing them */
3328 while(glGetError());
3329 glGenTextures(1, &texture
);
3330 glBindTexture(GL_TEXTURE_2D
, texture
);
3331 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA
, 4, 4, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, 0);
3332 checkGLcall("Specifying the PBO test texture\n");
3334 GL_EXTCALL(glGenBuffersARB(1, &pbo
));
3335 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, pbo
));
3336 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, sizeof(pattern
), pattern
, GL_STREAM_DRAW_ARB
));
3337 checkGLcall("Specifying the PBO test pbo\n");
3339 glTexSubImage2D(GL_TEXTURE_2D
, 0, 0, 0, 4, 4, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, NULL
);
3340 checkGLcall("Loading the PBO test texture\n");
3342 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
3343 glFinish(); /* just to be sure */
3345 memset(check
, 0, sizeof(check
));
3346 glGetTexImage(GL_TEXTURE_2D
, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, check
);
3347 checkGLcall("Reading back the PBO test texture\n");
3349 glDeleteTextures(1, &texture
);
3350 GL_EXTCALL(glDeleteBuffersARB(1, &pbo
));
3351 checkGLcall("PBO test cleanup\n");
3353 if(memcmp(check
, pattern
, sizeof(check
)) != 0) {
3354 WARN_(d3d_caps
)("PBO test failed, read back data doesn't match original\n");
3355 WARN_(d3d_caps
)("Disabling PBOs. This may result in slower performance\n");
3356 gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
] = FALSE
;
3358 TRACE_(d3d_caps
)("PBO test successful\n");
3361 #undef GLINFO_LOCATION
3363 /* Certain applications(Steam) complain if we report an outdated driver version. In general,
3364 * reporting a driver version is moot because we are not the Windows driver, and we have different
3365 * bugs, features, etc.
3367 * If a card is not found in this table, the gl driver version is reported
3369 struct driver_version_information
{
3370 WORD vendor
; /* reported PCI card vendor ID */
3371 WORD card
; /* reported PCI card device ID */
3372 WORD hipart_hi
, hipart_lo
; /* driver hiword to report */
3373 WORD lopart_hi
, lopart_lo
; /* driver loword to report */
3376 static const struct driver_version_information driver_version_table
[] = {
3377 /* Nvidia drivers. Geforce FX and newer cards are supported by the current driver */
3378 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5200
, 7, 15, 10, 16921 },
3379 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5600
, 7, 15, 10, 16921 },
3380 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5800
, 7, 15, 10, 16921 },
3381 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6200
, 7, 15, 10, 16921 },
3382 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6600GT
, 7, 15, 10, 16921 },
3383 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6800
, 7, 15, 10, 16921 },
3384 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7400
, 7, 15, 10, 16921 },
3385 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7300
, 7, 15, 10, 16921 },
3386 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7600
, 7, 15, 10, 16921 },
3387 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7800GT
, 7, 15, 10, 16921 },
3388 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8300GS
, 7, 15, 10, 16921 },
3389 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600GT
, 7, 15, 10, 16921 },
3390 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600MGT
, 7, 15, 10, 16921 },
3391 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8800GTS
, 7, 15, 10, 16921 },
3393 /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode */
3394 {VENDOR_ATI
, CARD_ATI_RADEON_9500
, 6, 14, 10, 6764 },
3395 {VENDOR_ATI
, CARD_ATI_RADEON_X700
, 6, 14, 10, 6764 },
3396 {VENDOR_ATI
, CARD_ATI_RADEON_X1600
, 6, 14, 10, 6764 },
3397 {VENDOR_ATI
, CARD_ATI_RADEON_HD2300
, 6, 14, 10, 6764 },
3398 {VENDOR_ATI
, CARD_ATI_RADEON_HD2600
, 6, 14, 10, 6764 },
3399 {VENDOR_ATI
, CARD_ATI_RADEON_HD2900
, 6, 14, 10, 6764 },
3401 /* TODO: Add information about legacy nvidia and ATI hardware, Intel and other cards */
3404 static void fixup_extensions(WineD3D_GL_Info
*gl_info
) {
3406 BOOL apple
= implementation_is_apple(gl_info
);
3409 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
3410 * used it falls back to software. While the compiler can detect if the shader uses all declared
3411 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
3412 * using relative addressing falls back to software.
3414 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL
3416 if(gl_info
->vs_glsl_constantsF
<= gl_info
->vs_arb_constantsF
) {
3417 FIXME("GLSL doesn't advertise more vertex shader uniforms than ARB. Driver fixup outdated?\n");
3419 TRACE("Driver claims %u GLSL vs uniforms, replacing with %u ARB vp uniforms\n",
3420 gl_info
->vs_glsl_constantsF
, gl_info
->vs_arb_constantsF
);
3421 gl_info
->vs_glsl_constantsF
= gl_info
->vs_arb_constantsF
;
3424 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
3425 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
3426 * If real NP2 textures are used, the driver falls back to software. So remove the supported
3427 * flag for this extension
3429 if(gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] && gl_info
->gl_vendor
== VENDOR_ATI
) {
3430 if(gl_info
->gl_card
== CARD_ATI_RADEON_X700
|| gl_info
->gl_card
== CARD_ATI_RADEON_X1600
||
3431 gl_info
->gl_card
== CARD_ATI_RADEON_9500
|| gl_info
->gl_card
== CARD_ATI_RADEON_8500
||
3432 gl_info
->gl_card
== CARD_ATI_RADEON_7200
|| gl_info
->gl_card
== CARD_ATI_RAGE_128PRO
) {
3433 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing\n");
3434 gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] = FALSE
;
3435 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = TRUE
;
3439 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
3440 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
3441 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
3442 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
3443 * according to the spec.
3445 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
3446 * makes the shader slower and eats instruction slots which should be available to the d3d app.
3448 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
3449 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
3450 * this workaround is activated on cards that do not need it, it won't break things, just affect
3451 * performance negatively.
3453 if(gl_info
->gl_vendor
== VENDOR_INTEL
||
3454 (gl_info
->gl_vendor
== VENDOR_ATI
&& gl_info
->gl_card
!= CARD_ATI_RADEON_X1600
)) {
3455 TRACE("Enabling vertex texture coord fixes in vertex shaders\n");
3456 gl_info
->set_texcoord_w
= TRUE
;
3460 /* Find out if PBOs work as they are supposed to */
3461 test_pbo_functionality(gl_info
);
3463 /* Fixup the driver version */
3464 for(i
= 0; i
< (sizeof(driver_version_table
) / sizeof(driver_version_table
[0])); i
++) {
3465 if(gl_info
->gl_vendor
== driver_version_table
[i
].vendor
&&
3466 gl_info
->gl_card
== driver_version_table
[i
].card
) {
3467 TRACE_(d3d_caps
)("Found card 0x%04x, 0x%04x in driver version DB\n", gl_info
->gl_vendor
, gl_info
->gl_card
);
3469 gl_info
->driver_version
= MAKEDWORD_VERSION(driver_version_table
[i
].lopart_hi
,
3470 driver_version_table
[i
].lopart_lo
);
3471 gl_info
->driver_version_hipart
= MAKEDWORD_VERSION(driver_version_table
[i
].hipart_hi
,
3472 driver_version_table
[i
].hipart_lo
);
3478 void invalid_func(void *data
) {
3479 ERR("Invalid vertex attribute function called\n");
3483 #define GLINFO_LOCATION (Adapters[0].gl_info)
3485 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
3486 * the extension detection and are used in drawStridedSlow
3488 static void position_d3dcolor(void *data
) {
3489 DWORD pos
= *((DWORD
*) data
);
3491 FIXME("Add a test for fixed function position from d3dcolor type\n");
3492 glVertex4s(D3DCOLOR_B_R(pos
),
3497 static void position_float4(void *data
) {
3498 GLfloat
*pos
= (float *) data
;
3500 if (pos
[3] < eps
&& pos
[3] > -eps
)
3503 float w
= 1.0 / pos
[3];
3505 glVertex4f(pos
[0] * w
, pos
[1] * w
, pos
[2] * w
, w
);
3509 static void diffuse_d3dcolor(void *data
) {
3510 DWORD diffuseColor
= *((DWORD
*) data
);
3512 glColor4ub(D3DCOLOR_B_R(diffuseColor
),
3513 D3DCOLOR_B_G(diffuseColor
),
3514 D3DCOLOR_B_B(diffuseColor
),
3515 D3DCOLOR_B_A(diffuseColor
));
3518 static void specular_d3dcolor(void *data
) {
3519 DWORD specularColor
= *((DWORD
*) data
);
3521 GL_EXTCALL(glSecondaryColor3ubEXT
)(D3DCOLOR_B_R(specularColor
),
3522 D3DCOLOR_B_G(specularColor
),
3523 D3DCOLOR_B_B(specularColor
));
3525 static void warn_no_specular_func(void *data
) {
3526 WARN("GL_EXT_secondary_color not supported\n");
3529 void fillGLAttribFuncs(WineD3D_GL_Info
*gl_info
) {
3530 position_funcs
[WINED3DDECLTYPE_FLOAT1
] = (void *) invalid_func
;
3531 position_funcs
[WINED3DDECLTYPE_FLOAT2
] = (void *) invalid_func
;
3532 position_funcs
[WINED3DDECLTYPE_FLOAT3
] = (void *) glVertex3fv
;
3533 position_funcs
[WINED3DDECLTYPE_FLOAT4
] = (void *) position_float4
;
3534 position_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = (void *) position_d3dcolor
;
3535 position_funcs
[WINED3DDECLTYPE_UBYTE4
] = (void *) invalid_func
;
3536 position_funcs
[WINED3DDECLTYPE_SHORT2
] = (void *) invalid_func
;
3537 position_funcs
[WINED3DDECLTYPE_SHORT4
] = (void *) glVertex2sv
;
3538 position_funcs
[WINED3DDECLTYPE_UBYTE4N
] = (void *) invalid_func
;
3539 position_funcs
[WINED3DDECLTYPE_SHORT2N
] = (void *) invalid_func
;
3540 position_funcs
[WINED3DDECLTYPE_SHORT4N
] = (void *) invalid_func
;
3541 position_funcs
[WINED3DDECLTYPE_USHORT2N
] = (void *) invalid_func
;
3542 position_funcs
[WINED3DDECLTYPE_USHORT4N
] = (void *) invalid_func
;
3543 position_funcs
[WINED3DDECLTYPE_UDEC3
] = (void *) invalid_func
;
3544 position_funcs
[WINED3DDECLTYPE_DEC3N
] = (void *) invalid_func
;
3545 position_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = (void *) invalid_func
;
3546 position_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = (void *) invalid_func
;
3548 diffuse_funcs
[WINED3DDECLTYPE_FLOAT1
] = (void *) invalid_func
;
3549 diffuse_funcs
[WINED3DDECLTYPE_FLOAT2
] = (void *) invalid_func
;
3550 diffuse_funcs
[WINED3DDECLTYPE_FLOAT3
] = (void *) glColor3fv
;
3551 diffuse_funcs
[WINED3DDECLTYPE_FLOAT4
] = (void *) glColor4fv
;
3552 diffuse_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = (void *) diffuse_d3dcolor
;
3553 diffuse_funcs
[WINED3DDECLTYPE_UBYTE4
] = (void *) invalid_func
;
3554 diffuse_funcs
[WINED3DDECLTYPE_SHORT2
] = (void *) invalid_func
;
3555 diffuse_funcs
[WINED3DDECLTYPE_SHORT4
] = (void *) invalid_func
;
3556 diffuse_funcs
[WINED3DDECLTYPE_UBYTE4N
] = (void *) glColor4ubv
;
3557 diffuse_funcs
[WINED3DDECLTYPE_SHORT2N
] = (void *) invalid_func
;
3558 diffuse_funcs
[WINED3DDECLTYPE_SHORT4N
] = (void *) glColor4sv
;
3559 diffuse_funcs
[WINED3DDECLTYPE_USHORT2N
] = (void *) invalid_func
;
3560 diffuse_funcs
[WINED3DDECLTYPE_USHORT4N
] = (void *) glColor4usv
;
3561 diffuse_funcs
[WINED3DDECLTYPE_UDEC3
] = (void *) invalid_func
;
3562 diffuse_funcs
[WINED3DDECLTYPE_DEC3N
] = (void *) invalid_func
;
3563 diffuse_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = (void *) invalid_func
;
3564 diffuse_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = (void *) invalid_func
;
3566 /* No 4 component entry points here */
3567 specular_funcs
[WINED3DDECLTYPE_FLOAT1
] = (void *) invalid_func
;
3568 specular_funcs
[WINED3DDECLTYPE_FLOAT2
] = (void *) invalid_func
;
3569 if(GL_SUPPORT(EXT_SECONDARY_COLOR
)) {
3570 specular_funcs
[WINED3DDECLTYPE_FLOAT3
] = (void *) GL_EXTCALL(glSecondaryColor3fvEXT
);
3572 specular_funcs
[WINED3DDECLTYPE_FLOAT3
] = (void *) warn_no_specular_func
;
3574 specular_funcs
[WINED3DDECLTYPE_FLOAT4
] = (void *) invalid_func
;
3575 if(GL_SUPPORT(EXT_SECONDARY_COLOR
)) {
3576 specular_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = (void *) specular_d3dcolor
;
3578 specular_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = (void *) warn_no_specular_func
;
3580 specular_funcs
[WINED3DDECLTYPE_UBYTE4
] = (void *) invalid_func
;
3581 specular_funcs
[WINED3DDECLTYPE_SHORT2
] = (void *) invalid_func
;
3582 specular_funcs
[WINED3DDECLTYPE_SHORT4
] = (void *) invalid_func
;
3583 specular_funcs
[WINED3DDECLTYPE_UBYTE4N
] = (void *) invalid_func
;
3584 specular_funcs
[WINED3DDECLTYPE_SHORT2N
] = (void *) invalid_func
;
3585 specular_funcs
[WINED3DDECLTYPE_SHORT4N
] = (void *) invalid_func
;
3586 specular_funcs
[WINED3DDECLTYPE_USHORT2N
] = (void *) invalid_func
;
3587 specular_funcs
[WINED3DDECLTYPE_USHORT4N
] = (void *) invalid_func
;
3588 specular_funcs
[WINED3DDECLTYPE_UDEC3
] = (void *) invalid_func
;
3589 specular_funcs
[WINED3DDECLTYPE_DEC3N
] = (void *) invalid_func
;
3590 specular_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = (void *) invalid_func
;
3591 specular_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = (void *) invalid_func
;
3593 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
3594 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
3596 normal_funcs
[WINED3DDECLTYPE_FLOAT1
] = (void *) invalid_func
;
3597 normal_funcs
[WINED3DDECLTYPE_FLOAT2
] = (void *) invalid_func
;
3598 normal_funcs
[WINED3DDECLTYPE_FLOAT3
] = (void *) glNormal3fv
;
3599 normal_funcs
[WINED3DDECLTYPE_FLOAT4
] = (void *) glNormal3fv
; /* Just ignore the 4th value */
3600 normal_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = (void *) invalid_func
;
3601 normal_funcs
[WINED3DDECLTYPE_UBYTE4
] = (void *) invalid_func
;
3602 normal_funcs
[WINED3DDECLTYPE_SHORT2
] = (void *) invalid_func
;
3603 normal_funcs
[WINED3DDECLTYPE_SHORT4
] = (void *) invalid_func
;
3604 normal_funcs
[WINED3DDECLTYPE_UBYTE4N
] = (void *) invalid_func
;
3605 normal_funcs
[WINED3DDECLTYPE_SHORT2N
] = (void *) invalid_func
;
3606 normal_funcs
[WINED3DDECLTYPE_SHORT4N
] = (void *) invalid_func
;
3607 normal_funcs
[WINED3DDECLTYPE_USHORT2N
] = (void *) invalid_func
;
3608 normal_funcs
[WINED3DDECLTYPE_USHORT4N
] = (void *) invalid_func
;
3609 normal_funcs
[WINED3DDECLTYPE_UDEC3
] = (void *) invalid_func
;
3610 normal_funcs
[WINED3DDECLTYPE_DEC3N
] = (void *) invalid_func
;
3611 normal_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = (void *) invalid_func
;
3612 normal_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = (void *) invalid_func
;
3615 #define PUSH1(att) attribs[nAttribs++] = (att);
3616 BOOL
InitAdapters(void) {
3617 static HMODULE mod_gl
;
3619 int ps_selected_mode
, vs_selected_mode
;
3621 /* No need to hold any lock. The calling library makes sure only one thread calls
3622 * wined3d simultaneously
3624 if(numAdapters
> 0) return TRUE
;
3626 TRACE("Initializing adapters\n");
3629 #ifdef USE_WIN32_OPENGL
3630 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
3631 mod_gl
= LoadLibraryA("opengl32.dll");
3633 ERR("Can't load opengl32.dll!\n");
3637 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
3638 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
3639 mod_gl
= GetModuleHandleA("gdi32.dll");
3643 /* Load WGL core functions from opengl32.dll */
3644 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
3648 if(!pwglGetProcAddress
) {
3649 ERR("Unable to load wglGetProcAddress!\n");
3653 /* Dynamically load all GL core functions */
3657 /* For now only one default adapter */
3664 WineD3D_PixelFormat
*cfgs
;
3666 DISPLAY_DEVICEW DisplayDevice
;
3669 TRACE("Initializing default adapter\n");
3670 Adapters
[0].num
= 0;
3671 Adapters
[0].monitorPoint
.x
= -1;
3672 Adapters
[0].monitorPoint
.y
= -1;
3674 if (!WineD3D_CreateFakeGLContext()) {
3675 ERR("Failed to get a gl context for default adapter\n");
3676 HeapFree(GetProcessHeap(), 0, Adapters
);
3677 WineD3D_ReleaseFakeGLContext();
3681 ret
= IWineD3DImpl_FillGLCaps(&Adapters
[0].gl_info
);
3683 ERR("Failed to initialize gl caps for default adapter\n");
3684 HeapFree(GetProcessHeap(), 0, Adapters
);
3685 WineD3D_ReleaseFakeGLContext();
3688 ret
= initPixelFormats(&Adapters
[0].gl_info
);
3690 ERR("Failed to init gl formats\n");
3691 HeapFree(GetProcessHeap(), 0, Adapters
);
3692 WineD3D_ReleaseFakeGLContext();
3696 hdc
= pwglGetCurrentDC();
3698 ERR("Failed to get gl HDC\n");
3699 HeapFree(GetProcessHeap(), 0, Adapters
);
3700 WineD3D_ReleaseFakeGLContext();
3704 Adapters
[0].driver
= "Display";
3705 Adapters
[0].description
= "Direct3D HAL";
3707 /* Use the VideoRamSize registry setting when set */
3708 if(wined3d_settings
.emulated_textureram
)
3709 Adapters
[0].TextureRam
= wined3d_settings
.emulated_textureram
;
3711 Adapters
[0].TextureRam
= Adapters
[0].gl_info
.vidmem
;
3712 Adapters
[0].UsedTextureRam
= 0;
3713 TRACE("Emulating %dMB of texture ram\n", Adapters
[0].TextureRam
/(1024*1024));
3715 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
3716 DisplayDevice
.cb
= sizeof(DisplayDevice
);
3717 EnumDisplayDevicesW(NULL
, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice
, 0);
3718 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice
.DeviceName
));
3719 strcpyW(Adapters
[0].DeviceName
, DisplayDevice
.DeviceName
);
3721 attribute
= WGL_NUMBER_PIXEL_FORMATS_ARB
;
3722 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, 0, 0, 1, &attribute
, &Adapters
[0].nCfgs
));
3724 Adapters
[0].cfgs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, Adapters
[0].nCfgs
*sizeof(WineD3D_PixelFormat
));
3725 cfgs
= Adapters
[0].cfgs
;
3726 PUSH1(WGL_RED_BITS_ARB
)
3727 PUSH1(WGL_GREEN_BITS_ARB
)
3728 PUSH1(WGL_BLUE_BITS_ARB
)
3729 PUSH1(WGL_ALPHA_BITS_ARB
)
3730 PUSH1(WGL_DEPTH_BITS_ARB
)
3731 PUSH1(WGL_STENCIL_BITS_ARB
)
3732 PUSH1(WGL_DRAW_TO_WINDOW_ARB
)
3734 for(iPixelFormat
=1; iPixelFormat
<=Adapters
[0].nCfgs
; iPixelFormat
++) {
3735 res
= GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, nAttribs
, attribs
, values
));
3740 /* Cache the pixel format */
3741 cfgs
->iPixelFormat
= iPixelFormat
;
3742 cfgs
->redSize
= values
[0];
3743 cfgs
->greenSize
= values
[1];
3744 cfgs
->blueSize
= values
[2];
3745 cfgs
->alphaSize
= values
[3];
3746 cfgs
->depthSize
= values
[4];
3747 cfgs
->stencilSize
= values
[5];
3748 cfgs
->windowDrawable
= values
[6];
3750 cfgs
->pbufferDrawable
= FALSE
;
3751 /* Check for pbuffer support when it is around as wglGetPixelFormatAttribiv fails for unknown
3753 if(GL_SUPPORT(WGL_ARB_PBUFFER
)) {
3754 int attrib
= WGL_DRAW_TO_PBUFFER_ARB
;
3756 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, 1, &attrib
, &value
)))
3757 cfgs
->pbufferDrawable
= value
;
3760 TRACE("iPixelFormat=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d, windowDrawable=%d, pbufferDrawable=%d\n", cfgs
->iPixelFormat
, cfgs
->redSize
, cfgs
->greenSize
, cfgs
->blueSize
, cfgs
->alphaSize
, cfgs
->depthSize
, cfgs
->stencilSize
, cfgs
->windowDrawable
, cfgs
->pbufferDrawable
);
3764 fixup_extensions(&Adapters
[0].gl_info
);
3766 WineD3D_ReleaseFakeGLContext();
3768 select_shader_mode(&Adapters
[0].gl_info
, WINED3DDEVTYPE_HAL
, &ps_selected_mode
, &vs_selected_mode
);
3769 select_shader_max_constants(ps_selected_mode
, vs_selected_mode
, &Adapters
[0].gl_info
);
3770 fillGLAttribFuncs(&Adapters
[0].gl_info
);
3771 init_type_lookup(&Adapters
[0].gl_info
);
3774 TRACE("%d adapters successfully initialized\n", numAdapters
);
3779 #undef GLINFO_LOCATION
3781 /**********************************************************
3782 * IWineD3D VTbl follows
3783 **********************************************************/
3785 const IWineD3DVtbl IWineD3D_Vtbl
=
3788 IWineD3DImpl_QueryInterface
,
3789 IWineD3DImpl_AddRef
,
3790 IWineD3DImpl_Release
,
3792 IWineD3DImpl_GetParent
,
3793 IWineD3DImpl_GetAdapterCount
,
3794 IWineD3DImpl_RegisterSoftwareDevice
,
3795 IWineD3DImpl_GetAdapterMonitor
,
3796 IWineD3DImpl_GetAdapterModeCount
,
3797 IWineD3DImpl_EnumAdapterModes
,
3798 IWineD3DImpl_GetAdapterDisplayMode
,
3799 IWineD3DImpl_GetAdapterIdentifier
,
3800 IWineD3DImpl_CheckDeviceMultiSampleType
,
3801 IWineD3DImpl_CheckDepthStencilMatch
,
3802 IWineD3DImpl_CheckDeviceType
,
3803 IWineD3DImpl_CheckDeviceFormat
,
3804 IWineD3DImpl_CheckDeviceFormatConversion
,
3805 IWineD3DImpl_GetDeviceCaps
,
3806 IWineD3DImpl_CreateDevice