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
8 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with this library; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
25 /* Compile time diagnostics: */
27 #ifndef DEBUG_SINGLE_MODE
28 /* Set to 1 to force only a single display mode to be exposed: */
29 #define DEBUG_SINGLE_MODE 0
34 #include "wined3d_private.h"
36 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
37 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps
);
39 #define GLINFO_LOCATION (*gl_info)
41 /* The d3d device ID */
42 static const GUID IID_D3DDEVICE_D3DUID
= { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
44 /* Extension detection */
46 const char *extension_string
;
47 GL_SupportedExt extension
;
51 {"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE
, 0 },
52 {"GL_APPLE_fence", APPLE_FENCE
, 0 },
53 {"GL_APPLE_flush_render", APPLE_FLUSH_RENDER
, 0 },
54 {"GL_APPLE_ycbcr_422", APPLE_YCBCR_422
, 0 },
55 {"GL_APPLE_float_pixels", APPLE_FLOAT_PIXELS
, 0 },
58 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL
, 0 },
59 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3
, 0 },
60 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE
, 0 },
61 {"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER
, 0 },
62 {"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC
, 0 },
65 {"GL_ARB_color_buffer_float", ARB_COLOR_BUFFER_FLOAT
, 0 },
66 {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS
, 0 },
67 {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM
, 0 },
68 {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER
, 0 },
69 {"GL_ARB_geometry_shader4", ARB_GEOMETRY_SHADER4
, 0 },
70 {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL
, 0 },
71 {"GL_ARB_imaging", ARB_IMAGING
, 0 },
72 {"GL_ARB_multisample", ARB_MULTISAMPLE
, 0 }, /* needs GLX_ARB_MULTISAMPLE as well */
73 {"GL_ARB_multitexture", ARB_MULTITEXTURE
, 0 },
74 {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY
, 0 },
75 {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT
, 0 },
76 {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS
, 0 },
77 {"GL_ARB_point_sprite", ARB_POINT_SPRITE
, 0 },
78 {"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP
, 0 },
79 {"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION
, 0 },
80 {"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP
, 0 },
81 {"GL_ARB_texture_env_add", ARB_TEXTURE_ENV_ADD
, 0 },
82 {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE
, 0 },
83 {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3
, 0 },
84 {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT
, 0 },
85 {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT
, 0 },
86 {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO
, MAKEDWORD_VERSION(2, 0) },
87 {"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE
, 0 },
88 {"GL_ARB_texture_rg", ARB_TEXTURE_RG
, 0 },
89 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND
, 0 },
90 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT
, 0 },
91 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM
, 0 },
92 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER
, 0 },
93 {"GL_ARB_shader_objects", ARB_SHADER_OBJECTS
, 0 },
96 {"GL_EXT_blend_color", EXT_BLEND_COLOR
, 0 },
97 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX
, 0 },
98 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE
, 0 },
99 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE
, 0 },
100 {"GL_EXT_fog_coord", EXT_FOG_COORD
, 0 },
101 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT
, 0 },
102 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE
, 0 },
103 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT
, 0 },
104 {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE
, 0 },
105 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS
, 0 },
106 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR
, 0 },
107 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE
, 0 },
108 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP
, 0 },
109 {"GL_EXT_texture3D", EXT_TEXTURE3D
, MAKEDWORD_VERSION(1, 2) },
110 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC
, 0 },
111 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC
, 0 },
112 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD
, 0 },
113 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE
, 0 },
114 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3
, 0 },
115 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB
, 0 },
116 {"GL_EXT_texture_swizzle", EXT_TEXTURE_SWIZZLE
, 0 },
117 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC
, 0 },
118 {"GL_EXT_texture_lod", EXT_TEXTURE_LOD
, 0 },
119 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS
, 0 },
120 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA
, 0 },
121 {"GL_EXT_vertex_shader", EXT_VERTEX_SHADER
, 0 },
122 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS
, 0 },
125 {"GL_NV_half_float", NV_HALF_FLOAT
, 0 },
126 {"GL_NV_fence", NV_FENCE
, 0 },
127 {"GL_NV_fog_distance", NV_FOG_DISTANCE
, 0 },
128 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM
, 0 },
129 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2
, 0 },
130 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS
, 0 },
131 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2
, 0 },
132 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION
, 0 },
133 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4
, 0 },
134 {"GL_NV_texture_shader", NV_TEXTURE_SHADER
, 0 },
135 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2
, 0 },
136 {"GL_NV_texture_shader3", NV_TEXTURE_SHADER3
, 0 },
137 {"GL_NV_occlusion_query", NV_OCCLUSION_QUERY
, 0 },
138 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM
, 0 },
139 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1
, 0 },
140 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2
, 0 },
141 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3
, 0 },
142 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP
, 0 },
143 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT
, 0 },
146 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP
, 0 },
149 /**********************************************************
150 * Utility functions follow
151 **********************************************************/
153 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
, WINED3DSURFTYPE SurfaceType
);
154 static const struct fragment_pipeline
*select_fragment_implementation(struct WineD3DAdapter
*adapter
,
155 WINED3DDEVTYPE DeviceType
);
156 static const shader_backend_t
*select_shader_backend(struct WineD3DAdapter
*adapter
, WINED3DDEVTYPE DeviceType
);
157 static const struct blit_shader
*select_blit_implementation(struct WineD3DAdapter
*adapter
, WINED3DDEVTYPE DeviceType
);
160 const int minLookup
[MAX_LOOKUPS
] =
162 WINED3DTADDRESS_WRAP
, /* WINELOOKUP_WARPPARAM */
165 const int maxLookup
[MAX_LOOKUPS
] =
167 WINED3DTADDRESS_MIRRORONCE
, /* WINELOOKUP_WARPPARAM */
170 DWORD
*stateLookup
[MAX_LOOKUPS
];
172 struct min_lookup minMipLookup
[WINED3DTEXF_ANISOTROPIC
+ 1];
173 const struct min_lookup minMipLookup_noFilter
[WINED3DTEXF_ANISOTROPIC
+ 1] =
175 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}},
176 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}},
177 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}},
178 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}},
181 GLenum magLookup
[WINED3DTEXF_ANISOTROPIC
+ 1];
182 const GLenum magLookup_noFilter
[WINED3DTEXF_ANISOTROPIC
+ 1] =
184 GL_NEAREST
, GL_NEAREST
, GL_NEAREST
, GL_NEAREST
187 /* drawStridedSlow attributes */
188 glAttribFunc position_funcs
[WINED3DDECLTYPE_UNUSED
];
189 glAttribFunc diffuse_funcs
[WINED3DDECLTYPE_UNUSED
];
190 glAttribFunc specular_func_3ubv
;
191 glAttribFunc specular_funcs
[WINED3DDECLTYPE_UNUSED
];
192 glAttribFunc normal_funcs
[WINED3DDECLTYPE_UNUSED
];
193 glMultiTexCoordFunc multi_texcoord_funcs
[WINED3DDECLTYPE_UNUSED
];
196 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
197 * i.e., there is no GL Context - Get a default rendering context to enable the
198 * function query some info from GL.
201 static int wined3d_fake_gl_context_ref
= 0;
202 static BOOL wined3d_fake_gl_context_foreign
;
203 static BOOL wined3d_fake_gl_context_available
= FALSE
;
204 static HDC wined3d_fake_gl_context_hdc
= NULL
;
205 static HWND wined3d_fake_gl_context_hwnd
= NULL
;
207 static CRITICAL_SECTION wined3d_fake_gl_context_cs
;
208 static CRITICAL_SECTION_DEBUG wined3d_fake_gl_context_cs_debug
=
210 0, 0, &wined3d_fake_gl_context_cs
,
211 { &wined3d_fake_gl_context_cs_debug
.ProcessLocksList
,
212 &wined3d_fake_gl_context_cs_debug
.ProcessLocksList
},
213 0, 0, { (DWORD_PTR
)(__FILE__
": wined3d_fake_gl_context_cs") }
215 static CRITICAL_SECTION wined3d_fake_gl_context_cs
= { &wined3d_fake_gl_context_cs_debug
, -1, 0, 0, 0, 0 };
217 static void WineD3D_ReleaseFakeGLContext(void) {
220 EnterCriticalSection(&wined3d_fake_gl_context_cs
);
222 if(!wined3d_fake_gl_context_available
) {
223 TRACE_(d3d_caps
)("context not available\n");
224 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
228 glCtx
= pwglGetCurrentContext();
230 TRACE_(d3d_caps
)("decrementing ref from %i\n", wined3d_fake_gl_context_ref
);
231 if (0 == (--wined3d_fake_gl_context_ref
) ) {
232 if(!wined3d_fake_gl_context_foreign
&& glCtx
) {
233 TRACE_(d3d_caps
)("destroying fake GL context\n");
234 pwglMakeCurrent(NULL
, NULL
);
235 pwglDeleteContext(glCtx
);
237 if(wined3d_fake_gl_context_hdc
)
238 ReleaseDC(wined3d_fake_gl_context_hwnd
, wined3d_fake_gl_context_hdc
);
239 wined3d_fake_gl_context_hdc
= NULL
; /* Make sure we don't think that it is still around */
240 if(wined3d_fake_gl_context_hwnd
)
241 DestroyWindow(wined3d_fake_gl_context_hwnd
);
242 wined3d_fake_gl_context_hwnd
= NULL
;
243 wined3d_fake_gl_context_available
= FALSE
;
245 assert(wined3d_fake_gl_context_ref
>= 0);
247 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
250 static BOOL
WineD3D_CreateFakeGLContext(void) {
253 EnterCriticalSection(&wined3d_fake_gl_context_cs
);
255 TRACE("getting context...\n");
256 if(wined3d_fake_gl_context_ref
> 0) goto ret
;
257 assert(0 == wined3d_fake_gl_context_ref
);
259 wined3d_fake_gl_context_foreign
= TRUE
;
261 glCtx
= pwglGetCurrentContext();
263 PIXELFORMATDESCRIPTOR pfd
;
266 wined3d_fake_gl_context_foreign
= FALSE
;
268 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes */
269 wined3d_fake_gl_context_hwnd
= CreateWindowA("WineD3D_OpenGL", "WineD3D fake window", WS_OVERLAPPEDWINDOW
, 10, 10, 10, 10, NULL
, NULL
, NULL
, NULL
);
270 if(!wined3d_fake_gl_context_hwnd
) {
271 ERR("HWND creation failed!\n");
274 wined3d_fake_gl_context_hdc
= GetDC(wined3d_fake_gl_context_hwnd
);
275 if(!wined3d_fake_gl_context_hdc
) {
276 ERR("GetDC failed!\n");
280 /* PixelFormat selection */
281 ZeroMemory(&pfd
, sizeof(pfd
));
282 pfd
.nSize
= sizeof(pfd
);
284 pfd
.dwFlags
= PFD_SUPPORT_OPENGL
| PFD_DOUBLEBUFFER
| PFD_DRAW_TO_WINDOW
;/*PFD_GENERIC_ACCELERATED*/
285 pfd
.iPixelType
= PFD_TYPE_RGBA
;
287 pfd
.iLayerType
= PFD_MAIN_PLANE
;
289 iPixelFormat
= ChoosePixelFormat(wined3d_fake_gl_context_hdc
, &pfd
);
291 /* If this happens something is very wrong as ChoosePixelFormat barely fails */
292 ERR("Can't find a suitable iPixelFormat\n");
295 DescribePixelFormat(wined3d_fake_gl_context_hdc
, iPixelFormat
, sizeof(pfd
), &pfd
);
296 SetPixelFormat(wined3d_fake_gl_context_hdc
, iPixelFormat
, &pfd
);
298 /* Create a GL context */
299 glCtx
= pwglCreateContext(wined3d_fake_gl_context_hdc
);
301 WARN_(d3d_caps
)("Error creating default context for capabilities initialization\n");
305 /* Make it the current GL context */
306 if (!pwglMakeCurrent(wined3d_fake_gl_context_hdc
, glCtx
)) {
307 WARN_(d3d_caps
)("Error setting default context as current for capabilities initialization\n");
313 TRACE("incrementing ref from %i\n", wined3d_fake_gl_context_ref
);
314 wined3d_fake_gl_context_ref
++;
315 wined3d_fake_gl_context_available
= TRUE
;
316 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
319 if(wined3d_fake_gl_context_hdc
)
320 ReleaseDC(wined3d_fake_gl_context_hwnd
, wined3d_fake_gl_context_hdc
);
321 wined3d_fake_gl_context_hdc
= NULL
;
322 if(wined3d_fake_gl_context_hwnd
)
323 DestroyWindow(wined3d_fake_gl_context_hwnd
);
324 wined3d_fake_gl_context_hwnd
= NULL
;
325 if(glCtx
) pwglDeleteContext(glCtx
);
326 LeaveCriticalSection(&wined3d_fake_gl_context_cs
);
330 /* Adjust the amount of used texture memory */
331 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl
*D3DDevice
, long glram
){
332 struct WineD3DAdapter
*adapter
= D3DDevice
->adapter
;
334 adapter
->UsedTextureRam
+= glram
;
335 TRACE("Adjusted gl ram by %ld to %d\n", glram
, adapter
->UsedTextureRam
);
336 return adapter
->UsedTextureRam
;
339 /**********************************************************
340 * IUnknown parts follows
341 **********************************************************/
343 static HRESULT WINAPI
IWineD3DImpl_QueryInterface(IWineD3D
*iface
,REFIID riid
,LPVOID
*ppobj
)
345 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
347 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
348 if (IsEqualGUID(riid
, &IID_IUnknown
)
349 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
350 || IsEqualGUID(riid
, &IID_IWineD3DDevice
)) {
351 IUnknown_AddRef(iface
);
356 return E_NOINTERFACE
;
359 static ULONG WINAPI
IWineD3DImpl_AddRef(IWineD3D
*iface
) {
360 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
361 ULONG refCount
= InterlockedIncrement(&This
->ref
);
363 TRACE("(%p) : AddRef increasing from %d\n", This
, refCount
- 1);
367 static ULONG WINAPI
IWineD3DImpl_Release(IWineD3D
*iface
) {
368 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
370 TRACE("(%p) : Releasing from %d\n", This
, This
->ref
);
371 ref
= InterlockedDecrement(&This
->ref
);
375 for (i
= 0; i
< This
->adapter_count
; ++i
)
377 HeapFree(GetProcessHeap(), 0, This
->adapters
[i
].cfgs
);
379 HeapFree(GetProcessHeap(), 0, This
);
385 /* Set the shader type for this device, depending on the given capabilities,
386 * the device type, and the user preferences in wined3d_settings */
388 static void select_shader_mode(const WineD3D_GL_Info
*gl_info
, WINED3DDEVTYPE DeviceType
, int *ps_selected
, int *vs_selected
)
390 if (wined3d_settings
.vs_mode
== VS_NONE
) {
391 *vs_selected
= SHADER_NONE
;
392 } else if (gl_info
->supported
[ARB_VERTEX_SHADER
] && wined3d_settings
.glslRequested
) {
393 /* Geforce4 cards support GLSL but for vertex shaders only. Further its reported GLSL caps are
394 * wrong. This combined with the fact that glsl won't offer more features or performance, use ARB
395 * shaders only on this card. */
396 if(gl_info
->vs_nv_version
&& gl_info
->vs_nv_version
< VS_VERSION_20
)
397 *vs_selected
= SHADER_ARB
;
399 *vs_selected
= SHADER_GLSL
;
400 } else if (gl_info
->supported
[ARB_VERTEX_PROGRAM
]) {
401 *vs_selected
= SHADER_ARB
;
403 *vs_selected
= SHADER_NONE
;
406 if (wined3d_settings
.ps_mode
== PS_NONE
) {
407 *ps_selected
= SHADER_NONE
;
408 } else if (gl_info
->supported
[ARB_FRAGMENT_SHADER
] && wined3d_settings
.glslRequested
) {
409 *ps_selected
= SHADER_GLSL
;
410 } else if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) {
411 *ps_selected
= SHADER_ARB
;
412 } else if (gl_info
->supported
[ATI_FRAGMENT_SHADER
]) {
413 *ps_selected
= SHADER_ATI
;
415 *ps_selected
= SHADER_NONE
;
419 /** Select the number of report maximum shader constants based on the selected shader modes */
420 static void select_shader_max_constants(
421 int ps_selected_mode
,
422 int vs_selected_mode
,
423 WineD3D_GL_Info
*gl_info
) {
425 switch (vs_selected_mode
) {
427 /* Subtract the other potential uniforms from the max available (bools, ints, and 1 row of projection matrix) */
428 gl_info
->max_vshader_constantsF
= gl_info
->vs_glsl_constantsF
- (MAX_CONST_B
/ 4) - MAX_CONST_I
- 1;
431 /* We have to subtract any other PARAMs that we might use in our shader programs.
432 * ATI seems to count 2 implicit PARAMs when we use fog and NVIDIA counts 1,
433 * and we reference one row of the PROJECTION matrix which counts as 1 PARAM. */
434 gl_info
->max_vshader_constantsF
= gl_info
->vs_arb_constantsF
- 3;
437 gl_info
->max_vshader_constantsF
= 0;
441 switch (ps_selected_mode
) {
443 /* Subtract the other potential uniforms from the max available (bools & ints), and 2 states for fog.
444 * In theory the texbem instruction may need one more shader constant too. But lets assume
445 * that a sm <= 1.3 shader does not need all the uniforms provided by a glsl-capable card,
446 * and lets not take away a uniform needlessly from all other shaders.
448 gl_info
->max_pshader_constantsF
= gl_info
->ps_glsl_constantsF
- (MAX_CONST_B
/ 4) - MAX_CONST_I
- 2;
451 /* The arb shader only loads the bump mapping environment matrix into the shader if it finds
452 * a free constant to do that, so only reduce the number of available constants by 2 for the fog states.
454 gl_info
->max_pshader_constantsF
= gl_info
->ps_arb_constantsF
- 2;
457 gl_info
->max_pshader_constantsF
= 0;
462 /**********************************************************
463 * IWineD3D parts follows
464 **********************************************************/
466 static inline BOOL
test_arb_vs_offset_limit(const WineD3D_GL_Info
*gl_info
)
470 const char *testcode
=
472 "PARAM C[66] = { program.env[0..65] };\n"
474 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
475 "ARL A0.x, zero.x;\n"
476 "MOV result.position, C[A0.x + 65];\n"
480 GL_EXTCALL(glGenProgramsARB(1, &prog
));
482 ERR("Failed to create an ARB offset limit test program\n");
484 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, prog
));
485 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
,
486 strlen(testcode
), testcode
));
487 if(glGetError() != 0) {
488 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
489 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB
)));
491 } else TRACE("OpenGL implementation allows offsets > 63\n");
493 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, 0));
494 GL_EXTCALL(glDeleteProgramsARB(1, &prog
));
495 checkGLcall("ARB vp offset limit test cleanup\n");
500 static DWORD
ver_for_ext(GL_SupportedExt ext
)
503 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
504 if(EXTENSION_MAP
[i
].extension
== ext
) {
505 return EXTENSION_MAP
[i
].version
;
511 static BOOL
IWineD3DImpl_FillGLCaps(WineD3D_GL_Info
*gl_info
) {
512 const char *GL_Extensions
= NULL
;
513 const char *WGL_Extensions
= NULL
;
514 const char *gl_string
= NULL
;
515 const char *gl_string_cursor
= NULL
;
517 GLfloat gl_floatv
[2];
518 int major
= 1, minor
= 0;
519 BOOL return_value
= TRUE
;
522 unsigned int vidmem
=0;
524 TRACE_(d3d_caps
)("(%p)\n", gl_info
);
528 gl_string
= (const char *) glGetString(GL_RENDERER
);
529 if (!gl_string
) gl_string
= "None";
530 strcpy(gl_info
->gl_renderer
, gl_string
);
532 gl_string
= (const char *) glGetString(GL_VENDOR
);
533 TRACE_(d3d_caps
)("Filling vendor string %s\n", gl_string
);
534 if (gl_string
!= NULL
) {
535 /* Fill in the GL vendor */
536 if (strstr(gl_string
, "NVIDIA")) {
537 gl_info
->gl_vendor
= VENDOR_NVIDIA
;
538 } else if (strstr(gl_string
, "ATI")) {
539 gl_info
->gl_vendor
= VENDOR_ATI
;
540 } else if (strstr(gl_string
, "Intel(R)") ||
541 strstr(gl_info
->gl_renderer
, "Intel(R)") ||
542 strstr(gl_string
, "Intel Inc.")) {
543 gl_info
->gl_vendor
= VENDOR_INTEL
;
544 } else if (strstr(gl_string
, "Mesa")) {
545 gl_info
->gl_vendor
= VENDOR_MESA
;
547 gl_info
->gl_vendor
= VENDOR_WINE
;
550 gl_info
->gl_vendor
= VENDOR_WINE
;
554 TRACE_(d3d_caps
)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string
), gl_info
->gl_vendor
);
556 /* Parse the GL_VERSION field into major and minor information */
557 gl_string
= (const char *) glGetString(GL_VERSION
);
558 if (gl_string
!= NULL
) {
560 /* First, parse the generic opengl version. This is supposed not to be convoluted with
561 * driver specific information
563 gl_string_cursor
= gl_string
;
564 major
= atoi(gl_string_cursor
);
566 ERR("Invalid opengl major version: %d\n", major
);
568 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
571 if (*gl_string_cursor
++ != '.') {
572 ERR_(d3d_caps
)("Invalid opengl version string: %s\n", debugstr_a(gl_string
));
574 minor
= atoi(gl_string_cursor
);
575 TRACE_(d3d_caps
)("Found OpenGL version: %d.%d\n", major
, minor
);
576 gl_info
->gl_version
= MAKEDWORD_VERSION(major
, minor
);
578 /* Now parse the driver specific string which we'll report to the app */
579 switch (gl_info
->gl_vendor
) {
581 gl_string_cursor
= strstr(gl_string
, "NVIDIA");
582 if (!gl_string_cursor
) {
583 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
587 gl_string_cursor
= strstr(gl_string_cursor
, " ");
588 if (!gl_string_cursor
) {
589 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
593 while (*gl_string_cursor
== ' ') {
597 if (!*gl_string_cursor
) {
598 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
602 major
= atoi(gl_string_cursor
);
603 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
607 if (*gl_string_cursor
++ != '.') {
608 ERR_(d3d_caps
)("Invalid nVidia version string: %s\n", debugstr_a(gl_string
));
612 minor
= atoi(gl_string_cursor
);
613 minor
= major
*100+minor
;
620 gl_string_cursor
= strchr(gl_string
, '-');
621 if (gl_string_cursor
) {
625 /* Check if version number is of the form x.y.z */
626 if (*gl_string_cursor
> '9' && *gl_string_cursor
< '0')
628 if (!error
&& *(gl_string_cursor
+2) > '9' && *(gl_string_cursor
+2) < '0')
630 if (!error
&& *(gl_string_cursor
+4) > '9' && *(gl_string_cursor
+4) < '0')
632 if (!error
&& *(gl_string_cursor
+1) != '.' && *(gl_string_cursor
+3) != '.')
635 /* Mark version number as malformed */
637 gl_string_cursor
= 0;
640 if (!gl_string_cursor
)
641 WARN_(d3d_caps
)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string
));
643 major
= *gl_string_cursor
- '0';
644 minor
= (*(gl_string_cursor
+2) - '0') * 256 + (*(gl_string_cursor
+4) - '0');
649 /* Apple and Mesa version strings look differently, but both provide intel drivers */
650 if(strstr(gl_string
, "APPLE")) {
651 /* [0-9]+.[0-9]+ APPLE-[0-9]+.[0.9]+.[0.9]+
652 * We only need the first part, and use the APPLE as identification
655 gl_string_cursor
= gl_string
;
656 major
= atoi(gl_string_cursor
);
657 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
661 if (*gl_string_cursor
++ != '.') {
662 ERR_(d3d_caps
)("Invalid MacOS-Intel version string: %s\n", debugstr_a(gl_string
));
666 minor
= atoi(gl_string_cursor
);
671 gl_string_cursor
= strstr(gl_string
, "Mesa");
672 gl_string_cursor
= strstr(gl_string_cursor
, " ");
673 while (*gl_string_cursor
&& ' ' == *gl_string_cursor
) ++gl_string_cursor
;
674 if (*gl_string_cursor
) {
678 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
679 tmp
[cursor
++] = *gl_string_cursor
;
685 if (*gl_string_cursor
!= '.') WARN_(d3d_caps
)("malformed GL_VERSION (%s)\n", debugstr_a(gl_string
));
689 while (*gl_string_cursor
<= '9' && *gl_string_cursor
>= '0') {
690 tmp
[cursor
++] = *gl_string_cursor
;
702 gl_info
->driver_version
= MAKEDWORD_VERSION(major
, minor
);
703 TRACE_(d3d_caps
)("found driver version (%s)->%i.%i->(0x%08x)\n", debugstr_a(gl_string
), major
, minor
, gl_info
->driver_version
);
704 /* Current Windows drivers have versions like 6.14.... (some older have an earlier version) */
705 gl_info
->driver_version_hipart
= MAKEDWORD_VERSION(6, 14);
707 FIXME("OpenGL driver did not return version information\n");
708 gl_info
->driver_version
= MAKEDWORD_VERSION(0, 0);
709 gl_info
->driver_version_hipart
= MAKEDWORD_VERSION(6, 14);
712 TRACE_(d3d_caps
)("found GL_RENDERER (%s)->(0x%04x)\n", debugstr_a(gl_info
->gl_renderer
), gl_info
->gl_card
);
715 * Initialize openGL extension related variables
716 * with Default values
718 memset(gl_info
->supported
, 0, sizeof(gl_info
->supported
));
719 gl_info
->max_buffers
= 1;
720 gl_info
->max_textures
= 1;
721 gl_info
->max_texture_stages
= 1;
722 gl_info
->max_fragment_samplers
= 1;
723 gl_info
->max_vertex_samplers
= 0;
724 gl_info
->max_combined_samplers
= gl_info
->max_fragment_samplers
+ gl_info
->max_vertex_samplers
;
725 gl_info
->max_sampler_stages
= 1;
726 gl_info
->ps_arb_version
= PS_VERSION_NOT_SUPPORTED
;
727 gl_info
->ps_arb_max_temps
= 0;
728 gl_info
->ps_arb_max_instructions
= 0;
729 gl_info
->vs_arb_version
= VS_VERSION_NOT_SUPPORTED
;
730 gl_info
->vs_arb_max_temps
= 0;
731 gl_info
->vs_arb_max_instructions
= 0;
732 gl_info
->vs_nv_version
= VS_VERSION_NOT_SUPPORTED
;
733 gl_info
->vs_ati_version
= VS_VERSION_NOT_SUPPORTED
;
734 gl_info
->vs_glsl_constantsF
= 0;
735 gl_info
->ps_glsl_constantsF
= 0;
736 gl_info
->vs_arb_constantsF
= 0;
737 gl_info
->ps_arb_constantsF
= 0;
739 /* Retrieve opengl defaults */
740 glGetIntegerv(GL_MAX_CLIP_PLANES
, &gl_max
);
741 gl_info
->max_clipplanes
= min(WINED3DMAXUSERCLIPPLANES
, gl_max
);
742 TRACE_(d3d_caps
)("ClipPlanes support - num Planes=%d\n", gl_max
);
744 glGetIntegerv(GL_MAX_LIGHTS
, &gl_max
);
745 gl_info
->max_lights
= gl_max
;
746 TRACE_(d3d_caps
)("Lights support - max lights=%d\n", gl_max
);
748 glGetIntegerv(GL_MAX_TEXTURE_SIZE
, &gl_max
);
749 gl_info
->max_texture_size
= gl_max
;
750 TRACE_(d3d_caps
)("Maximum texture size support - max texture size=%d\n", gl_max
);
752 glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE
, gl_floatv
);
753 gl_info
->max_pointsizemin
= gl_floatv
[0];
754 gl_info
->max_pointsize
= gl_floatv
[1];
755 TRACE_(d3d_caps
)("Maximum point size support - max point size=%f\n", gl_floatv
[1]);
757 /* Parse the gl supported features, in theory enabling parts of our code appropriately */
758 GL_Extensions
= (const char *) glGetString(GL_EXTENSIONS
);
759 TRACE_(d3d_caps
)("GL_Extensions reported:\n");
761 if (NULL
== GL_Extensions
) {
762 ERR(" GL_Extensions returns NULL\n");
764 while (*GL_Extensions
!= 0x00) {
769 while (isspace(*GL_Extensions
)) GL_Extensions
++;
770 Start
= GL_Extensions
;
771 while (!isspace(*GL_Extensions
) && *GL_Extensions
!= 0x00) {
775 len
= GL_Extensions
- Start
;
776 if (len
== 0 || len
>= sizeof(ThisExtn
))
779 memcpy(ThisExtn
, Start
, len
);
780 ThisExtn
[len
] = '\0';
781 TRACE_(d3d_caps
)("- %s\n", ThisExtn
);
783 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
784 if (!strcmp(ThisExtn
, EXTENSION_MAP
[i
].extension_string
)) {
785 TRACE_(d3d_caps
)(" FOUND: %s support\n", EXTENSION_MAP
[i
].extension_string
);
786 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
794 /* Now work out what GL support this card really has */
795 #define USE_GL_FUNC(type, pfn, ext, replace) { \
796 DWORD ver = ver_for_ext(ext); \
797 if(gl_info->supported[ext]) gl_info->pfn = (type) pwglGetProcAddress(#pfn); \
798 else if(ver && ver <= gl_info->gl_version) gl_info->pfn = (type) pwglGetProcAddress(#replace); \
799 else gl_info->pfn = NULL; \
804 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type) pwglGetProcAddress(#pfn);
809 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
810 * loading the functions, otherwise the code above will load the extension entry points instead of the
811 * core functions, which may not work
813 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
814 if (gl_info
->supported
[EXTENSION_MAP
[i
].extension
] == FALSE
&&
815 EXTENSION_MAP
[i
].version
<= gl_info
->gl_version
&& EXTENSION_MAP
[i
].version
) {
816 TRACE_(d3d_caps
)(" GL CORE: %s support\n", EXTENSION_MAP
[i
].extension_string
);
817 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
821 if (gl_info
->supported
[APPLE_FENCE
]) {
822 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
823 * The apple extension interacts with some other apple exts. Disable the NV
824 * extension if the apple one is support to prevent confusion in other parts
827 gl_info
->supported
[NV_FENCE
] = FALSE
;
829 if (gl_info
->supported
[APPLE_FLOAT_PIXELS
]) {
830 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
832 * The enums are the same:
833 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
834 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
835 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
836 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
837 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
839 if(!gl_info
->supported
[ARB_TEXTURE_FLOAT
]) {
840 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels\n");
841 gl_info
->supported
[ARB_TEXTURE_FLOAT
] = TRUE
;
843 if(!gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
]) {
844 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels\n");
845 gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
] = TRUE
;
848 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
]) {
849 TRACE_(d3d_caps
)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support\n");
850 gl_info
->supported
[NV_TEXGEN_REFLECTION
] = TRUE
;
852 if (gl_info
->supported
[NV_TEXTURE_SHADER2
]) {
853 if(gl_info
->supported
[NV_REGISTER_COMBINERS
]) {
854 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
855 * are supported. The nv extensions provide the same functionality as the
856 * ATI one, and a bit more(signed pixelformats)
858 gl_info
->supported
[ATI_FRAGMENT_SHADER
] = FALSE
;
861 if (gl_info
->supported
[ARB_DRAW_BUFFERS
]) {
862 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB
, &gl_max
);
863 gl_info
->max_buffers
= gl_max
;
864 TRACE_(d3d_caps
)("Max draw buffers: %u\n", gl_max
);
866 if (gl_info
->supported
[ARB_MULTITEXTURE
]) {
867 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB
, &gl_max
);
868 gl_info
->max_textures
= min(MAX_TEXTURES
, gl_max
);
869 TRACE_(d3d_caps
)("Max textures: %d\n", gl_info
->max_textures
);
871 if (gl_info
->supported
[NV_REGISTER_COMBINERS
]) {
873 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV
, &tmp
);
874 gl_info
->max_texture_stages
= min(MAX_TEXTURES
, tmp
);
876 gl_info
->max_texture_stages
= min(MAX_TEXTURES
, gl_max
);
878 TRACE_(d3d_caps
)("Max texture stages: %d\n", gl_info
->max_texture_stages
);
880 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) {
882 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
883 gl_info
->max_fragment_samplers
= min(MAX_FRAGMENT_SAMPLERS
, tmp
);
885 gl_info
->max_fragment_samplers
= max(gl_info
->max_fragment_samplers
, gl_max
);
887 TRACE_(d3d_caps
)("Max fragment samplers: %d\n", gl_info
->max_fragment_samplers
);
889 if (gl_info
->supported
[ARB_VERTEX_SHADER
]) {
891 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
892 gl_info
->max_vertex_samplers
= tmp
;
893 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
894 gl_info
->max_combined_samplers
= tmp
;
896 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
897 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
898 * an issue because then the sampler setup only depends on the two shaders. If a pixel
899 * shader is used with fixed function vertex processing we're fine too because fixed function
900 * vertex processing doesn't use any samplers. If fixed function fragment processing is
901 * used we have to make sure that all vertex sampler setups are valid together with all
902 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
903 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
904 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
905 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
906 * a fixed function pipeline anymore.
908 * So this is just a check to check that our assumption holds true. If not, write a warning
909 * and reduce the number of vertex samplers or probably disable vertex texture fetch.
911 if(gl_info
->max_vertex_samplers
&&
912 MAX_TEXTURES
+ gl_info
->max_vertex_samplers
> gl_info
->max_combined_samplers
) {
913 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers\n",
914 gl_info
->max_vertex_samplers
, gl_info
->max_combined_samplers
);
915 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers\n");
916 if( gl_info
->max_combined_samplers
> MAX_TEXTURES
)
917 gl_info
->max_vertex_samplers
=
918 gl_info
->max_combined_samplers
- MAX_TEXTURES
;
920 gl_info
->max_vertex_samplers
= 0;
923 gl_info
->max_combined_samplers
= gl_info
->max_fragment_samplers
;
925 TRACE_(d3d_caps
)("Max vertex samplers: %u\n", gl_info
->max_vertex_samplers
);
926 TRACE_(d3d_caps
)("Max combined samplers: %u\n", gl_info
->max_combined_samplers
);
928 if (gl_info
->supported
[ARB_VERTEX_BLEND
]) {
929 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB
, &gl_max
);
930 gl_info
->max_blends
= gl_max
;
931 TRACE_(d3d_caps
)("Max blends: %u\n", gl_info
->max_blends
);
933 if (gl_info
->supported
[EXT_TEXTURE3D
]) {
934 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT
, &gl_max
);
935 gl_info
->max_texture3d_size
= gl_max
;
936 TRACE_(d3d_caps
)("Max texture3D size: %d\n", gl_info
->max_texture3d_size
);
938 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
]) {
939 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
, &gl_max
);
940 gl_info
->max_anisotropy
= gl_max
;
941 TRACE_(d3d_caps
)("Max anisotropy: %d\n", gl_info
->max_anisotropy
);
943 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) {
944 gl_info
->ps_arb_version
= PS_VERSION_11
;
945 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
946 gl_info
->ps_arb_constantsF
= gl_max
;
947 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM float constants: %d\n", gl_info
->ps_arb_constantsF
);
948 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
949 gl_info
->ps_arb_max_temps
= gl_max
;
950 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d\n", gl_info
->ps_arb_max_temps
);
951 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
952 gl_info
->ps_arb_max_instructions
= gl_max
;
953 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native instructions: %d\n", gl_info
->ps_arb_max_instructions
);
955 if (gl_info
->supported
[ARB_VERTEX_PROGRAM
]) {
956 gl_info
->vs_arb_version
= VS_VERSION_11
;
957 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
958 gl_info
->vs_arb_constantsF
= gl_max
;
959 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM float constants: %d\n", gl_info
->vs_arb_constantsF
);
960 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
961 gl_info
->vs_arb_max_temps
= gl_max
;
962 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native temporaries: %d\n", gl_info
->vs_arb_max_temps
);
963 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
964 gl_info
->vs_arb_max_instructions
= gl_max
;
965 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native instructions: %d\n", gl_info
->vs_arb_max_instructions
);
967 gl_info
->arb_vs_offset_limit
= test_arb_vs_offset_limit(gl_info
);
969 if (gl_info
->supported
[ARB_VERTEX_SHADER
]) {
970 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
, &gl_max
);
971 gl_info
->vs_glsl_constantsF
= gl_max
/ 4;
972 TRACE_(d3d_caps
)("Max ARB_VERTEX_SHADER float constants: %u\n", gl_info
->vs_glsl_constantsF
);
974 if (gl_info
->supported
[ARB_FRAGMENT_SHADER
]) {
975 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB
, &gl_max
);
976 gl_info
->ps_glsl_constantsF
= gl_max
/ 4;
977 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_SHADER float constants: %u\n", gl_info
->ps_glsl_constantsF
);
978 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB
, &gl_max
);
979 gl_info
->max_glsl_varyings
= gl_max
;
980 TRACE_(d3d_caps
)("Max GLSL varyings: %u (%u 4 component varyings)\n", gl_max
, gl_max
/ 4);
982 if (gl_info
->supported
[EXT_VERTEX_SHADER
]) {
983 gl_info
->vs_ati_version
= VS_VERSION_11
;
985 if (gl_info
->supported
[NV_VERTEX_PROGRAM3
]) {
986 gl_info
->vs_nv_version
= VS_VERSION_30
;
987 } else if (gl_info
->supported
[NV_VERTEX_PROGRAM2
]) {
988 gl_info
->vs_nv_version
= VS_VERSION_20
;
989 } else if (gl_info
->supported
[NV_VERTEX_PROGRAM1_1
]) {
990 gl_info
->vs_nv_version
= VS_VERSION_11
;
991 } else if (gl_info
->supported
[NV_VERTEX_PROGRAM
]) {
992 gl_info
->vs_nv_version
= VS_VERSION_10
;
994 if (gl_info
->supported
[NV_FRAGMENT_PROGRAM2
]) {
995 gl_info
->ps_nv_version
= PS_VERSION_30
;
996 } else if (gl_info
->supported
[NV_FRAGMENT_PROGRAM
]) {
997 gl_info
->ps_nv_version
= PS_VERSION_20
;
999 if (gl_info
->supported
[NV_LIGHT_MAX_EXPONENT
]) {
1000 glGetFloatv(GL_MAX_SHININESS_NV
, &gl_info
->max_shininess
);
1002 gl_info
->max_shininess
= 128.0;
1004 if (gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
]) {
1005 /* If we have full NP2 texture support, disable GL_ARB_texture_rectangle because we will never use it.
1006 * This saves a few redundant glDisable calls
1008 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = FALSE
;
1010 if(gl_info
->supported
[ATI_FRAGMENT_SHADER
]) {
1011 /* Disable NV_register_combiners and fragment shader if this is supported.
1012 * generally the NV extensions are preferred over the ATI ones, and this
1013 * extension is disabled if register_combiners and texture_shader2 are both
1014 * supported. So we reach this place only if we have incomplete NV dxlevel 8
1015 * fragment processing support
1017 gl_info
->supported
[NV_REGISTER_COMBINERS
] = FALSE
;
1018 gl_info
->supported
[NV_REGISTER_COMBINERS2
] = FALSE
;
1019 gl_info
->supported
[NV_TEXTURE_SHADER
] = FALSE
;
1020 gl_info
->supported
[NV_TEXTURE_SHADER2
] = FALSE
;
1021 gl_info
->supported
[NV_TEXTURE_SHADER3
] = FALSE
;
1025 checkGLcall("extension detection\n");
1027 /* In some cases the number of texture stages can be larger than the number
1028 * of samplers. The GF4 for example can use only 2 samplers (no fragment
1029 * shaders), but 8 texture stages (register combiners). */
1030 gl_info
->max_sampler_stages
= max(gl_info
->max_fragment_samplers
, gl_info
->max_texture_stages
);
1032 /* We can only use ORM_FBO when the hardware supports it. */
1033 if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
&& !gl_info
->supported
[EXT_FRAMEBUFFER_OBJECT
]) {
1034 WARN_(d3d_caps
)("GL_EXT_framebuffer_object not supported, falling back to PBuffer offscreen rendering mode.\n");
1035 wined3d_settings
.offscreen_rendering_mode
= ORM_PBUFFER
;
1038 /* MRTs are currently only supported when FBOs are used. */
1039 if (wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
) {
1040 gl_info
->max_buffers
= 1;
1043 /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of different GPUs with roughly the same
1044 * features. In most cases GPUs from a certain family differ in clockspeeds, the amount of video memory and
1045 * in case of the latest videocards in the number of pixel/vertex pipelines.
1047 * A Direct3D device object contains the PCI id (vendor + device) of the videocard which is used for
1048 * rendering. Various games use this information to get a rough estimation of the features of the card
1049 * and some might use it for enabling 3d effects only on certain types of videocards. In some cases
1050 * games might even use it to work around bugs which happen on certain videocards/driver combinations.
1051 * The problem is that OpenGL only exposes a rendering string containing the name of the videocard and
1054 * Various games depend on the PCI id, so somehow we need to provide one. A simple option is to parse
1055 * the renderer string and translate this to the right PCI id. This is a lot of work because there are more
1056 * than 200 GPUs just for Nvidia. Various cards share the same renderer string, so the amount of code might
1057 * be 'small' but there are quite a number of exceptions which would make this a pain to maintain.
1058 * Another way would be to query the PCI id from the operating system (assuming this is the videocard which
1059 * is used for rendering which is not always the case). This would work but it is not very portable. Second
1060 * it would not work well in, let's say, a remote X situation in which the amount of 3d features which can be used
1063 * As said most games only use the PCI id to get an indication of the capabilities of the card.
1064 * It doesn't really matter if the given id is the correct one if we return the id of a card with
1065 * similar 3d features.
1067 * The code below checks the OpenGL capabilities of a videocard and matches that to a certain level of
1068 * Direct3D functionality. Once a card passes the Direct3D9 check, we know that the card (in case of Nvidia)
1069 * is at least a GeforceFX. To give a better estimate we do a basic check on the renderer string but if that
1070 * won't pass we return a default card. This way is better than maintaining a full card database as even
1071 * without a full database we can return a card with similar features. Second the size of the database
1072 * can be made quite small because when you know what type of 3d functionality a card has, you know to which
1073 * GPU family the GPU must belong. Because of this you only have to check a small part of the renderer string
1074 * to distinguishes between different models from that family.
1076 * The code also selects a default amount of video memory which we will use for an estimation of the amount
1077 * of free texture memory. In case of real D3D the amount of texture memory includes video memory and system
1078 * memory (to be specific AGP memory or in case of PCIE TurboCache/HyperMemory). We don't know how much
1079 * system memory can be addressed by the system but we can make a reasonable estimation about the amount of
1080 * video memory. If the value is slightly wrong it doesn't matter as we didn't include AGP-like memory which
1081 * makes the amount of addressable memory higher and second OpenGL isn't that critical it moves to system
1082 * memory behind our backs if really needed.
1083 * Note that the amount of video memory can be overruled using a registry setting.
1085 switch (gl_info
->gl_vendor
) {
1087 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1088 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1090 if(WINE_D3D9_CAPABLE(gl_info
) && (gl_info
->vs_nv_version
== VS_VERSION_30
)) {
1091 /* Geforce GTX - highend */
1092 if(strstr(gl_info
->gl_renderer
, "GTX 280")) {
1093 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_GTX280
;
1096 /* Geforce9 - highend */
1097 else if(strstr(gl_info
->gl_renderer
, "9800")) {
1098 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_9800GT
;
1101 /* Geforce9 - midend */
1102 else if(strstr(gl_info
->gl_renderer
, "9600")) {
1103 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_9600GT
;
1104 vidmem
= 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1106 /* Geforce8 - highend */
1107 else if (strstr(gl_info
->gl_renderer
, "8800")) {
1108 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8800GTS
;
1109 vidmem
= 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1111 /* Geforce8 - midend mobile */
1112 else if(strstr(gl_info
->gl_renderer
, "8600 M")) {
1113 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8600MGT
;
1116 /* Geforce8 - midend */
1117 else if(strstr(gl_info
->gl_renderer
, "8600") ||
1118 strstr(gl_info
->gl_renderer
, "8700"))
1120 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8600GT
;
1123 /* Geforce8 - lowend */
1124 else if(strstr(gl_info
->gl_renderer
, "8300") ||
1125 strstr(gl_info
->gl_renderer
, "8400") ||
1126 strstr(gl_info
->gl_renderer
, "8500"))
1128 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_8300GS
;
1129 vidmem
= 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1131 /* Geforce7 - highend */
1132 else if(strstr(gl_info
->gl_renderer
, "7800") ||
1133 strstr(gl_info
->gl_renderer
, "7900") ||
1134 strstr(gl_info
->gl_renderer
, "7950") ||
1135 strstr(gl_info
->gl_renderer
, "Quadro FX 4") ||
1136 strstr(gl_info
->gl_renderer
, "Quadro FX 5"))
1138 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7800GT
;
1139 vidmem
= 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1141 /* Geforce7 midend */
1142 else if(strstr(gl_info
->gl_renderer
, "7600") ||
1143 strstr(gl_info
->gl_renderer
, "7700")) {
1144 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7600
;
1145 vidmem
= 256; /* The 7600 uses 256-512MB */
1146 /* Geforce7 lower medium */
1147 } else if(strstr(gl_info
->gl_renderer
, "7400")) {
1148 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7400
;
1149 vidmem
= 256; /* The 7400 uses 256-512MB */
1151 /* Geforce7 lowend */
1152 else if(strstr(gl_info
->gl_renderer
, "7300")) {
1153 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_7300
;
1154 vidmem
= 256; /* Mac Pros with this card have 256 MB */
1156 /* Geforce6 highend */
1157 else if(strstr(gl_info
->gl_renderer
, "6800"))
1159 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_6800
;
1160 vidmem
= 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1162 /* Geforce6 - midend */
1163 else if(strstr(gl_info
->gl_renderer
, "6600") ||
1164 strstr(gl_info
->gl_renderer
, "6610") ||
1165 strstr(gl_info
->gl_renderer
, "6700"))
1167 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_6600GT
;
1168 vidmem
= 128; /* A 6600GT has 128-256MB */
1170 /* Geforce6/7 lowend */
1172 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE_6200
; /* Geforce 6100/6150/6200/7300/7400/7500 */
1175 } else if(WINE_D3D9_CAPABLE(gl_info
)) {
1176 /* GeforceFX - highend */
1177 if (strstr(gl_info
->gl_renderer
, "5800") ||
1178 strstr(gl_info
->gl_renderer
, "5900") ||
1179 strstr(gl_info
->gl_renderer
, "5950") ||
1180 strstr(gl_info
->gl_renderer
, "Quadro FX"))
1182 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5800
;
1183 vidmem
= 256; /* 5800-5900 cards use 256MB */
1185 /* GeforceFX - midend */
1186 else if(strstr(gl_info
->gl_renderer
, "5600") ||
1187 strstr(gl_info
->gl_renderer
, "5650") ||
1188 strstr(gl_info
->gl_renderer
, "5700") ||
1189 strstr(gl_info
->gl_renderer
, "5750"))
1191 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5600
;
1192 vidmem
= 128; /* A 5600 uses 128-256MB */
1194 /* GeforceFX - lowend */
1196 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5200
; /* GeforceFX 5100/5200/5250/5300/5500 */
1197 vidmem
= 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1199 } else if(WINE_D3D8_CAPABLE(gl_info
)) {
1200 if (strstr(gl_info
->gl_renderer
, "GeForce4 Ti") || strstr(gl_info
->gl_renderer
, "Quadro4")) {
1201 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE4_TI4200
; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1202 vidmem
= 64; /* Geforce4 Ti cards have 64-128MB */
1205 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE3
; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1206 vidmem
= 64; /* Geforce3 cards have 64-128MB */
1208 } else if(WINE_D3D7_CAPABLE(gl_info
)) {
1209 if (strstr(gl_info
->gl_renderer
, "GeForce4 MX")) {
1210 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE4_MX
; /* MX420/MX440/MX460/MX4000 */
1211 vidmem
= 64; /* Most Geforce4MX GPUs have at least 64MB of memory, some early models had 32MB but most have 64MB or even 128MB */
1213 else if(strstr(gl_info
->gl_renderer
, "GeForce2 MX") || strstr(gl_info
->gl_renderer
, "Quadro2 MXR")) {
1214 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE2_MX
; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1215 vidmem
= 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1217 else if(strstr(gl_info
->gl_renderer
, "GeForce2") || strstr(gl_info
->gl_renderer
, "Quadro2")) {
1218 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE2
; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1219 vidmem
= 32; /* Geforce2 GPUs have 32-64MB of video memory */
1222 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE
; /* Geforce 256/DDR, Quadro */
1223 vidmem
= 32; /* Most Geforce1 cards have 32MB, there are also some rare 16 and 64MB (Dell) models */
1226 if (strstr(gl_info
->gl_renderer
, "TNT2")) {
1227 gl_info
->gl_card
= CARD_NVIDIA_RIVA_TNT2
; /* Riva TNT2 standard/M64/Pro/Ultra */
1228 vidmem
= 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1231 gl_info
->gl_card
= CARD_NVIDIA_RIVA_TNT
; /* Riva TNT, Vanta */
1232 vidmem
= 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1237 if(WINE_D3D9_CAPABLE(gl_info
)) {
1238 /* Radeon R6xx HD2900/HD3800 - highend */
1239 if (strstr(gl_info
->gl_renderer
, "HD 2900") ||
1240 strstr(gl_info
->gl_renderer
, "HD 3870") ||
1241 strstr(gl_info
->gl_renderer
, "HD 3850"))
1243 gl_info
->gl_card
= CARD_ATI_RADEON_HD2900
;
1244 vidmem
= 512; /* HD2900/HD3800 uses 256-1024MB */
1246 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1247 else if (strstr(gl_info
->gl_renderer
, "HD 2600") ||
1248 strstr(gl_info
->gl_renderer
, "HD 3830") ||
1249 strstr(gl_info
->gl_renderer
, "HD 3690") ||
1250 strstr(gl_info
->gl_renderer
, "HD 3650"))
1252 gl_info
->gl_card
= CARD_ATI_RADEON_HD2600
;
1253 vidmem
= 256; /* HD2600/HD3600 uses 256-512MB */
1255 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1256 else if (strstr(gl_info
->gl_renderer
, "HD 2300") ||
1257 strstr(gl_info
->gl_renderer
, "HD 2400") ||
1258 strstr(gl_info
->gl_renderer
, "HD 3470") ||
1259 strstr(gl_info
->gl_renderer
, "HD 3450") ||
1260 strstr(gl_info
->gl_renderer
, "HD 3430"))
1262 gl_info
->gl_card
= CARD_ATI_RADEON_HD2300
;
1263 vidmem
= 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1265 /* Radeon R6xx/R7xx integrated */
1266 else if (strstr(gl_info
->gl_renderer
, "HD 3100") ||
1267 strstr(gl_info
->gl_renderer
, "HD 3200") ||
1268 strstr(gl_info
->gl_renderer
, "HD 3300"))
1270 gl_info
->gl_card
= CARD_ATI_RADEON_HD3200
;
1271 vidmem
= 128; /* 128MB */
1274 else if (strstr(gl_info
->gl_renderer
, "X1600") ||
1275 strstr(gl_info
->gl_renderer
, "X1650") ||
1276 strstr(gl_info
->gl_renderer
, "X1800") ||
1277 strstr(gl_info
->gl_renderer
, "X1900") ||
1278 strstr(gl_info
->gl_renderer
, "X1950"))
1280 gl_info
->gl_card
= CARD_ATI_RADEON_X1600
;
1281 vidmem
= 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1283 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1284 else if(strstr(gl_info
->gl_renderer
, "X700") ||
1285 strstr(gl_info
->gl_renderer
, "X800") ||
1286 strstr(gl_info
->gl_renderer
, "X850") ||
1287 strstr(gl_info
->gl_renderer
, "X1300") ||
1288 strstr(gl_info
->gl_renderer
, "X1400") ||
1289 strstr(gl_info
->gl_renderer
, "X1450") ||
1290 strstr(gl_info
->gl_renderer
, "X1550"))
1292 gl_info
->gl_card
= CARD_ATI_RADEON_X700
;
1293 vidmem
= 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1295 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1296 else if(strstr(gl_info
->gl_renderer
, "Radeon Xpress"))
1298 gl_info
->gl_card
= CARD_ATI_RADEON_XPRESS_200M
;
1299 vidmem
= 64; /* Shared RAM, BIOS configurable, 64-256M */
1303 gl_info
->gl_card
= CARD_ATI_RADEON_9500
; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1304 vidmem
= 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1306 } else if(WINE_D3D8_CAPABLE(gl_info
)) {
1307 gl_info
->gl_card
= CARD_ATI_RADEON_8500
; /* Radeon 8500/9000/9100/9200/9300 */
1308 vidmem
= 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1309 } else if(WINE_D3D7_CAPABLE(gl_info
)) {
1310 gl_info
->gl_card
= CARD_ATI_RADEON_7200
; /* Radeon 7000/7100/7200/7500 */
1311 vidmem
= 32; /* There are models with up to 64MB */
1313 gl_info
->gl_card
= CARD_ATI_RAGE_128PRO
;
1314 vidmem
= 16; /* There are 16-32MB models */
1318 if (strstr(gl_info
->gl_renderer
, "GMA 950") ||
1319 strstr(gl_info
->gl_renderer
, "945GM")) {
1320 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1321 gl_info
->gl_card
= CARD_INTEL_I945GM
;
1323 } else if (strstr(gl_info
->gl_renderer
, "915GM")) {
1324 gl_info
->gl_card
= CARD_INTEL_I915GM
;
1325 } else if (strstr(gl_info
->gl_renderer
, "915G")) {
1326 gl_info
->gl_card
= CARD_INTEL_I915G
;
1327 } else if (strstr(gl_info
->gl_renderer
, "865G")) {
1328 gl_info
->gl_card
= CARD_INTEL_I865G
;
1329 } else if (strstr(gl_info
->gl_renderer
, "855G")) {
1330 gl_info
->gl_card
= CARD_INTEL_I855G
;
1331 } else if (strstr(gl_info
->gl_renderer
, "830G")) {
1332 gl_info
->gl_card
= CARD_INTEL_I830G
;
1334 gl_info
->gl_card
= CARD_INTEL_I915G
;
1340 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1341 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1342 * them a good generic choice.
1344 gl_info
->gl_vendor
= VENDOR_NVIDIA
;
1345 if(WINE_D3D9_CAPABLE(gl_info
))
1346 gl_info
->gl_card
= CARD_NVIDIA_GEFORCEFX_5600
;
1347 else if(WINE_D3D8_CAPABLE(gl_info
))
1348 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE3
;
1349 else if(WINE_D3D7_CAPABLE(gl_info
))
1350 gl_info
->gl_card
= CARD_NVIDIA_GEFORCE
;
1351 else if(WINE_D3D6_CAPABLE(gl_info
))
1352 gl_info
->gl_card
= CARD_NVIDIA_RIVA_TNT
;
1354 gl_info
->gl_card
= CARD_NVIDIA_RIVA_128
;
1356 TRACE_(d3d_caps
)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", gl_info
->gl_vendor
, gl_info
->gl_card
);
1358 /* If we have an estimate use it, else default to 64MB; */
1360 gl_info
->vidmem
= vidmem
*1024*1024; /* convert from MBs to bytes */
1362 gl_info
->vidmem
= WINE_DEFAULT_VIDMEM
;
1364 /* Load all the lookup tables */
1365 for (i
= 0; i
< MAX_LOOKUPS
; i
++) {
1366 stateLookup
[i
] = HeapAlloc(GetProcessHeap(), 0, sizeof(*stateLookup
[i
]) * (1 + maxLookup
[i
] - minLookup
[i
]) );
1369 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_WRAP
- minLookup
[WINELOOKUP_WARPPARAM
]] = GL_REPEAT
;
1370 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_CLAMP
- minLookup
[WINELOOKUP_WARPPARAM
]] = GL_CLAMP_TO_EDGE
;
1371 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_BORDER
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1372 gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
] ? GL_CLAMP_TO_BORDER_ARB
: GL_REPEAT
;
1373 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_BORDER
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1374 gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
] ? GL_CLAMP_TO_BORDER_ARB
: GL_REPEAT
;
1375 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_MIRROR
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1376 gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
] ? GL_MIRRORED_REPEAT_ARB
: GL_REPEAT
;
1377 stateLookup
[WINELOOKUP_WARPPARAM
][WINED3DTADDRESS_MIRRORONCE
- minLookup
[WINELOOKUP_WARPPARAM
]] =
1378 gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
] ? GL_MIRROR_CLAMP_TO_EDGE_ATI
: GL_REPEAT
;
1380 magLookup
[WINED3DTEXF_NONE
- WINED3DTEXF_NONE
] = GL_NEAREST
;
1381 magLookup
[WINED3DTEXF_POINT
- WINED3DTEXF_NONE
] = GL_NEAREST
;
1382 magLookup
[WINED3DTEXF_LINEAR
- WINED3DTEXF_NONE
] = GL_LINEAR
;
1383 magLookup
[WINED3DTEXF_ANISOTROPIC
- WINED3DTEXF_NONE
] =
1384 gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ? GL_LINEAR
: GL_NEAREST
;
1387 minMipLookup
[WINED3DTEXF_NONE
].mip
[WINED3DTEXF_NONE
] = GL_LINEAR
;
1388 minMipLookup
[WINED3DTEXF_NONE
].mip
[WINED3DTEXF_POINT
] = GL_LINEAR
;
1389 minMipLookup
[WINED3DTEXF_NONE
].mip
[WINED3DTEXF_LINEAR
] = GL_LINEAR
;
1390 minMipLookup
[WINED3DTEXF_POINT
].mip
[WINED3DTEXF_NONE
] = GL_NEAREST
;
1391 minMipLookup
[WINED3DTEXF_POINT
].mip
[WINED3DTEXF_POINT
] = GL_NEAREST_MIPMAP_NEAREST
;
1392 minMipLookup
[WINED3DTEXF_POINT
].mip
[WINED3DTEXF_LINEAR
] = GL_NEAREST_MIPMAP_LINEAR
;
1393 minMipLookup
[WINED3DTEXF_LINEAR
].mip
[WINED3DTEXF_NONE
] = GL_LINEAR
;
1394 minMipLookup
[WINED3DTEXF_LINEAR
].mip
[WINED3DTEXF_POINT
] = GL_LINEAR_MIPMAP_NEAREST
;
1395 minMipLookup
[WINED3DTEXF_LINEAR
].mip
[WINED3DTEXF_LINEAR
] = GL_LINEAR_MIPMAP_LINEAR
;
1396 minMipLookup
[WINED3DTEXF_ANISOTROPIC
].mip
[WINED3DTEXF_NONE
]
1397 = gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ? GL_LINEAR_MIPMAP_LINEAR
: GL_LINEAR
;
1398 minMipLookup
[WINED3DTEXF_ANISOTROPIC
].mip
[WINED3DTEXF_POINT
]
1399 = gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ? GL_LINEAR_MIPMAP_NEAREST
: GL_LINEAR
;
1400 minMipLookup
[WINED3DTEXF_ANISOTROPIC
].mip
[WINED3DTEXF_LINEAR
]
1401 = gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
] ? GL_LINEAR_MIPMAP_LINEAR
: GL_LINEAR
;
1403 /* TODO: config lookups */
1405 /* Make sure there's an active HDC else the WGL extensions will fail */
1406 hdc
= pwglGetCurrentDC();
1408 WGL_Extensions
= GL_EXTCALL(wglGetExtensionsStringARB(hdc
));
1409 TRACE_(d3d_caps
)("WGL_Extensions reported:\n");
1411 if (NULL
== WGL_Extensions
) {
1412 ERR(" WGL_Extensions returns NULL\n");
1414 while (*WGL_Extensions
!= 0x00) {
1419 while (isspace(*WGL_Extensions
)) WGL_Extensions
++;
1420 Start
= WGL_Extensions
;
1421 while (!isspace(*WGL_Extensions
) && *WGL_Extensions
!= 0x00) {
1425 len
= WGL_Extensions
- Start
;
1426 if (len
== 0 || len
>= sizeof(ThisExtn
))
1429 memcpy(ThisExtn
, Start
, len
);
1430 ThisExtn
[len
] = '\0';
1431 TRACE_(d3d_caps
)("- %s\n", ThisExtn
);
1433 if (!strcmp(ThisExtn
, "WGL_ARB_pbuffer")) {
1434 gl_info
->supported
[WGL_ARB_PBUFFER
] = TRUE
;
1435 TRACE_(d3d_caps
)("FOUND: WGL_ARB_pbuffer support\n");
1437 if (!strcmp(ThisExtn
, "WGL_ARB_pixel_format")) {
1438 gl_info
->supported
[WGL_ARB_PIXEL_FORMAT
] = TRUE
;
1439 TRACE_(d3d_caps
)("FOUND: WGL_ARB_pixel_format support\n");
1441 if (!strcmp(ThisExtn
, "WGL_WINE_pixel_format_passthrough")) {
1442 gl_info
->supported
[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH
] = TRUE
;
1443 TRACE_(d3d_caps
)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
1450 return return_value
;
1453 /**********************************************************
1454 * IWineD3D implementation follows
1455 **********************************************************/
1457 static UINT WINAPI
IWineD3DImpl_GetAdapterCount (IWineD3D
*iface
) {
1458 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1460 TRACE_(d3d_caps
)("(%p): Reporting %u adapters\n", This
, This
->adapter_count
);
1462 return This
->adapter_count
;
1465 static HRESULT WINAPI
IWineD3DImpl_RegisterSoftwareDevice(IWineD3D
*iface
, void* pInitializeFunction
) {
1466 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1467 FIXME("(%p)->(%p): stub\n", This
, pInitializeFunction
);
1471 static HMONITOR WINAPI
IWineD3DImpl_GetAdapterMonitor(IWineD3D
*iface
, UINT Adapter
) {
1472 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1474 TRACE_(d3d_caps
)("(%p)->(%d)\n", This
, Adapter
);
1476 if (Adapter
>= IWineD3DImpl_GetAdapterCount(iface
)) {
1480 return MonitorFromPoint(This
->adapters
[Adapter
].monitorPoint
, MONITOR_DEFAULTTOPRIMARY
);
1483 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
1484 of the same bpp but different resolutions */
1486 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1487 static UINT WINAPI
IWineD3DImpl_GetAdapterModeCount(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
) {
1488 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1489 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Format: %s)\n", This
, Adapter
, debug_d3dformat(Format
));
1491 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1495 /* TODO: Store modes per adapter and read it from the adapter structure */
1496 if (Adapter
== 0) { /* Display */
1500 if (!DEBUG_SINGLE_MODE
) {
1503 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
1504 DevModeW
.dmSize
= sizeof(DevModeW
);
1505 while (EnumDisplaySettingsExW(NULL
, j
, &DevModeW
, 0)) {
1509 case WINED3DFMT_UNKNOWN
:
1510 /* This is for D3D8, do not enumerate P8 here */
1511 if (DevModeW
.dmBitsPerPel
== 32 ||
1512 DevModeW
.dmBitsPerPel
== 16) i
++;
1514 case WINED3DFMT_X8R8G8B8
:
1515 if (DevModeW
.dmBitsPerPel
== 32) i
++;
1517 case WINED3DFMT_R5G6B5
:
1518 if (DevModeW
.dmBitsPerPel
== 16) i
++;
1521 if (DevModeW
.dmBitsPerPel
== 8) i
++;
1524 /* Skip other modes as they do not match the requested format */
1533 TRACE_(d3d_caps
)("(%p}->(Adapter: %d) => %d (out of %d)\n", This
, Adapter
, i
, j
);
1536 FIXME_(d3d_caps
)("Adapter not primary display\n");
1541 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
1542 static HRESULT WINAPI
IWineD3DImpl_EnumAdapterModes(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
, UINT Mode
, WINED3DDISPLAYMODE
* pMode
) {
1543 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1544 TRACE_(d3d_caps
)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This
, Adapter
, Mode
, pMode
, debug_d3dformat(Format
));
1546 /* Validate the parameters as much as possible */
1547 if (NULL
== pMode
||
1548 Adapter
>= IWineD3DImpl_GetAdapterCount(iface
) ||
1549 Mode
>= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, Format
)) {
1550 return WINED3DERR_INVALIDCALL
;
1553 /* TODO: Store modes per adapter and read it from the adapter structure */
1554 if (Adapter
== 0 && !DEBUG_SINGLE_MODE
) { /* Display */
1560 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
1561 DevModeW
.dmSize
= sizeof(DevModeW
);
1563 /* If we are filtering to a specific format (D3D9), then need to skip
1564 all unrelated modes, but if mode is irrelevant (D3D8), then we can
1565 just count through the ones with valid bit depths */
1566 while ((i
<=Mode
) && EnumDisplaySettingsExW(NULL
, j
++, &DevModeW
, 0)) {
1569 case WINED3DFMT_UNKNOWN
:
1570 /* This is D3D8. Do not enumerate P8 here */
1571 if (DevModeW
.dmBitsPerPel
== 32 ||
1572 DevModeW
.dmBitsPerPel
== 16) i
++;
1574 case WINED3DFMT_X8R8G8B8
:
1575 if (DevModeW
.dmBitsPerPel
== 32) i
++;
1577 case WINED3DFMT_R5G6B5
:
1578 if (DevModeW
.dmBitsPerPel
== 16) i
++;
1581 if (DevModeW
.dmBitsPerPel
== 8) i
++;
1584 /* Modes that don't match what we support can get an early-out */
1585 TRACE_(d3d_caps
)("Searching for %s, returning D3DERR_INVALIDCALL\n", debug_d3dformat(Format
));
1586 return WINED3DERR_INVALIDCALL
;
1591 TRACE_(d3d_caps
)("No modes found for format (%x - %s)\n", Format
, debug_d3dformat(Format
));
1592 return WINED3DERR_INVALIDCALL
;
1596 /* Now get the display mode via the calculated index */
1597 if (EnumDisplaySettingsExW(NULL
, ModeIdx
, &DevModeW
, 0)) {
1598 pMode
->Width
= DevModeW
.dmPelsWidth
;
1599 pMode
->Height
= DevModeW
.dmPelsHeight
;
1600 pMode
->RefreshRate
= WINED3DADAPTER_DEFAULT
;
1601 if (DevModeW
.dmFields
& DM_DISPLAYFREQUENCY
)
1602 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
1604 if (Format
== WINED3DFMT_UNKNOWN
) {
1605 pMode
->Format
= pixelformat_for_depth(DevModeW
.dmBitsPerPel
);
1607 pMode
->Format
= Format
;
1610 TRACE_(d3d_caps
)("Requested mode out of range %d\n", Mode
);
1611 return WINED3DERR_INVALIDCALL
;
1614 TRACE_(d3d_caps
)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode
->Width
, pMode
->Height
,
1615 pMode
->RefreshRate
, pMode
->Format
, debug_d3dformat(pMode
->Format
),
1616 DevModeW
.dmBitsPerPel
);
1618 } else if (DEBUG_SINGLE_MODE
) {
1619 /* Return one setting of the format requested */
1620 if (Mode
> 0) return WINED3DERR_INVALIDCALL
;
1622 pMode
->Height
= 600;
1623 pMode
->RefreshRate
= 60;
1624 pMode
->Format
= (Format
== WINED3DFMT_UNKNOWN
) ? WINED3DFMT_X8R8G8B8
: Format
;
1626 FIXME_(d3d_caps
)("Adapter not primary display\n");
1632 static HRESULT WINAPI
IWineD3DImpl_GetAdapterDisplayMode(IWineD3D
*iface
, UINT Adapter
, WINED3DDISPLAYMODE
* pMode
) {
1633 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1634 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, pMode: %p)\n", This
, Adapter
, pMode
);
1636 if (NULL
== pMode
||
1637 Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1638 return WINED3DERR_INVALIDCALL
;
1641 if (Adapter
== 0) { /* Display */
1645 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
1646 DevModeW
.dmSize
= sizeof(DevModeW
);
1648 EnumDisplaySettingsExW(NULL
, ENUM_CURRENT_SETTINGS
, &DevModeW
, 0);
1649 pMode
->Width
= DevModeW
.dmPelsWidth
;
1650 pMode
->Height
= DevModeW
.dmPelsHeight
;
1651 bpp
= DevModeW
.dmBitsPerPel
;
1652 pMode
->RefreshRate
= WINED3DADAPTER_DEFAULT
;
1653 if (DevModeW
.dmFields
&DM_DISPLAYFREQUENCY
)
1655 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
1658 pMode
->Format
= pixelformat_for_depth(bpp
);
1660 FIXME_(d3d_caps
)("Adapter not primary display\n");
1663 TRACE_(d3d_caps
)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode
->Width
,
1664 pMode
->Height
, pMode
->RefreshRate
, debug_d3dformat(pMode
->Format
));
1668 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
1669 and fields being inserted in the middle, a new structure is used in place */
1670 static HRESULT WINAPI
IWineD3DImpl_GetAdapterIdentifier(IWineD3D
*iface
, UINT Adapter
, DWORD Flags
,
1671 WINED3DADAPTER_IDENTIFIER
* pIdentifier
) {
1672 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1674 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This
, Adapter
, Flags
, pIdentifier
);
1676 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1677 return WINED3DERR_INVALIDCALL
;
1680 /* Return the information requested */
1681 TRACE_(d3d_caps
)("device/Vendor Name and Version detection using FillGLCaps\n");
1682 strcpy(pIdentifier
->Driver
, This
->adapters
[Adapter
].driver
);
1683 strcpy(pIdentifier
->Description
, This
->adapters
[Adapter
].description
);
1685 /* Note dx8 doesn't supply a DeviceName */
1686 if (NULL
!= pIdentifier
->DeviceName
) strcpy(pIdentifier
->DeviceName
, "\\\\.\\DISPLAY"); /* FIXME: May depend on desktop? */
1687 pIdentifier
->DriverVersion
->u
.HighPart
= This
->adapters
[Adapter
].gl_info
.driver_version_hipart
;
1688 pIdentifier
->DriverVersion
->u
.LowPart
= This
->adapters
[Adapter
].gl_info
.driver_version
;
1689 *(pIdentifier
->VendorId
) = This
->adapters
[Adapter
].gl_info
.gl_vendor
;
1690 *(pIdentifier
->DeviceId
) = This
->adapters
[Adapter
].gl_info
.gl_card
;
1691 *(pIdentifier
->SubSysId
) = 0;
1692 *(pIdentifier
->Revision
) = 0;
1693 *pIdentifier
->DeviceIdentifier
= IID_D3DDEVICE_D3DUID
;
1695 if(wined3d_settings
.pci_device_id
!= PCI_DEVICE_NONE
)
1697 TRACE_(d3d_caps
)("Overriding pci device id with: %x\n", wined3d_settings
.pci_device_id
);
1698 *(pIdentifier
->DeviceId
) = wined3d_settings
.pci_device_id
;
1701 if(wined3d_settings
.pci_vendor_id
!= PCI_VENDOR_NONE
)
1703 TRACE_(d3d_caps
)("Overriding pci vendor id with: %x\n", wined3d_settings
.pci_vendor_id
);
1704 *(pIdentifier
->VendorId
) = wined3d_settings
.pci_vendor_id
;
1707 if (Flags
& WINED3DENUM_NO_WHQL_LEVEL
) {
1708 *(pIdentifier
->WHQLLevel
) = 0;
1710 *(pIdentifier
->WHQLLevel
) = 1;
1716 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const WineD3D_GL_Info
*gl_info
,
1717 const WineD3D_PixelFormat
*cfg
, const struct GlPixelFormatDesc
*format_desc
)
1719 short redSize
, greenSize
, blueSize
, alphaSize
, colorBits
;
1724 if(cfg
->iPixelType
== WGL_TYPE_RGBA_ARB
) { /* Integer RGBA formats */
1725 if (!getColorBits(format_desc
, &redSize
, &greenSize
, &blueSize
, &alphaSize
, &colorBits
))
1727 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc
->format
));
1731 if(cfg
->redSize
< redSize
)
1734 if(cfg
->greenSize
< greenSize
)
1737 if(cfg
->blueSize
< blueSize
)
1740 if(cfg
->alphaSize
< alphaSize
)
1744 } else if(cfg
->iPixelType
== WGL_TYPE_RGBA_FLOAT_ARB
) { /* Float RGBA formats; TODO: WGL_NV_float_buffer */
1745 if (format_desc
->format
== WINED3DFMT_R16_FLOAT
)
1746 return (cfg
->redSize
== 16 && cfg
->greenSize
== 0 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
1747 if (format_desc
->format
== WINED3DFMT_R16G16_FLOAT
)
1748 return (cfg
->redSize
== 16 && cfg
->greenSize
== 16 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
1749 if (format_desc
->format
== WINED3DFMT_R16G16B16A16_FLOAT
)
1750 return (cfg
->redSize
== 16 && cfg
->greenSize
== 16 && cfg
->blueSize
== 16 && cfg
->alphaSize
== 16);
1751 if (format_desc
->format
== WINED3DFMT_R32_FLOAT
)
1752 return (cfg
->redSize
== 32 && cfg
->greenSize
== 0 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
1753 if (format_desc
->format
== WINED3DFMT_R32G32_FLOAT
)
1754 return (cfg
->redSize
== 32 && cfg
->greenSize
== 32 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
1755 if (format_desc
->format
== WINED3DFMT_R32G32B32A32_FLOAT
)
1756 return (cfg
->redSize
== 32 && cfg
->greenSize
== 32 && cfg
->blueSize
== 32 && cfg
->alphaSize
== 32);
1758 /* Probably a color index mode */
1765 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const WineD3D_GL_Info
*gl_info
,
1766 const WineD3D_PixelFormat
*cfg
, const struct GlPixelFormatDesc
*format_desc
)
1768 short depthSize
, stencilSize
;
1769 BOOL lockable
= FALSE
;
1774 if (!getDepthStencilBits(format_desc
, &depthSize
, &stencilSize
))
1776 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc
->format
));
1780 if ((format_desc
->format
== WINED3DFMT_D16_LOCKABLE
) || (format_desc
->format
== WINED3DFMT_D32F_LOCKABLE
))
1783 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
1784 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
1785 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
1786 if(!(cfg
->depthSize
== depthSize
|| (!lockable
&& cfg
->depthSize
> depthSize
)))
1789 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
1790 * allow more stencil bits than requested. */
1791 if(cfg
->stencilSize
< stencilSize
)
1797 static HRESULT WINAPI
IWineD3DImpl_CheckDepthStencilMatch(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
1798 WINED3DFORMAT AdapterFormat
,
1799 WINED3DFORMAT RenderTargetFormat
,
1800 WINED3DFORMAT DepthStencilFormat
) {
1801 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1803 const WineD3D_PixelFormat
*cfgs
;
1804 const struct WineD3DAdapter
*adapter
;
1805 const struct GlPixelFormatDesc
*rt_format_desc
;
1806 const struct GlPixelFormatDesc
*ds_format_desc
;
1809 WARN_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
1811 DeviceType
, debug_d3ddevicetype(DeviceType
),
1812 AdapterFormat
, debug_d3dformat(AdapterFormat
),
1813 RenderTargetFormat
, debug_d3dformat(RenderTargetFormat
),
1814 DepthStencilFormat
, debug_d3dformat(DepthStencilFormat
));
1816 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1817 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This
, Adapter
, IWineD3D_GetAdapterCount(iface
));
1818 return WINED3DERR_INVALIDCALL
;
1821 adapter
= &This
->adapters
[Adapter
];
1822 rt_format_desc
= getFormatDescEntry(RenderTargetFormat
, &adapter
->gl_info
);
1823 ds_format_desc
= getFormatDescEntry(DepthStencilFormat
, &adapter
->gl_info
);
1824 cfgs
= adapter
->cfgs
;
1825 nCfgs
= adapter
->nCfgs
;
1826 for (it
= 0; it
< nCfgs
; ++it
) {
1827 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
, &cfgs
[it
], rt_format_desc
))
1829 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, &cfgs
[it
], ds_format_desc
))
1831 TRACE_(d3d_caps
)("(%p) : Formats matched\n", This
);
1836 WARN_(d3d_caps
)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat
), debug_d3dformat(DepthStencilFormat
));
1838 return WINED3DERR_NOTAVAILABLE
;
1841 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
1842 WINED3DFORMAT SurfaceFormat
,
1843 BOOL Windowed
, WINED3DMULTISAMPLE_TYPE MultiSampleType
, DWORD
* pQualityLevels
) {
1845 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1846 const struct GlPixelFormatDesc
*glDesc
;
1847 const struct WineD3DAdapter
*adapter
;
1849 TRACE_(d3d_caps
)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
1852 DeviceType
, debug_d3ddevicetype(DeviceType
),
1853 SurfaceFormat
, debug_d3dformat(SurfaceFormat
),
1858 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1859 return WINED3DERR_INVALIDCALL
;
1862 /* TODO: handle Windowed, add more quality levels */
1864 if (WINED3DMULTISAMPLE_NONE
== MultiSampleType
) return WINED3D_OK
;
1866 /* By default multisampling is disabled right now as it causes issues
1867 * on some Nvidia driver versions and it doesn't work well in combination
1869 if(!wined3d_settings
.allow_multisampling
)
1870 return WINED3DERR_NOTAVAILABLE
;
1872 adapter
= &This
->adapters
[Adapter
];
1873 glDesc
= getFormatDescEntry(SurfaceFormat
, &adapter
->gl_info
);
1874 if (!glDesc
) return WINED3DERR_INVALIDCALL
;
1876 if(glDesc
->Flags
& (WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
)) {
1878 const WineD3D_PixelFormat
*cfgs
;
1880 cfgs
= adapter
->cfgs
;
1881 nCfgs
= adapter
->nCfgs
;
1882 for(i
=0; i
<nCfgs
; i
++) {
1883 if(cfgs
[i
].numSamples
!= MultiSampleType
)
1886 if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, &cfgs
[i
], glDesc
))
1889 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs
[i
].iPixelFormat
, MultiSampleType
, debug_d3dformat(SurfaceFormat
));
1892 *pQualityLevels
= 1; /* Guess at a value! */
1896 else if(glDesc
->Flags
& WINED3DFMT_FLAG_RENDERTARGET
) {
1897 short redSize
, greenSize
, blueSize
, alphaSize
, colorBits
;
1899 const WineD3D_PixelFormat
*cfgs
;
1901 if (!getColorBits(glDesc
, &redSize
, &greenSize
, &blueSize
, &alphaSize
, &colorBits
))
1903 ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat
);
1904 return WINED3DERR_NOTAVAILABLE
;
1907 cfgs
= adapter
->cfgs
;
1908 nCfgs
= adapter
->nCfgs
;
1909 for(i
=0; i
<nCfgs
; i
++) {
1910 if(cfgs
[i
].numSamples
!= MultiSampleType
)
1912 if(cfgs
[i
].redSize
!= redSize
)
1914 if(cfgs
[i
].greenSize
!= greenSize
)
1916 if(cfgs
[i
].blueSize
!= blueSize
)
1918 if(cfgs
[i
].alphaSize
!= alphaSize
)
1921 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs
[i
].iPixelFormat
, MultiSampleType
, debug_d3dformat(SurfaceFormat
));
1924 *pQualityLevels
= 1; /* Guess at a value! */
1928 return WINED3DERR_NOTAVAILABLE
;
1931 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
1932 WINED3DFORMAT DisplayFormat
, WINED3DFORMAT BackBufferFormat
, BOOL Windowed
) {
1934 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
1935 HRESULT hr
= WINED3DERR_NOTAVAILABLE
;
1938 TRACE_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, CheckType:(%x,%s), DispFmt:(%x,%s), BackBuf:(%x,%s), Win?%d): stub\n",
1941 DeviceType
, debug_d3ddevicetype(DeviceType
),
1942 DisplayFormat
, debug_d3dformat(DisplayFormat
),
1943 BackBufferFormat
, debug_d3dformat(BackBufferFormat
),
1946 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
1947 WARN_(d3d_caps
)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
1948 return WINED3DERR_INVALIDCALL
;
1951 /* The task of this function is to check whether a certain display / backbuffer format
1952 * combination is available on the given adapter. In fullscreen mode microsoft specified
1953 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
1954 * and display format should match exactly.
1955 * In windowed mode format conversion can occur and this depends on the driver. When format
1956 * conversion is done, this function should nevertheless fail and applications need to use
1957 * CheckDeviceFormatConversion.
1958 * At the moment we assume that fullscreen and windowed have the same capabilities */
1960 /* There are only 4 display formats */
1961 if(!((DisplayFormat
== WINED3DFMT_R5G6B5
) ||
1962 (DisplayFormat
== WINED3DFMT_X1R5G5B5
) ||
1963 (DisplayFormat
== WINED3DFMT_X8R8G8B8
) ||
1964 (DisplayFormat
== WINED3DFMT_A2R10G10B10
)))
1966 TRACE_(d3d_caps
)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat
));
1967 return WINED3DERR_NOTAVAILABLE
;
1970 /* If the requested DisplayFormat is not available, don't continue */
1971 nmodes
= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, DisplayFormat
);
1973 TRACE_(d3d_caps
)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat
));
1974 return WINED3DERR_NOTAVAILABLE
;
1977 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
1978 if(!Windowed
&& BackBufferFormat
== WINED3DFMT_UNKNOWN
) {
1979 TRACE_(d3d_caps
)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
1980 return WINED3DERR_NOTAVAILABLE
;
1983 /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
1984 if( (DisplayFormat
== WINED3DFMT_R5G6B5
) && (BackBufferFormat
!= WINED3DFMT_R5G6B5
) ) {
1985 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1986 return WINED3DERR_NOTAVAILABLE
;
1989 /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
1990 if( (DisplayFormat
== WINED3DFMT_X1R5G5B5
) && !((BackBufferFormat
== WINED3DFMT_X1R5G5B5
) || (BackBufferFormat
== WINED3DFMT_A1R5G5B5
)) ) {
1991 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1992 return WINED3DERR_NOTAVAILABLE
;
1995 /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
1996 if( (DisplayFormat
== WINED3DFMT_X8R8G8B8
) && !((BackBufferFormat
== WINED3DFMT_X8R8G8B8
) || (BackBufferFormat
== WINED3DFMT_A8R8G8B8
)) ) {
1997 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
1998 return WINED3DERR_NOTAVAILABLE
;
2001 /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
2002 if( (DisplayFormat
== WINED3DFMT_A2R10G10B10
) && ((BackBufferFormat
!= WINED3DFMT_A2R10G10B10
) || Windowed
)) {
2003 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2004 return WINED3DERR_NOTAVAILABLE
;
2007 /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
2008 hr
= IWineD3DImpl_CheckDeviceFormat(iface
, Adapter
, DeviceType
, DisplayFormat
, WINED3DUSAGE_RENDERTARGET
, WINED3DRTYPE_SURFACE
, BackBufferFormat
, SURFACE_OPENGL
);
2010 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2016 /* Check if we support bumpmapping for a format */
2017 static BOOL
CheckBumpMapCapability(struct WineD3DAdapter
*adapter
,
2018 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2020 const struct fragment_pipeline
*fp
;
2022 switch(format_desc
->format
)
2024 case WINED3DFMT_R8G8_SNORM
:
2025 case WINED3DFMT_R16G16_SNORM
:
2026 case WINED3DFMT_L6V5U5
:
2027 case WINED3DFMT_X8L8V8U8
:
2028 case WINED3DFMT_R8G8B8A8_SNORM
:
2029 /* Ask the fixed function pipeline implementation if it can deal
2030 * with the conversion. If we've got a GL extension giving native
2031 * support this will be an identity conversion. */
2032 fp
= select_fragment_implementation(adapter
, DeviceType
);
2033 if (fp
->color_fixup_supported(format_desc
->color_fixup
))
2035 TRACE_(d3d_caps
)("[OK]\n");
2038 TRACE_(d3d_caps
)("[FAILED]\n");
2042 TRACE_(d3d_caps
)("[FAILED]\n");
2047 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
2048 static BOOL
CheckDepthStencilCapability(struct WineD3DAdapter
*adapter
,
2049 const struct GlPixelFormatDesc
*display_format_desc
, const struct GlPixelFormatDesc
*ds_format_desc
)
2053 /* Only allow depth/stencil formats */
2054 if (!(ds_format_desc
->Flags
& (WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
))) return FALSE
;
2056 /* Walk through all WGL pixel formats to find a match */
2057 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2059 WineD3D_PixelFormat
*cfg
= &adapter
->cfgs
[it
];
2060 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
, cfg
, display_format_desc
))
2062 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, cfg
, ds_format_desc
))
2072 static BOOL
CheckFilterCapability(struct WineD3DAdapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2074 /* The flags entry of a format contains the filtering capability */
2075 if (format_desc
->Flags
& WINED3DFMT_FLAG_FILTERING
) return TRUE
;
2080 /* Check the render target capabilities of a format */
2081 static BOOL
CheckRenderTargetCapability(struct WineD3DAdapter
*adapter
,
2082 const struct GlPixelFormatDesc
*adapter_format_desc
, const struct GlPixelFormatDesc
*check_format_desc
)
2084 /* Filter out non-RT formats */
2085 if (!(check_format_desc
->Flags
& WINED3DFMT_FLAG_RENDERTARGET
)) return FALSE
;
2087 if(wined3d_settings
.offscreen_rendering_mode
== ORM_BACKBUFFER
) {
2088 WineD3D_PixelFormat
*cfgs
= adapter
->cfgs
;
2090 short AdapterRed
, AdapterGreen
, AdapterBlue
, AdapterAlpha
, AdapterTotalSize
;
2091 short CheckRed
, CheckGreen
, CheckBlue
, CheckAlpha
, CheckTotalSize
;
2093 getColorBits(adapter_format_desc
, &AdapterRed
, &AdapterGreen
, &AdapterBlue
, &AdapterAlpha
, &AdapterTotalSize
);
2094 getColorBits(check_format_desc
, &CheckRed
, &CheckGreen
, &CheckBlue
, &CheckAlpha
, &CheckTotalSize
);
2096 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
2097 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
2098 if(!((AdapterRed
== CheckRed
) && (AdapterGreen
== CheckGreen
) && (AdapterBlue
== CheckBlue
))) {
2099 TRACE_(d3d_caps
)("[FAILED]\n");
2103 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
2104 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
2105 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2107 if (cfgs
[it
].windowDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
,
2108 &cfgs
[it
], check_format_desc
))
2110 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
2111 cfgs
[it
].iPixelFormat
, debug_d3dformat(check_format_desc
->format
));
2115 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_PBUFFER
) {
2116 /* We can probably use this function in FBO mode too on some drivers to get some basic indication of the capabilities. */
2117 WineD3D_PixelFormat
*cfgs
= adapter
->cfgs
;
2120 /* Check if there is a WGL pixel format matching the requirements, the pixel format should also be usable with pbuffers */
2121 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2123 if (cfgs
[it
].pbufferDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
,
2124 &cfgs
[it
], check_format_desc
))
2126 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
2127 cfgs
[it
].iPixelFormat
, debug_d3dformat(check_format_desc
->format
));
2131 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
){
2132 /* For now return TRUE for FBOs until we have some proper checks.
2133 * Note that this function will only be called when the format is around for texturing. */
2139 static BOOL
CheckSrgbReadCapability(struct WineD3DAdapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2141 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
2143 /* Check for supported sRGB formats (Texture loading and framebuffer) */
2144 if(!GL_SUPPORT(EXT_TEXTURE_SRGB
)) {
2145 TRACE_(d3d_caps
)("[FAILED] GL_EXT_texture_sRGB not supported\n");
2149 switch (format_desc
->format
)
2151 case WINED3DFMT_A8R8G8B8
:
2152 case WINED3DFMT_X8R8G8B8
:
2153 case WINED3DFMT_A4R4G4B4
:
2155 case WINED3DFMT_A8L8
:
2156 case WINED3DFMT_DXT1
:
2157 case WINED3DFMT_DXT2
:
2158 case WINED3DFMT_DXT3
:
2159 case WINED3DFMT_DXT4
:
2160 case WINED3DFMT_DXT5
:
2161 TRACE_(d3d_caps
)("[OK]\n");
2165 TRACE_(d3d_caps
)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(format_desc
->format
));
2171 static BOOL
CheckSrgbWriteCapability(struct WineD3DAdapter
*adapter
,
2172 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2174 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
2175 * doing the color fixup in shaders.
2176 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
2177 if ((format_desc
->format
== WINED3DFMT_X8R8G8B8
) || (format_desc
->format
== WINED3DFMT_A8R8G8B8
))
2179 int vs_selected_mode
;
2180 int ps_selected_mode
;
2181 select_shader_mode(&adapter
->gl_info
, DeviceType
, &ps_selected_mode
, &vs_selected_mode
);
2183 if((ps_selected_mode
== SHADER_ARB
) || (ps_selected_mode
== SHADER_GLSL
)) {
2184 TRACE_(d3d_caps
)("[OK]\n");
2189 TRACE_(d3d_caps
)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(format_desc
->format
));
2193 /* Check if a format support blending in combination with pixel shaders */
2194 static BOOL
CheckPostPixelShaderBlendingCapability(struct WineD3DAdapter
*adapter
,
2195 const struct GlPixelFormatDesc
*format_desc
)
2197 /* The flags entry of a format contains the post pixel shader blending capability */
2198 if (format_desc
->Flags
& WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
) return TRUE
;
2203 static BOOL
CheckWrapAndMipCapability(struct WineD3DAdapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2205 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
2206 * but we have to report mipmapping so we cannot reject this flag. Tests show that
2207 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
2208 * that wrapping is supported. The lack of filtering will sort out the mipmapping
2209 * capability anyway.
2211 * For now lets report this on all formats, but in the future we may want to
2212 * restrict it to some should games need that
2217 /* Check if a texture format is supported on the given adapter */
2218 static BOOL
CheckTextureCapability(struct WineD3DAdapter
*adapter
,
2219 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2221 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
2222 const shader_backend_t
*shader_backend
;
2223 const struct fragment_pipeline
*fp
;
2225 switch (format_desc
->format
)
2228 * supported: RGB(A) formats
2230 case WINED3DFMT_R8G8B8
: /* Enable for dx7, blacklisted for 8 and 9 above */
2231 case WINED3DFMT_A8R8G8B8
:
2232 case WINED3DFMT_X8R8G8B8
:
2233 case WINED3DFMT_R5G6B5
:
2234 case WINED3DFMT_X1R5G5B5
:
2235 case WINED3DFMT_A1R5G5B5
:
2236 case WINED3DFMT_A4R4G4B4
:
2237 case WINED3DFMT_A8_UNORM
:
2238 case WINED3DFMT_X4R4G4B4
:
2239 case WINED3DFMT_R8G8B8A8_UNORM
:
2240 case WINED3DFMT_X8B8G8R8
:
2241 case WINED3DFMT_A2R10G10B10
:
2242 case WINED3DFMT_R10G10B10A2_UNORM
:
2243 case WINED3DFMT_R16G16_UNORM
:
2244 TRACE_(d3d_caps
)("[OK]\n");
2247 case WINED3DFMT_R3G3B2
:
2248 TRACE_(d3d_caps
)("[FAILED] - Not supported on Windows\n");
2252 * supported: Palettized
2255 TRACE_(d3d_caps
)("[OK]\n");
2257 /* No Windows driver offers A8P8, so don't offer it either */
2258 case WINED3DFMT_A8P8
:
2262 * Supported: (Alpha)-Luminance
2265 case WINED3DFMT_A8L8
:
2266 case WINED3DFMT_L16
:
2267 TRACE_(d3d_caps
)("[OK]\n");
2270 /* Not supported on Windows, thus disabled */
2271 case WINED3DFMT_A4L4
:
2272 TRACE_(d3d_caps
)("[FAILED] - not supported on windows\n");
2276 * Supported: Depth/Stencil formats
2278 case WINED3DFMT_D16_LOCKABLE
:
2279 case WINED3DFMT_D16_UNORM
:
2280 case WINED3DFMT_D15S1
:
2281 case WINED3DFMT_D24X8
:
2282 case WINED3DFMT_D24X4S4
:
2283 case WINED3DFMT_D24S8
:
2284 case WINED3DFMT_D24FS8
:
2285 case WINED3DFMT_D32
:
2286 case WINED3DFMT_D32F_LOCKABLE
:
2290 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
2291 * GL_NV_texture_shader). Emulated by shaders
2293 case WINED3DFMT_R8G8_SNORM
:
2294 case WINED3DFMT_X8L8V8U8
:
2295 case WINED3DFMT_L6V5U5
:
2296 case WINED3DFMT_R8G8B8A8_SNORM
:
2297 case WINED3DFMT_R16G16_SNORM
:
2298 /* Ask the shader backend if it can deal with the conversion. If
2299 * we've got a GL extension giving native support this will be an
2300 * identity conversion. */
2301 shader_backend
= select_shader_backend(adapter
, DeviceType
);
2302 if (shader_backend
->shader_color_fixup_supported(format_desc
->color_fixup
))
2304 TRACE_(d3d_caps
)("[OK]\n");
2307 TRACE_(d3d_caps
)("[FAILED]\n");
2310 case WINED3DFMT_DXT1
:
2311 case WINED3DFMT_DXT2
:
2312 case WINED3DFMT_DXT3
:
2313 case WINED3DFMT_DXT4
:
2314 case WINED3DFMT_DXT5
:
2315 if (GL_SUPPORT(EXT_TEXTURE_COMPRESSION_S3TC
)) {
2316 TRACE_(d3d_caps
)("[OK]\n");
2319 TRACE_(d3d_caps
)("[FAILED]\n");
2324 * Odd formats - not supported
2326 case WINED3DFMT_VERTEXDATA
:
2327 case WINED3DFMT_R16_UINT
:
2328 case WINED3DFMT_R32_UINT
:
2329 case WINED3DFMT_R16G16B16A16_SNORM
:
2330 case WINED3DFMT_A2W10V10U10
:
2331 case WINED3DFMT_W11V11U10
:
2332 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2336 * WINED3DFMT_CxV8U8: Not supported right now
2338 case WINED3DFMT_CxV8U8
:
2339 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2343 case WINED3DFMT_UYVY
:
2344 case WINED3DFMT_YUY2
:
2345 if(GL_SUPPORT(APPLE_YCBCR_422
)) {
2346 TRACE_(d3d_caps
)("[OK]\n");
2349 TRACE_(d3d_caps
)("[FAILED]\n");
2351 case WINED3DFMT_YV12
:
2352 TRACE_(d3d_caps
)("[FAILED]\n");
2356 case WINED3DFMT_R16G16B16A16_UNORM
:
2357 case WINED3DFMT_A8R3G3B2
:
2358 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
2361 /* Floating point formats */
2362 case WINED3DFMT_R16_FLOAT
:
2363 case WINED3DFMT_R16G16B16A16_FLOAT
:
2364 if(GL_SUPPORT(ARB_TEXTURE_FLOAT
) && GL_SUPPORT(ARB_HALF_FLOAT_PIXEL
)) {
2365 TRACE_(d3d_caps
)("[OK]\n");
2368 TRACE_(d3d_caps
)("[FAILED]\n");
2371 case WINED3DFMT_R32_FLOAT
:
2372 case WINED3DFMT_R32G32B32A32_FLOAT
:
2373 if (GL_SUPPORT(ARB_TEXTURE_FLOAT
)) {
2374 TRACE_(d3d_caps
)("[OK]\n");
2377 TRACE_(d3d_caps
)("[FAILED]\n");
2380 case WINED3DFMT_R16G16_FLOAT
:
2381 case WINED3DFMT_R32G32_FLOAT
:
2382 if(GL_SUPPORT(ARB_TEXTURE_RG
)) {
2383 TRACE_(d3d_caps
)("[OK]\n");
2386 TRACE_(d3d_caps
)("[FAILED]\n");
2389 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
2390 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
2391 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
2392 * We can do instancing with all shader versions, but we need vertex shaders.
2394 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
2395 * to enable instancing. WineD3D doesn't need that and just ignores it.
2397 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
2399 case WINEMAKEFOURCC('I','N','S','T'):
2400 TRACE("ATI Instancing check hack\n");
2401 if(GL_SUPPORT(ARB_VERTEX_PROGRAM
) || GL_SUPPORT(ARB_VERTEX_SHADER
)) {
2402 TRACE_(d3d_caps
)("[OK]\n");
2405 TRACE_(d3d_caps
)("[FAILED]\n");
2408 /* Some weird FOURCC formats */
2409 case WINED3DFMT_R8G8_B8G8
:
2410 case WINED3DFMT_G8R8_G8B8
:
2411 case WINED3DFMT_MULTI2_ARGB8
:
2412 TRACE_(d3d_caps
)("[FAILED]\n");
2415 /* Vendor specific formats */
2416 case WINED3DFMT_ATI2N
:
2417 if(GL_SUPPORT(ATI_TEXTURE_COMPRESSION_3DC
) || GL_SUPPORT(EXT_TEXTURE_COMPRESSION_RGTC
)) {
2418 shader_backend
= select_shader_backend(adapter
, DeviceType
);
2419 fp
= select_fragment_implementation(adapter
, DeviceType
);
2420 if (shader_backend
->shader_color_fixup_supported(format_desc
->color_fixup
)
2421 && fp
->color_fixup_supported(format_desc
->color_fixup
))
2423 TRACE_(d3d_caps
)("[OK]\n");
2427 TRACE_(d3d_caps
)("[OK]\n");
2430 TRACE_(d3d_caps
)("[FAILED]\n");
2433 case WINED3DFMT_NVHU
:
2434 case WINED3DFMT_NVHS
:
2435 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
2436 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
2437 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
2438 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
2439 * Applications have to deal with not having NVHS and NVHU.
2441 TRACE_(d3d_caps
)("[FAILED]\n");
2444 case WINED3DFMT_UNKNOWN
:
2448 ERR("Unhandled format=%s\n", debug_d3dformat(format_desc
->format
));
2454 static BOOL
CheckSurfaceCapability(struct WineD3DAdapter
*adapter
, const struct GlPixelFormatDesc
*adapter_format_desc
,
2455 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*check_format_desc
, WINED3DSURFTYPE SurfaceType
)
2457 const struct blit_shader
*blitter
;
2459 if(SurfaceType
== SURFACE_GDI
) {
2460 switch(check_format_desc
->format
)
2462 case WINED3DFMT_R8G8B8
:
2463 case WINED3DFMT_A8R8G8B8
:
2464 case WINED3DFMT_X8R8G8B8
:
2465 case WINED3DFMT_R5G6B5
:
2466 case WINED3DFMT_X1R5G5B5
:
2467 case WINED3DFMT_A1R5G5B5
:
2468 case WINED3DFMT_A4R4G4B4
:
2469 case WINED3DFMT_R3G3B2
:
2470 case WINED3DFMT_A8_UNORM
:
2471 case WINED3DFMT_A8R3G3B2
:
2472 case WINED3DFMT_X4R4G4B4
:
2473 case WINED3DFMT_R10G10B10A2_UNORM
:
2474 case WINED3DFMT_R8G8B8A8_UNORM
:
2475 case WINED3DFMT_X8B8G8R8
:
2476 case WINED3DFMT_R16G16_UNORM
:
2477 case WINED3DFMT_A2R10G10B10
:
2478 case WINED3DFMT_R16G16B16A16_UNORM
:
2480 TRACE_(d3d_caps
)("[OK]\n");
2483 TRACE_(d3d_caps
)("[FAILED] - not available on GDI surfaces\n");
2488 /* All format that are supported for textures are supported for surfaces as well */
2489 if (CheckTextureCapability(adapter
, DeviceType
, check_format_desc
)) return TRUE
;
2490 /* All depth stencil formats are supported on surfaces */
2491 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, check_format_desc
)) return TRUE
;
2493 /* If opengl can't process the format natively, the blitter may be able to convert it */
2494 blitter
= select_blit_implementation(adapter
, DeviceType
);
2495 if (blitter
->color_fixup_supported(check_format_desc
->color_fixup
))
2497 TRACE_(d3d_caps
)("[OK]\n");
2501 /* Reject other formats */
2502 TRACE_(d3d_caps
)("[FAILED]\n");
2506 static BOOL
CheckVertexTextureCapability(struct WineD3DAdapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2508 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
2510 if (!GL_LIMITS(vertex_samplers
)) {
2511 TRACE_(d3d_caps
)("[FAILED]\n");
2515 switch (format_desc
->format
)
2517 case WINED3DFMT_R32G32B32A32_FLOAT
:
2518 if (!GL_SUPPORT(ARB_TEXTURE_FLOAT
)) {
2519 TRACE_(d3d_caps
)("[FAILED]\n");
2522 TRACE_(d3d_caps
)("[OK]\n");
2526 TRACE_(d3d_caps
)("[FAILED]\n");
2532 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2533 WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
,
2534 WINED3DSURFTYPE SurfaceType
) {
2535 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2536 struct WineD3DAdapter
*adapter
= &This
->adapters
[Adapter
];
2537 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
2538 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(CheckFormat
, gl_info
);
2539 const struct GlPixelFormatDesc
*adapter_format_desc
= getFormatDescEntry(AdapterFormat
, gl_info
);
2540 DWORD UsageCaps
= 0;
2542 TRACE_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
2545 DeviceType
, debug_d3ddevicetype(DeviceType
),
2546 AdapterFormat
, debug_d3dformat(AdapterFormat
),
2547 Usage
, debug_d3dusage(Usage
), debug_d3dusagequery(Usage
),
2548 RType
, debug_d3dresourcetype(RType
),
2549 CheckFormat
, debug_d3dformat(CheckFormat
));
2551 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2552 return WINED3DERR_INVALIDCALL
;
2555 if(RType
== WINED3DRTYPE_CUBETEXTURE
) {
2557 if(SurfaceType
!= SURFACE_OPENGL
) {
2558 TRACE("[FAILED]\n");
2559 return WINED3DERR_NOTAVAILABLE
;
2562 /* Cubetexture allows:
2563 * - D3DUSAGE_AUTOGENMIPMAP
2564 * - D3DUSAGE_DEPTHSTENCIL
2565 * - D3DUSAGE_DYNAMIC
2566 * - D3DUSAGE_NONSECURE (d3d9ex)
2567 * - D3DUSAGE_RENDERTARGET
2568 * - D3DUSAGE_SOFTWAREPROCESSING
2569 * - D3DUSAGE_QUERY_WRAPANDMIP
2571 if(GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
2572 /* Check if the texture format is around */
2573 if (CheckTextureCapability(adapter
, DeviceType
, format_desc
))
2575 if(Usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
2576 /* Check for automatic mipmap generation support */
2577 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP
)) {
2578 UsageCaps
|= WINED3DUSAGE_AUTOGENMIPMAP
;
2580 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2581 TRACE_(d3d_caps
)("[FAILED] - No autogenmipmap support, but continuing\n");
2585 /* Always report dynamic locking */
2586 if(Usage
& WINED3DUSAGE_DYNAMIC
)
2587 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
2589 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
2590 if(CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
2592 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
2594 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
2595 return WINED3DERR_NOTAVAILABLE
;
2599 /* Always report software processing */
2600 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
2601 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
2603 /* Check QUERY_FILTER support */
2604 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
2605 if (CheckFilterCapability(adapter
, format_desc
))
2607 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
2609 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
2610 return WINED3DERR_NOTAVAILABLE
;
2614 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2615 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
2616 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
2618 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
2620 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
2621 return WINED3DERR_NOTAVAILABLE
;
2625 /* Check QUERY_SRGBREAD support */
2626 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
2627 if (CheckSrgbReadCapability(adapter
, format_desc
))
2629 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
2631 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
2632 return WINED3DERR_NOTAVAILABLE
;
2636 /* Check QUERY_SRGBWRITE support */
2637 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
2638 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
2640 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
2642 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
2643 return WINED3DERR_NOTAVAILABLE
;
2647 /* Check QUERY_VERTEXTEXTURE support */
2648 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
2649 if (CheckVertexTextureCapability(adapter
, format_desc
))
2651 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
2653 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
2654 return WINED3DERR_NOTAVAILABLE
;
2658 /* Check QUERY_WRAPANDMIP support */
2659 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
2660 if (CheckWrapAndMipCapability(adapter
, format_desc
))
2662 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
2664 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
2665 return WINED3DERR_NOTAVAILABLE
;
2669 TRACE_(d3d_caps
)("[FAILED] - Cube texture format not supported\n");
2670 return WINED3DERR_NOTAVAILABLE
;
2673 TRACE_(d3d_caps
)("[FAILED] - No cube texture support\n");
2674 return WINED3DERR_NOTAVAILABLE
;
2676 } else if(RType
== WINED3DRTYPE_SURFACE
) {
2678 * - D3DUSAGE_DEPTHSTENCIL
2679 * - D3DUSAGE_NONSECURE (d3d9ex)
2680 * - D3DUSAGE_RENDERTARGET
2683 if (CheckSurfaceCapability(adapter
, adapter_format_desc
, DeviceType
, format_desc
, SurfaceType
))
2685 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
2686 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, format_desc
))
2688 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
2690 TRACE_(d3d_caps
)("[FAILED] - No depthstencil support\n");
2691 return WINED3DERR_NOTAVAILABLE
;
2695 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
2696 if (CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
2698 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
2700 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
2701 return WINED3DERR_NOTAVAILABLE
;
2705 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2706 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
2707 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
2709 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
2711 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
2712 return WINED3DERR_NOTAVAILABLE
;
2716 TRACE_(d3d_caps
)("[FAILED] - Not supported for plain surfaces\n");
2717 return WINED3DERR_NOTAVAILABLE
;
2720 } else if(RType
== WINED3DRTYPE_TEXTURE
) {
2722 * - D3DUSAGE_AUTOGENMIPMAP
2723 * - D3DUSAGE_DEPTHSTENCIL
2725 * - D3DUSAGE_DYNAMIC
2726 * - D3DUSAGE_NONSECURE (d3d9ex)
2727 * - D3DUSAGE_RENDERTARGET
2728 * - D3DUSAGE_SOFTWAREPROCESSING
2729 * - D3DUSAGE_TEXTAPI (d3d9ex)
2730 * - D3DUSAGE_QUERY_WRAPANDMIP
2733 if(SurfaceType
!= SURFACE_OPENGL
) {
2734 TRACE("[FAILED]\n");
2735 return WINED3DERR_NOTAVAILABLE
;
2738 /* Check if the texture format is around */
2739 if (CheckTextureCapability(adapter
, DeviceType
, format_desc
))
2741 if(Usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
2742 /* Check for automatic mipmap generation support */
2743 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP
)) {
2744 UsageCaps
|= WINED3DUSAGE_AUTOGENMIPMAP
;
2746 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
2747 TRACE_(d3d_caps
)("[FAILED] - No autogenmipmap support, but continuing\n");
2751 /* Always report dynamic locking */
2752 if(Usage
& WINED3DUSAGE_DYNAMIC
)
2753 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
2755 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
2756 if (CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
2758 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
2760 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
2761 return WINED3DERR_NOTAVAILABLE
;
2765 /* Always report software processing */
2766 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
2767 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
2769 /* Check QUERY_FILTER support */
2770 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
2771 if (CheckFilterCapability(adapter
, format_desc
))
2773 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
2775 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
2776 return WINED3DERR_NOTAVAILABLE
;
2780 /* Check QUERY_LEGACYBUMPMAP support */
2781 if(Usage
& WINED3DUSAGE_QUERY_LEGACYBUMPMAP
) {
2782 if (CheckBumpMapCapability(adapter
, DeviceType
, format_desc
))
2784 UsageCaps
|= WINED3DUSAGE_QUERY_LEGACYBUMPMAP
;
2786 TRACE_(d3d_caps
)("[FAILED] - No legacy bumpmap support\n");
2787 return WINED3DERR_NOTAVAILABLE
;
2791 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2792 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
2793 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
2795 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
2797 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
2798 return WINED3DERR_NOTAVAILABLE
;
2802 /* Check QUERY_SRGBREAD support */
2803 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
2804 if (CheckSrgbReadCapability(adapter
, format_desc
))
2806 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
2808 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
2809 return WINED3DERR_NOTAVAILABLE
;
2813 /* Check QUERY_SRGBWRITE support */
2814 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
2815 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
2817 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
2819 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
2820 return WINED3DERR_NOTAVAILABLE
;
2824 /* Check QUERY_VERTEXTEXTURE support */
2825 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
2826 if (CheckVertexTextureCapability(adapter
, format_desc
))
2828 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
2830 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
2831 return WINED3DERR_NOTAVAILABLE
;
2835 /* Check QUERY_WRAPANDMIP support */
2836 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
2837 if (CheckWrapAndMipCapability(adapter
, format_desc
))
2839 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
2841 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
2842 return WINED3DERR_NOTAVAILABLE
;
2846 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
2847 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, format_desc
))
2849 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
2851 TRACE_(d3d_caps
)("[FAILED] - No depth stencil support\n");
2852 return WINED3DERR_NOTAVAILABLE
;
2856 TRACE_(d3d_caps
)("[FAILED] - Texture format not supported\n");
2857 return WINED3DERR_NOTAVAILABLE
;
2859 } else if((RType
== WINED3DRTYPE_VOLUME
) || (RType
== WINED3DRTYPE_VOLUMETEXTURE
)) {
2860 /* Volume is to VolumeTexture what Surface is to Texture but its usage caps are not documented.
2861 * Most driver seem to offer (nearly) the same on Volume and VolumeTexture, so do that too.
2863 * Volumetexture allows:
2864 * - D3DUSAGE_DYNAMIC
2865 * - D3DUSAGE_NONSECURE (d3d9ex)
2866 * - D3DUSAGE_SOFTWAREPROCESSING
2867 * - D3DUSAGE_QUERY_WRAPANDMIP
2870 if(SurfaceType
!= SURFACE_OPENGL
) {
2871 TRACE("[FAILED]\n");
2872 return WINED3DERR_NOTAVAILABLE
;
2875 /* Check volume texture and volume usage caps */
2876 if(GL_SUPPORT(EXT_TEXTURE3D
)) {
2877 if (!CheckTextureCapability(adapter
, DeviceType
, format_desc
))
2879 TRACE_(d3d_caps
)("[FAILED] - Format not supported\n");
2880 return WINED3DERR_NOTAVAILABLE
;
2883 /* Always report dynamic locking */
2884 if(Usage
& WINED3DUSAGE_DYNAMIC
)
2885 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
2887 /* Always report software processing */
2888 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
2889 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
2891 /* Check QUERY_FILTER support */
2892 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
2893 if (CheckFilterCapability(adapter
, format_desc
))
2895 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
2897 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
2898 return WINED3DERR_NOTAVAILABLE
;
2902 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
2903 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
2904 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
2906 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
2908 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
2909 return WINED3DERR_NOTAVAILABLE
;
2913 /* Check QUERY_SRGBREAD support */
2914 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
2915 if (CheckSrgbReadCapability(adapter
, format_desc
))
2917 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
2919 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
2920 return WINED3DERR_NOTAVAILABLE
;
2924 /* Check QUERY_SRGBWRITE support */
2925 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
2926 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
2928 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
2930 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
2931 return WINED3DERR_NOTAVAILABLE
;
2935 /* Check QUERY_VERTEXTEXTURE support */
2936 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
2937 if (CheckVertexTextureCapability(adapter
, format_desc
))
2939 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
2941 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
2942 return WINED3DERR_NOTAVAILABLE
;
2946 /* Check QUERY_WRAPANDMIP support */
2947 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
2948 if (CheckWrapAndMipCapability(adapter
, format_desc
))
2950 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
2952 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
2953 return WINED3DERR_NOTAVAILABLE
;
2957 TRACE_(d3d_caps
)("[FAILED] - No volume texture support\n");
2958 return WINED3DERR_NOTAVAILABLE
;
2961 /* Filter formats that need conversion; For one part, this conversion is unimplemented,
2962 * and volume textures are huge, so it would be a big performance hit. Unless we hit an
2963 * app needing one of those formats, don't advertize them to avoid leading apps into
2964 * temptation. The windows drivers don't support most of those formats on volumes anyway,
2967 switch(CheckFormat
) {
2969 case WINED3DFMT_A4L4
:
2970 case WINED3DFMT_R32_FLOAT
:
2971 case WINED3DFMT_R16_FLOAT
:
2972 case WINED3DFMT_X8L8V8U8
:
2973 case WINED3DFMT_L6V5U5
:
2974 case WINED3DFMT_R16G16_UNORM
:
2975 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
2976 return WINED3DERR_NOTAVAILABLE
;
2978 case WINED3DFMT_R8G8B8A8_SNORM
:
2979 case WINED3DFMT_R16G16_SNORM
:
2980 if(!GL_SUPPORT(NV_TEXTURE_SHADER
)) {
2981 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
2982 return WINED3DERR_NOTAVAILABLE
;
2986 case WINED3DFMT_R8G8_SNORM
:
2987 if(!GL_SUPPORT(NV_TEXTURE_SHADER
)) {
2988 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
2989 return WINED3DERR_NOTAVAILABLE
;
2993 case WINED3DFMT_DXT1
:
2994 case WINED3DFMT_DXT2
:
2995 case WINED3DFMT_DXT3
:
2996 case WINED3DFMT_DXT4
:
2997 case WINED3DFMT_DXT5
:
2998 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
2999 * compressed texture results in an error. While the D3D refrast does
3000 * support s3tc volumes, at least the nvidia windows driver does not, so
3001 * we're free not to support this format.
3003 TRACE_(d3d_caps
)("[FAILED] - DXTn does not support 3D textures\n");
3004 return WINED3DERR_NOTAVAILABLE
;
3007 /* Do nothing, continue with checking the format below */
3010 } else if((RType
== WINED3DRTYPE_INDEXBUFFER
) || (RType
== WINED3DRTYPE_VERTEXBUFFER
)){
3011 /* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
3012 TRACE_(d3d_caps
)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
3013 return WINED3DERR_NOTAVAILABLE
;
3016 /* This format is nothing special and it is supported perfectly.
3017 * However, ati and nvidia driver on windows do not mark this format as
3018 * supported (tested with the dxCapsViewer) and pretending to
3019 * support this format uncovers a bug in Battlefield 1942 (fonts are missing)
3020 * So do the same as Windows drivers and pretend not to support it on dx8 and 9
3021 * Enable it on dx7. It will need additional checking on dx10 when we support it.
3023 if(This
->dxVersion
> 7 && CheckFormat
== WINED3DFMT_R8G8B8
) {
3024 TRACE_(d3d_caps
)("[FAILED]\n");
3025 return WINED3DERR_NOTAVAILABLE
;
3028 /* When the UsageCaps exactly matches Usage return WINED3D_OK except for the situation in which
3029 * WINED3DUSAGE_AUTOGENMIPMAP isn't around, then WINED3DOK_NOAUTOGEN is returned if all the other
3030 * usage flags match. */
3031 if(UsageCaps
== Usage
) {
3033 } else if((UsageCaps
== (Usage
& ~WINED3DUSAGE_AUTOGENMIPMAP
)) && (Usage
& WINED3DUSAGE_AUTOGENMIPMAP
)){
3034 return WINED3DOK_NOAUTOGEN
;
3036 TRACE_(d3d_caps
)("[FAILED] - Usage=%#08x requested for CheckFormat=%s and RType=%d but only %#08x is available\n", Usage
, debug_d3dformat(CheckFormat
), RType
, UsageCaps
);
3037 return WINED3DERR_NOTAVAILABLE
;
3041 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
3042 WINED3DFORMAT SourceFormat
, WINED3DFORMAT TargetFormat
) {
3043 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3045 FIXME_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), SrcFmt:(%u,%s), TgtFmt:(%u,%s))\n",
3048 DeviceType
, debug_d3ddevicetype(DeviceType
),
3049 SourceFormat
, debug_d3dformat(SourceFormat
),
3050 TargetFormat
, debug_d3dformat(TargetFormat
));
3054 static const shader_backend_t
*select_shader_backend(struct WineD3DAdapter
*adapter
, WINED3DDEVTYPE DeviceType
)
3056 const shader_backend_t
*ret
;
3057 int vs_selected_mode
;
3058 int ps_selected_mode
;
3060 select_shader_mode(&adapter
->gl_info
, DeviceType
, &ps_selected_mode
, &vs_selected_mode
);
3061 if (vs_selected_mode
== SHADER_GLSL
|| ps_selected_mode
== SHADER_GLSL
) {
3062 ret
= &glsl_shader_backend
;
3063 } else if (vs_selected_mode
== SHADER_ARB
|| ps_selected_mode
== SHADER_ARB
) {
3064 ret
= &arb_program_shader_backend
;
3066 ret
= &none_shader_backend
;
3071 static const struct fragment_pipeline
*select_fragment_implementation(struct WineD3DAdapter
*adapter
,
3072 WINED3DDEVTYPE DeviceType
)
3074 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
3075 int vs_selected_mode
;
3076 int ps_selected_mode
;
3078 select_shader_mode(&adapter
->gl_info
, DeviceType
, &ps_selected_mode
, &vs_selected_mode
);
3079 if((ps_selected_mode
== SHADER_ARB
|| ps_selected_mode
== SHADER_GLSL
) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) {
3080 return &arbfp_fragment_pipeline
;
3081 } else if(ps_selected_mode
== SHADER_ATI
) {
3082 return &atifs_fragment_pipeline
;
3083 } else if(GL_SUPPORT(NV_REGISTER_COMBINERS
) && GL_SUPPORT(NV_TEXTURE_SHADER2
)) {
3084 return &nvts_fragment_pipeline
;
3085 } else if(GL_SUPPORT(NV_REGISTER_COMBINERS
)) {
3086 return &nvrc_fragment_pipeline
;
3088 return &ffp_fragment_pipeline
;
3092 static const struct blit_shader
*select_blit_implementation(struct WineD3DAdapter
*adapter
, WINED3DDEVTYPE DeviceType
)
3094 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
3095 int vs_selected_mode
;
3096 int ps_selected_mode
;
3098 select_shader_mode(&adapter
->gl_info
, DeviceType
, &ps_selected_mode
, &vs_selected_mode
);
3099 if((ps_selected_mode
== SHADER_ARB
|| ps_selected_mode
== SHADER_GLSL
) && GL_SUPPORT(ARB_FRAGMENT_PROGRAM
)) {
3106 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
3107 subset of a D3DCAPS9 structure. However, it has to come via a void *
3108 as the d3d8 interface cannot import the d3d9 header */
3109 static HRESULT WINAPI
IWineD3DImpl_GetDeviceCaps(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DCAPS
* pCaps
) {
3111 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3112 struct WineD3DAdapter
*adapter
= &This
->adapters
[Adapter
];
3113 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
3114 int vs_selected_mode
;
3115 int ps_selected_mode
;
3116 struct shader_caps shader_caps
;
3117 struct fragment_caps fragment_caps
;
3118 const shader_backend_t
*shader_backend
;
3119 const struct fragment_pipeline
*frag_pipeline
= NULL
;
3120 DWORD ckey_caps
, blit_caps
, fx_caps
;
3122 TRACE_(d3d_caps
)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This
, Adapter
, DeviceType
, pCaps
);
3124 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
3125 return WINED3DERR_INVALIDCALL
;
3128 select_shader_mode(&adapter
->gl_info
, DeviceType
, &ps_selected_mode
, &vs_selected_mode
);
3130 /* This function should *not* be modifying GL caps
3131 * TODO: move the functionality where it belongs */
3132 select_shader_max_constants(ps_selected_mode
, vs_selected_mode
, &adapter
->gl_info
);
3134 /* ------------------------------------------------
3135 The following fields apply to both d3d8 and d3d9
3136 ------------------------------------------------ */
3137 pCaps
->DeviceType
= (DeviceType
== WINED3DDEVTYPE_HAL
) ? WINED3DDEVTYPE_HAL
: WINED3DDEVTYPE_REF
; /* Not quite true, but use h/w supported by opengl I suppose */
3138 pCaps
->AdapterOrdinal
= Adapter
;
3141 pCaps
->Caps2
= WINED3DCAPS2_CANRENDERWINDOWED
|
3142 WINED3DCAPS2_FULLSCREENGAMMA
|
3143 WINED3DCAPS2_DYNAMICTEXTURES
;
3144 if(GL_SUPPORT(SGIS_GENERATE_MIPMAP
)) {
3145 pCaps
->Caps2
|= WINED3DCAPS2_CANAUTOGENMIPMAP
;
3148 pCaps
->Caps3
= WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD
|
3149 WINED3DCAPS3_COPY_TO_VIDMEM
|
3150 WINED3DCAPS3_COPY_TO_SYSTEMMEM
;
3152 pCaps
->PresentationIntervals
= WINED3DPRESENT_INTERVAL_IMMEDIATE
|
3153 WINED3DPRESENT_INTERVAL_ONE
;
3155 pCaps
->CursorCaps
= WINED3DCURSORCAPS_COLOR
|
3156 WINED3DCURSORCAPS_LOWRES
;
3158 pCaps
->DevCaps
= WINED3DDEVCAPS_FLOATTLVERTEX
|
3159 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY
|
3160 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY
|
3161 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY
|
3162 WINED3DDEVCAPS_DRAWPRIMTLVERTEX
|
3163 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT
|
3164 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY
|
3165 WINED3DDEVCAPS_PUREDEVICE
|
3166 WINED3DDEVCAPS_HWRASTERIZATION
|
3167 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY
|
3168 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY
|
3169 WINED3DDEVCAPS_CANRENDERAFTERFLIP
|
3170 WINED3DDEVCAPS_DRAWPRIMITIVES2
|
3171 WINED3DDEVCAPS_DRAWPRIMITIVES2EX
|
3172 WINED3DDEVCAPS_RTPATCHES
;
3174 pCaps
->PrimitiveMiscCaps
= WINED3DPMISCCAPS_CULLNONE
|
3175 WINED3DPMISCCAPS_CULLCCW
|
3176 WINED3DPMISCCAPS_CULLCW
|
3177 WINED3DPMISCCAPS_COLORWRITEENABLE
|
3178 WINED3DPMISCCAPS_CLIPTLVERTS
|
3179 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS
|
3180 WINED3DPMISCCAPS_MASKZ
|
3181 WINED3DPMISCCAPS_BLENDOP
|
3182 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING
;
3184 WINED3DPMISCCAPS_NULLREFERENCE
3185 WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
3186 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
3187 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
3188 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
3190 if(GL_SUPPORT(EXT_BLEND_EQUATION_SEPARATE
) && GL_SUPPORT(EXT_BLEND_FUNC_SEPARATE
))
3191 pCaps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_SEPARATEALPHABLEND
;
3193 pCaps
->RasterCaps
= WINED3DPRASTERCAPS_DITHER
|
3194 WINED3DPRASTERCAPS_PAT
|
3195 WINED3DPRASTERCAPS_WFOG
|
3196 WINED3DPRASTERCAPS_ZFOG
|
3197 WINED3DPRASTERCAPS_FOGVERTEX
|
3198 WINED3DPRASTERCAPS_FOGTABLE
|
3199 WINED3DPRASTERCAPS_STIPPLE
|
3200 WINED3DPRASTERCAPS_SUBPIXEL
|
3201 WINED3DPRASTERCAPS_ZTEST
|
3202 WINED3DPRASTERCAPS_SCISSORTEST
|
3203 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS
|
3204 WINED3DPRASTERCAPS_DEPTHBIAS
;
3206 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
)) {
3207 pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_ANISOTROPY
|
3208 WINED3DPRASTERCAPS_ZBIAS
|
3209 WINED3DPRASTERCAPS_MIPMAPLODBIAS
;
3211 if(GL_SUPPORT(NV_FOG_DISTANCE
)) {
3212 pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_FOGRANGE
;
3215 WINED3DPRASTERCAPS_COLORPERSPECTIVE
3216 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
3217 WINED3DPRASTERCAPS_ANTIALIASEDGES
3218 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
3219 WINED3DPRASTERCAPS_WBUFFER */
3221 pCaps
->ZCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
3222 WINED3DPCMPCAPS_EQUAL
|
3223 WINED3DPCMPCAPS_GREATER
|
3224 WINED3DPCMPCAPS_GREATEREQUAL
|
3225 WINED3DPCMPCAPS_LESS
|
3226 WINED3DPCMPCAPS_LESSEQUAL
|
3227 WINED3DPCMPCAPS_NEVER
|
3228 WINED3DPCMPCAPS_NOTEQUAL
;
3230 pCaps
->SrcBlendCaps
= WINED3DPBLENDCAPS_BOTHINVSRCALPHA
|
3231 WINED3DPBLENDCAPS_BOTHSRCALPHA
|
3232 WINED3DPBLENDCAPS_DESTALPHA
|
3233 WINED3DPBLENDCAPS_DESTCOLOR
|
3234 WINED3DPBLENDCAPS_INVDESTALPHA
|
3235 WINED3DPBLENDCAPS_INVDESTCOLOR
|
3236 WINED3DPBLENDCAPS_INVSRCALPHA
|
3237 WINED3DPBLENDCAPS_INVSRCCOLOR
|
3238 WINED3DPBLENDCAPS_ONE
|
3239 WINED3DPBLENDCAPS_SRCALPHA
|
3240 WINED3DPBLENDCAPS_SRCALPHASAT
|
3241 WINED3DPBLENDCAPS_SRCCOLOR
|
3242 WINED3DPBLENDCAPS_ZERO
;
3244 pCaps
->DestBlendCaps
= WINED3DPBLENDCAPS_DESTALPHA
|
3245 WINED3DPBLENDCAPS_DESTCOLOR
|
3246 WINED3DPBLENDCAPS_INVDESTALPHA
|
3247 WINED3DPBLENDCAPS_INVDESTCOLOR
|
3248 WINED3DPBLENDCAPS_INVSRCALPHA
|
3249 WINED3DPBLENDCAPS_INVSRCCOLOR
|
3250 WINED3DPBLENDCAPS_ONE
|
3251 WINED3DPBLENDCAPS_SRCALPHA
|
3252 WINED3DPBLENDCAPS_SRCCOLOR
|
3253 WINED3DPBLENDCAPS_ZERO
;
3254 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
3255 * according to the glBlendFunc manpage
3257 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
3258 * legacy settings for srcblend only
3261 if( GL_SUPPORT(EXT_BLEND_COLOR
)) {
3262 pCaps
->SrcBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
3263 pCaps
->DestBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
3267 pCaps
->AlphaCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
3268 WINED3DPCMPCAPS_EQUAL
|
3269 WINED3DPCMPCAPS_GREATER
|
3270 WINED3DPCMPCAPS_GREATEREQUAL
|
3271 WINED3DPCMPCAPS_LESS
|
3272 WINED3DPCMPCAPS_LESSEQUAL
|
3273 WINED3DPCMPCAPS_NEVER
|
3274 WINED3DPCMPCAPS_NOTEQUAL
;
3276 pCaps
->ShadeCaps
= WINED3DPSHADECAPS_SPECULARGOURAUDRGB
|
3277 WINED3DPSHADECAPS_COLORGOURAUDRGB
|
3278 WINED3DPSHADECAPS_ALPHAFLATBLEND
|
3279 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND
|
3280 WINED3DPSHADECAPS_COLORFLATRGB
|
3281 WINED3DPSHADECAPS_FOGFLAT
|
3282 WINED3DPSHADECAPS_FOGGOURAUD
|
3283 WINED3DPSHADECAPS_SPECULARFLATRGB
;
3285 pCaps
->TextureCaps
= WINED3DPTEXTURECAPS_ALPHA
|
3286 WINED3DPTEXTURECAPS_ALPHAPALETTE
|
3287 WINED3DPTEXTURECAPS_TRANSPARENCY
|
3288 WINED3DPTEXTURECAPS_BORDER
|
3289 WINED3DPTEXTURECAPS_MIPMAP
|
3290 WINED3DPTEXTURECAPS_PROJECTED
|
3291 WINED3DPTEXTURECAPS_PERSPECTIVE
;
3293 if( !GL_SUPPORT(ARB_TEXTURE_NON_POWER_OF_TWO
)) {
3294 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_POW2
|
3295 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL
;
3298 if( GL_SUPPORT(EXT_TEXTURE3D
)) {
3299 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_VOLUMEMAP
|
3300 WINED3DPTEXTURECAPS_MIPVOLUMEMAP
|
3301 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2
;
3304 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
3305 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_CUBEMAP
|
3306 WINED3DPTEXTURECAPS_MIPCUBEMAP
|
3307 WINED3DPTEXTURECAPS_CUBEMAP_POW2
;
3311 pCaps
->TextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
3312 WINED3DPTFILTERCAPS_MAGFPOINT
|
3313 WINED3DPTFILTERCAPS_MINFLINEAR
|
3314 WINED3DPTFILTERCAPS_MINFPOINT
|
3315 WINED3DPTFILTERCAPS_MIPFLINEAR
|
3316 WINED3DPTFILTERCAPS_MIPFPOINT
|
3317 WINED3DPTFILTERCAPS_LINEAR
|
3318 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
3319 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
3320 WINED3DPTFILTERCAPS_MIPLINEAR
|
3321 WINED3DPTFILTERCAPS_MIPNEAREST
|
3322 WINED3DPTFILTERCAPS_NEAREST
;
3324 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
)) {
3325 pCaps
->TextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
3326 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
3329 if (GL_SUPPORT(ARB_TEXTURE_CUBE_MAP
)) {
3330 pCaps
->CubeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
3331 WINED3DPTFILTERCAPS_MAGFPOINT
|
3332 WINED3DPTFILTERCAPS_MINFLINEAR
|
3333 WINED3DPTFILTERCAPS_MINFPOINT
|
3334 WINED3DPTFILTERCAPS_MIPFLINEAR
|
3335 WINED3DPTFILTERCAPS_MIPFPOINT
|
3336 WINED3DPTFILTERCAPS_LINEAR
|
3337 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
3338 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
3339 WINED3DPTFILTERCAPS_MIPLINEAR
|
3340 WINED3DPTFILTERCAPS_MIPNEAREST
|
3341 WINED3DPTFILTERCAPS_NEAREST
;
3343 if (GL_SUPPORT(EXT_TEXTURE_FILTER_ANISOTROPIC
)) {
3344 pCaps
->CubeTextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
3345 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
3348 pCaps
->CubeTextureFilterCaps
= 0;
3350 if (GL_SUPPORT(EXT_TEXTURE3D
)) {
3351 pCaps
->VolumeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
3352 WINED3DPTFILTERCAPS_MAGFPOINT
|
3353 WINED3DPTFILTERCAPS_MINFLINEAR
|
3354 WINED3DPTFILTERCAPS_MINFPOINT
|
3355 WINED3DPTFILTERCAPS_MIPFLINEAR
|
3356 WINED3DPTFILTERCAPS_MIPFPOINT
|
3357 WINED3DPTFILTERCAPS_LINEAR
|
3358 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
3359 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
3360 WINED3DPTFILTERCAPS_MIPLINEAR
|
3361 WINED3DPTFILTERCAPS_MIPNEAREST
|
3362 WINED3DPTFILTERCAPS_NEAREST
;
3364 pCaps
->VolumeTextureFilterCaps
= 0;
3366 pCaps
->TextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
3367 WINED3DPTADDRESSCAPS_CLAMP
|
3368 WINED3DPTADDRESSCAPS_WRAP
;
3370 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP
)) {
3371 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
3373 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT
)) {
3374 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
3376 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE
)) {
3377 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
3380 if (GL_SUPPORT(EXT_TEXTURE3D
)) {
3381 pCaps
->VolumeTextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
3382 WINED3DPTADDRESSCAPS_CLAMP
|
3383 WINED3DPTADDRESSCAPS_WRAP
;
3384 if (GL_SUPPORT(ARB_TEXTURE_BORDER_CLAMP
)) {
3385 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
3387 if (GL_SUPPORT(ARB_TEXTURE_MIRRORED_REPEAT
)) {
3388 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
3390 if (GL_SUPPORT(ATI_TEXTURE_MIRROR_ONCE
)) {
3391 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
3394 pCaps
->VolumeTextureAddressCaps
= 0;
3396 pCaps
->LineCaps
= WINED3DLINECAPS_TEXTURE
|
3397 WINED3DLINECAPS_ZTEST
|
3398 WINED3DLINECAPS_BLEND
|
3399 WINED3DLINECAPS_ALPHACMP
|
3400 WINED3DLINECAPS_FOG
;
3401 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
3402 * idea how generating the smoothing alpha values works; the result is different
3405 pCaps
->MaxTextureWidth
= GL_LIMITS(texture_size
);
3406 pCaps
->MaxTextureHeight
= GL_LIMITS(texture_size
);
3408 if(GL_SUPPORT(EXT_TEXTURE3D
))
3409 pCaps
->MaxVolumeExtent
= GL_LIMITS(texture3d_size
);
3411 pCaps
->MaxVolumeExtent
= 0;
3413 pCaps
->MaxTextureRepeat
= 32768;
3414 pCaps
->MaxTextureAspectRatio
= GL_LIMITS(texture_size
);
3415 pCaps
->MaxVertexW
= 1.0;
3417 pCaps
->GuardBandLeft
= 0;
3418 pCaps
->GuardBandTop
= 0;
3419 pCaps
->GuardBandRight
= 0;
3420 pCaps
->GuardBandBottom
= 0;
3422 pCaps
->ExtentsAdjust
= 0;
3424 pCaps
->StencilCaps
= WINED3DSTENCILCAPS_DECRSAT
|
3425 WINED3DSTENCILCAPS_INCRSAT
|
3426 WINED3DSTENCILCAPS_INVERT
|
3427 WINED3DSTENCILCAPS_KEEP
|
3428 WINED3DSTENCILCAPS_REPLACE
|
3429 WINED3DSTENCILCAPS_ZERO
;
3430 if (GL_SUPPORT(EXT_STENCIL_WRAP
)) {
3431 pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_DECR
|
3432 WINED3DSTENCILCAPS_INCR
;
3434 if ( This
->dxVersion
> 8 &&
3435 ( GL_SUPPORT(EXT_STENCIL_TWO_SIDE
) ||
3436 GL_SUPPORT(ATI_SEPARATE_STENCIL
) ) ) {
3437 pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_TWOSIDED
;
3440 pCaps
->FVFCaps
= WINED3DFVFCAPS_PSIZE
| 0x0008; /* 8 texture coords */
3442 pCaps
->MaxUserClipPlanes
= GL_LIMITS(clipplanes
);
3443 pCaps
->MaxActiveLights
= GL_LIMITS(lights
);
3445 pCaps
->MaxVertexBlendMatrices
= GL_LIMITS(blends
);
3446 pCaps
->MaxVertexBlendMatrixIndex
= 0;
3448 pCaps
->MaxAnisotropy
= GL_LIMITS(anisotropy
);
3449 pCaps
->MaxPointSize
= GL_LIMITS(pointsize
);
3452 pCaps
->VertexProcessingCaps
= WINED3DVTXPCAPS_DIRECTIONALLIGHTS
|
3453 WINED3DVTXPCAPS_MATERIALSOURCE7
|
3454 WINED3DVTXPCAPS_POSITIONALLIGHTS
|
3455 WINED3DVTXPCAPS_LOCALVIEWER
|
3456 WINED3DVTXPCAPS_VERTEXFOG
|
3457 WINED3DVTXPCAPS_TEXGEN
;
3459 D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
3461 pCaps
->MaxPrimitiveCount
= 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
3462 pCaps
->MaxVertexIndex
= 0xFFFFF;
3463 pCaps
->MaxStreams
= MAX_STREAMS
;
3464 pCaps
->MaxStreamStride
= 1024;
3466 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
3467 pCaps
->DevCaps2
= WINED3DDEVCAPS2_STREAMOFFSET
|
3468 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET
;
3469 pCaps
->MaxNpatchTessellationLevel
= 0;
3470 pCaps
->MasterAdapterOrdinal
= 0;
3471 pCaps
->AdapterOrdinalInGroup
= 0;
3472 pCaps
->NumberOfAdaptersInGroup
= 1;
3474 pCaps
->NumSimultaneousRTs
= GL_LIMITS(buffers
);
3476 pCaps
->StretchRectFilterCaps
= WINED3DPTFILTERCAPS_MINFPOINT
|
3477 WINED3DPTFILTERCAPS_MAGFPOINT
|
3478 WINED3DPTFILTERCAPS_MINFLINEAR
|
3479 WINED3DPTFILTERCAPS_MAGFLINEAR
;
3480 pCaps
->VertexTextureFilterCaps
= 0;
3482 memset(&shader_caps
, 0, sizeof(shader_caps
));
3483 shader_backend
= select_shader_backend(adapter
, DeviceType
);
3484 shader_backend
->shader_get_caps(DeviceType
, &adapter
->gl_info
, &shader_caps
);
3486 memset(&fragment_caps
, 0, sizeof(fragment_caps
));
3487 frag_pipeline
= select_fragment_implementation(adapter
, DeviceType
);
3488 frag_pipeline
->get_caps(DeviceType
, &adapter
->gl_info
, &fragment_caps
);
3490 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
3491 pCaps
->PrimitiveMiscCaps
|= fragment_caps
.PrimitiveMiscCaps
;
3493 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
3494 * Ignore shader model capabilities if disabled in config
3496 if(vs_selected_mode
== SHADER_NONE
) {
3497 TRACE_(d3d_caps
)("Vertex shader disabled in config, reporting version 0.0\n");
3498 pCaps
->VertexShaderVersion
= WINED3DVS_VERSION(0,0);
3499 pCaps
->MaxVertexShaderConst
= 0;
3501 pCaps
->VertexShaderVersion
= shader_caps
.VertexShaderVersion
;
3502 pCaps
->MaxVertexShaderConst
= shader_caps
.MaxVertexShaderConst
;
3505 if(ps_selected_mode
== SHADER_NONE
) {
3506 TRACE_(d3d_caps
)("Pixel shader disabled in config, reporting version 0.0\n");
3507 pCaps
->PixelShaderVersion
= WINED3DPS_VERSION(0,0);
3508 pCaps
->PixelShader1xMaxValue
= 0.0;
3510 pCaps
->PixelShaderVersion
= shader_caps
.PixelShaderVersion
;
3511 pCaps
->PixelShader1xMaxValue
= shader_caps
.PixelShader1xMaxValue
;
3514 pCaps
->TextureOpCaps
= fragment_caps
.TextureOpCaps
;
3515 pCaps
->MaxTextureBlendStages
= fragment_caps
.MaxTextureBlendStages
;
3516 pCaps
->MaxSimultaneousTextures
= fragment_caps
.MaxSimultaneousTextures
;
3518 pCaps
->VS20Caps
= shader_caps
.VS20Caps
;
3519 pCaps
->MaxVShaderInstructionsExecuted
= shader_caps
.MaxVShaderInstructionsExecuted
;
3520 pCaps
->MaxVertexShader30InstructionSlots
= shader_caps
.MaxVertexShader30InstructionSlots
;
3521 pCaps
->PS20Caps
= shader_caps
.PS20Caps
;
3522 pCaps
->MaxPShaderInstructionsExecuted
= shader_caps
.MaxPShaderInstructionsExecuted
;
3523 pCaps
->MaxPixelShader30InstructionSlots
= shader_caps
.MaxPixelShader30InstructionSlots
;
3525 /* The following caps are shader specific, but they are things we cannot detect, or which
3526 * are the same among all shader models. So to avoid code duplication set the shader version
3527 * specific, but otherwise constant caps here
3529 if(pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(3,0)) {
3530 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3531 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
3532 pCaps
->VS20Caps
.Caps
= WINED3DVS20CAPS_PREDICATION
;
3533 pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3534 pCaps
->VS20Caps
.NumTemps
= max(32, adapter
->gl_info
.vs_arb_max_temps
);
3535 pCaps
->VS20Caps
.StaticFlowControlDepth
= WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH
; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
3537 pCaps
->MaxVShaderInstructionsExecuted
= 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
3538 pCaps
->MaxVertexShader30InstructionSlots
= max(512, adapter
->gl_info
.vs_arb_max_instructions
);
3539 } else if(pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(2,0)) {
3540 pCaps
->VS20Caps
.Caps
= 0;
3541 pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH
;
3542 pCaps
->VS20Caps
.NumTemps
= max(12, adapter
->gl_info
.vs_arb_max_temps
);
3543 pCaps
->VS20Caps
.StaticFlowControlDepth
= 1;
3545 pCaps
->MaxVShaderInstructionsExecuted
= 65535;
3546 pCaps
->MaxVertexShader30InstructionSlots
= 0;
3547 } else { /* VS 1.x */
3548 pCaps
->VS20Caps
.Caps
= 0;
3549 pCaps
->VS20Caps
.DynamicFlowControlDepth
= 0;
3550 pCaps
->VS20Caps
.NumTemps
= 0;
3551 pCaps
->VS20Caps
.StaticFlowControlDepth
= 0;
3553 pCaps
->MaxVShaderInstructionsExecuted
= 0;
3554 pCaps
->MaxVertexShader30InstructionSlots
= 0;
3557 if(pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(3,0)) {
3558 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
3559 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
3561 /* 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 */
3562 pCaps
->PS20Caps
.Caps
= WINED3DPS20CAPS_ARBITRARYSWIZZLE
|
3563 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS
|
3564 WINED3DPS20CAPS_PREDICATION
|
3565 WINED3DPS20CAPS_NODEPENDENTREADLIMIT
|
3566 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
;
3567 pCaps
->PS20Caps
.DynamicFlowControlDepth
= WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
3568 pCaps
->PS20Caps
.NumTemps
= max(32, adapter
->gl_info
.ps_arb_max_temps
);
3569 pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
3570 pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS
; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
3572 pCaps
->MaxPShaderInstructionsExecuted
= 65535;
3573 pCaps
->MaxPixelShader30InstructionSlots
= max(WINED3DMIN30SHADERINSTRUCTIONS
, adapter
->gl_info
.ps_arb_max_instructions
);
3574 } else if(pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(2,0)) {
3575 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
3576 pCaps
->PS20Caps
.Caps
= 0;
3577 pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
3578 pCaps
->PS20Caps
.NumTemps
= max(12, adapter
->gl_info
.ps_arb_max_temps
);
3579 pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH
; /* Minimum: 1 */
3580 pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS
; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
3582 pCaps
->MaxPShaderInstructionsExecuted
= 512; /* Minimum value, a GeforceFX uses 1024 */
3583 pCaps
->MaxPixelShader30InstructionSlots
= 0;
3584 } else { /* PS 1.x */
3585 pCaps
->PS20Caps
.Caps
= 0;
3586 pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0;
3587 pCaps
->PS20Caps
.NumTemps
= 0;
3588 pCaps
->PS20Caps
.StaticFlowControlDepth
= 0;
3589 pCaps
->PS20Caps
.NumInstructionSlots
= 0;
3591 pCaps
->MaxPShaderInstructionsExecuted
= 0;
3592 pCaps
->MaxPixelShader30InstructionSlots
= 0;
3595 if(pCaps
->VertexShaderVersion
>= WINED3DVS_VERSION(2,0)) {
3596 /* OpenGL supports all the formats below, perhaps not always
3597 * without conversion, but it supports them.
3598 * Further GLSL doesn't seem to have an official unsigned type so
3599 * don't advertise it yet as I'm not sure how we handle it.
3600 * We might need to add some clamping in the shader engine to
3602 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
3603 pCaps
->DeclTypes
= WINED3DDTCAPS_UBYTE4
|
3604 WINED3DDTCAPS_UBYTE4N
|
3605 WINED3DDTCAPS_SHORT2N
|
3606 WINED3DDTCAPS_SHORT4N
;
3607 if (GL_SUPPORT(NV_HALF_FLOAT
)) {
3608 pCaps
->DeclTypes
|= WINED3DDTCAPS_FLOAT16_2
|
3609 WINED3DDTCAPS_FLOAT16_4
;
3612 pCaps
->DeclTypes
= 0;
3614 /* Set DirectDraw helper Caps */
3615 ckey_caps
= WINEDDCKEYCAPS_DESTBLT
|
3616 WINEDDCKEYCAPS_SRCBLT
;
3617 fx_caps
= WINEDDFXCAPS_BLTALPHA
|
3618 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT
|
3619 WINEDDFXCAPS_BLTMIRRORUPDOWN
|
3620 WINEDDFXCAPS_BLTROTATION90
|
3621 WINEDDFXCAPS_BLTSHRINKX
|
3622 WINEDDFXCAPS_BLTSHRINKXN
|
3623 WINEDDFXCAPS_BLTSHRINKY
|
3624 WINEDDFXCAPS_BLTSHRINKXN
|
3625 WINEDDFXCAPS_BLTSTRETCHX
|
3626 WINEDDFXCAPS_BLTSTRETCHXN
|
3627 WINEDDFXCAPS_BLTSTRETCHY
|
3628 WINEDDFXCAPS_BLTSTRETCHYN
;
3629 blit_caps
= WINEDDCAPS_BLT
|
3630 WINEDDCAPS_BLTCOLORFILL
|
3631 WINEDDCAPS_BLTDEPTHFILL
|
3632 WINEDDCAPS_BLTSTRETCH
|
3633 WINEDDCAPS_CANBLTSYSMEM
|
3634 WINEDDCAPS_CANCLIP
|
3635 WINEDDCAPS_CANCLIPSTRETCHED
|
3636 WINEDDCAPS_COLORKEY
|
3637 WINEDDCAPS_COLORKEYHWASSIST
|
3638 WINEDDCAPS_ALIGNBOUNDARYSRC
;
3640 /* Fill the ddraw caps structure */
3641 pCaps
->DirectDrawCaps
.Caps
= WINEDDCAPS_GDI
|
3642 WINEDDCAPS_PALETTE
|
3644 pCaps
->DirectDrawCaps
.Caps2
= WINEDDCAPS2_CERTIFIED
|
3645 WINEDDCAPS2_NOPAGELOCKREQUIRED
|
3646 WINEDDCAPS2_PRIMARYGAMMA
|
3647 WINEDDCAPS2_WIDESURFACES
|
3648 WINEDDCAPS2_CANRENDERWINDOWED
;
3649 pCaps
->DirectDrawCaps
.SVBCaps
= blit_caps
;
3650 pCaps
->DirectDrawCaps
.SVBCKeyCaps
= ckey_caps
;
3651 pCaps
->DirectDrawCaps
.SVBFXCaps
= fx_caps
;
3652 pCaps
->DirectDrawCaps
.VSBCaps
= blit_caps
;
3653 pCaps
->DirectDrawCaps
.VSBCKeyCaps
= ckey_caps
;
3654 pCaps
->DirectDrawCaps
.VSBFXCaps
= fx_caps
;
3655 pCaps
->DirectDrawCaps
.SSBCaps
= blit_caps
;
3656 pCaps
->DirectDrawCaps
.SSBCKeyCaps
= ckey_caps
;
3657 pCaps
->DirectDrawCaps
.SSBFXCaps
= fx_caps
;
3659 pCaps
->DirectDrawCaps
.ddsCaps
= WINEDDSCAPS_ALPHA
|
3660 WINEDDSCAPS_BACKBUFFER
|
3662 WINEDDSCAPS_FRONTBUFFER
|
3663 WINEDDSCAPS_OFFSCREENPLAIN
|
3664 WINEDDSCAPS_PALETTE
|
3665 WINEDDSCAPS_PRIMARYSURFACE
|
3666 WINEDDSCAPS_SYSTEMMEMORY
|
3667 WINEDDSCAPS_VIDEOMEMORY
|
3668 WINEDDSCAPS_VISIBLE
;
3669 pCaps
->DirectDrawCaps
.StrideAlign
= DDRAW_PITCH_ALIGNMENT
;
3671 /* Set D3D caps if OpenGL is available. */
3672 if (adapter
->opengl
)
3674 pCaps
->DirectDrawCaps
.ddsCaps
|=WINEDDSCAPS_3DDEVICE
|
3675 WINEDDSCAPS_MIPMAP
|
3676 WINEDDSCAPS_TEXTURE
|
3677 WINEDDSCAPS_ZBUFFER
;
3678 pCaps
->DirectDrawCaps
.Caps
|= WINEDDCAPS_3D
;
3684 /* Note due to structure differences between dx8 and dx9 D3DPRESENT_PARAMETERS,
3685 and fields being inserted in the middle, a new structure is used in place */
3686 static HRESULT WINAPI
IWineD3DImpl_CreateDevice(IWineD3D
*iface
, UINT Adapter
,
3687 WINED3DDEVTYPE DeviceType
, HWND hFocusWindow
, DWORD BehaviourFlags
, IUnknown
*parent
,
3688 IWineD3DDeviceParent
*device_parent
, IWineD3DDevice
**ppReturnedDeviceInterface
)
3690 IWineD3DDeviceImpl
*object
= NULL
;
3691 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3692 struct WineD3DAdapter
*adapter
= &This
->adapters
[Adapter
];
3693 WINED3DDISPLAYMODE mode
;
3694 const struct fragment_pipeline
*frag_pipeline
= NULL
;
3696 struct fragment_caps ffp_caps
;
3699 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
3700 * number and create a device without a 3D adapter for 2D only operation.
3702 if (IWineD3D_GetAdapterCount(iface
) && Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
3703 return WINED3DERR_INVALIDCALL
;
3706 /* Create a WineD3DDevice object */
3707 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(IWineD3DDeviceImpl
));
3708 *ppReturnedDeviceInterface
= (IWineD3DDevice
*)object
;
3709 TRACE("Created WineD3DDevice object @ %p\n", object
);
3710 if (NULL
== object
) {
3711 return WINED3DERR_OUTOFVIDEOMEMORY
;
3714 /* Set up initial COM information */
3715 object
->lpVtbl
= &IWineD3DDevice_Vtbl
;
3717 object
->wineD3D
= iface
;
3718 object
->adapter
= This
->adapter_count
? adapter
: NULL
;
3719 IWineD3D_AddRef(object
->wineD3D
);
3720 object
->parent
= parent
;
3721 object
->device_parent
= device_parent
;
3722 list_init(&object
->resources
);
3723 list_init(&object
->shaders
);
3725 if(This
->dxVersion
== 7) {
3726 object
->surface_alignment
= DDRAW_PITCH_ALIGNMENT
;
3728 object
->surface_alignment
= D3D8_PITCH_ALIGNMENT
;
3730 object
->posFixup
[0] = 1.0; /* This is needed to get the x coord unmodified through a MAD */
3732 /* Set the state up as invalid until the device is fully created */
3733 object
->state
= WINED3DERR_DRIVERINTERNALERROR
;
3735 TRACE("(%p)->(Adptr:%d, DevType: %x, FocusHwnd: %p, BehFlags: %x, RetDevInt: %p)\n", This
, Adapter
, DeviceType
,
3736 hFocusWindow
, BehaviourFlags
, ppReturnedDeviceInterface
);
3738 /* Save the creation parameters */
3739 object
->createParms
.AdapterOrdinal
= Adapter
;
3740 object
->createParms
.DeviceType
= DeviceType
;
3741 object
->createParms
.hFocusWindow
= hFocusWindow
;
3742 object
->createParms
.BehaviorFlags
= BehaviourFlags
;
3744 /* Initialize other useful values */
3745 object
->adapterNo
= Adapter
;
3746 object
->devType
= DeviceType
;
3748 select_shader_mode(&adapter
->gl_info
, DeviceType
,
3749 &object
->ps_selected_mode
, &object
->vs_selected_mode
);
3750 object
->shader_backend
= select_shader_backend(adapter
, DeviceType
);
3752 memset(&ffp_caps
, 0, sizeof(ffp_caps
));
3753 frag_pipeline
= select_fragment_implementation(adapter
, DeviceType
);
3754 object
->frag_pipe
= frag_pipeline
;
3755 frag_pipeline
->get_caps(DeviceType
, &adapter
->gl_info
, &ffp_caps
);
3756 object
->max_ffp_textures
= ffp_caps
.MaxSimultaneousTextures
;
3757 object
->max_ffp_texture_stages
= ffp_caps
.MaxTextureBlendStages
;
3758 hr
= compile_state_table(object
->StateTable
, object
->multistate_funcs
, &adapter
->gl_info
,
3759 ffp_vertexstate_template
, frag_pipeline
, misc_state_template
);
3762 IWineD3D_Release(object
->wineD3D
);
3763 HeapFree(GetProcessHeap(), 0, object
);
3768 object
->blitter
= select_blit_implementation(adapter
, DeviceType
);
3770 /* set the state of the device to valid */
3771 object
->state
= WINED3D_OK
;
3773 /* Get the initial screen setup for ddraw */
3774 IWineD3DImpl_GetAdapterDisplayMode(iface
, Adapter
, &mode
);
3776 object
->ddraw_width
= mode
.Width
;
3777 object
->ddraw_height
= mode
.Height
;
3778 object
->ddraw_format
= mode
.Format
;
3780 for(i
= 0; i
< PATCHMAP_SIZE
; i
++) {
3781 list_init(&object
->patches
[i
]);
3784 IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent
, *ppReturnedDeviceInterface
);
3789 static HRESULT WINAPI
IWineD3DImpl_GetParent(IWineD3D
*iface
, IUnknown
**pParent
) {
3790 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3791 IUnknown_AddRef(This
->parent
);
3792 *pParent
= This
->parent
;
3796 ULONG WINAPI
D3DCB_DefaultDestroySurface(IWineD3DSurface
*pSurface
) {
3797 IUnknown
* surfaceParent
;
3798 TRACE("(%p) call back\n", pSurface
);
3800 /* Now, release the parent, which will take care of cleaning up the surface for us */
3801 IWineD3DSurface_GetParent(pSurface
, &surfaceParent
);
3802 IUnknown_Release(surfaceParent
);
3803 return IUnknown_Release(surfaceParent
);
3806 ULONG WINAPI
D3DCB_DefaultDestroyVolume(IWineD3DVolume
*pVolume
) {
3807 IUnknown
* volumeParent
;
3808 TRACE("(%p) call back\n", pVolume
);
3810 /* Now, release the parent, which will take care of cleaning up the volume for us */
3811 IWineD3DVolume_GetParent(pVolume
, &volumeParent
);
3812 IUnknown_Release(volumeParent
);
3813 return IUnknown_Release(volumeParent
);
3816 static BOOL
implementation_is_apple(const WineD3D_GL_Info
*gl_info
)
3818 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
3819 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
3820 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
3822 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
3823 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
3824 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
3825 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
3826 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
3827 * the chance that other implementations support them is rather small since Win32 QuickTime uses
3828 * DirectDraw, not OpenGL.
3830 if(gl_info
->supported
[APPLE_FENCE
] &&
3831 gl_info
->supported
[APPLE_CLIENT_STORAGE
] &&
3832 gl_info
->supported
[APPLE_FLUSH_RENDER
] &&
3833 gl_info
->supported
[APPLE_YCBCR_422
]) {
3834 TRACE_(d3d_caps
)("GL_APPLE_fence, GL_APPLE_client_storage, GL_APPLE_flush_render and GL_ycbcr_422 are supported\n");
3835 TRACE_(d3d_caps
)("Activating MacOS fixups\n");
3838 TRACE_(d3d_caps
)("Apple extensions are not supported\n");
3839 TRACE_(d3d_caps
)("Not activating MacOS fixups\n");
3844 static void test_pbo_functionality(WineD3D_GL_Info
*gl_info
) {
3845 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
3846 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
3847 * all the texture. This function detects this bug by its symptom and disables PBOs
3848 * if the test fails.
3850 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
3851 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
3852 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
3853 * read back is compared to the original. If they are equal PBOs are assumed to work,
3854 * otherwise the PBO extension is disabled.
3856 GLuint texture
, pbo
;
3857 static const unsigned int pattern
[] = {
3858 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
3859 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
3860 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
3861 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
3863 unsigned int check
[sizeof(pattern
) / sizeof(pattern
[0])];
3865 if(!gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
]) {
3866 /* No PBO -> No point in testing them */
3870 while(glGetError());
3871 glGenTextures(1, &texture
);
3872 glBindTexture(GL_TEXTURE_2D
, texture
);
3873 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA8
, 4, 4, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, 0);
3874 checkGLcall("Specifying the PBO test texture\n");
3876 GL_EXTCALL(glGenBuffersARB(1, &pbo
));
3877 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, pbo
));
3878 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, sizeof(pattern
), pattern
, GL_STREAM_DRAW_ARB
));
3879 checkGLcall("Specifying the PBO test pbo\n");
3881 glTexSubImage2D(GL_TEXTURE_2D
, 0, 0, 0, 4, 4, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, NULL
);
3882 checkGLcall("Loading the PBO test texture\n");
3884 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
3885 glFinish(); /* just to be sure */
3887 memset(check
, 0, sizeof(check
));
3888 glGetTexImage(GL_TEXTURE_2D
, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, check
);
3889 checkGLcall("Reading back the PBO test texture\n");
3891 glDeleteTextures(1, &texture
);
3892 GL_EXTCALL(glDeleteBuffersARB(1, &pbo
));
3893 checkGLcall("PBO test cleanup\n");
3895 if(memcmp(check
, pattern
, sizeof(check
)) != 0) {
3896 WARN_(d3d_caps
)("PBO test failed, read back data doesn't match original\n");
3897 WARN_(d3d_caps
)("Disabling PBOs. This may result in slower performance\n");
3898 gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
] = FALSE
;
3900 TRACE_(d3d_caps
)("PBO test successful\n");
3904 /* Certain applications(Steam) complain if we report an outdated driver version. In general,
3905 * reporting a driver version is moot because we are not the Windows driver, and we have different
3906 * bugs, features, etc.
3908 * If a card is not found in this table, the gl driver version is reported
3910 struct driver_version_information
{
3911 WORD vendor
; /* reported PCI card vendor ID */
3912 WORD card
; /* reported PCI card device ID */
3913 WORD hipart_hi
, hipart_lo
; /* driver hiword to report */
3914 WORD lopart_hi
, lopart_lo
; /* driver loword to report */
3917 static const struct driver_version_information driver_version_table
[] = {
3918 /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (177.x)*/
3919 /* GeforceFX support is up to 173.x, Geforce2MX/3/4 up to 96.x, TNT/Geforce1/2 up to 71.x */
3920 /* Note that version numbers >100 lets say 123.45 use >= x.y.11.2345 and not x.y.10.12345 */
3921 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5200
, 7, 15, 11, 7341 },
3922 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5600
, 7, 15, 11, 7341 },
3923 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5800
, 7, 15, 11, 7341 },
3924 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6200
, 7, 15, 11, 7341 },
3925 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6600GT
, 7, 15, 11, 7341 },
3926 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6800
, 7, 15, 11, 7341 },
3927 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7400
, 7, 15, 11, 7341 },
3928 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7300
, 7, 15, 11, 7341 },
3929 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7600
, 7, 15, 11, 7341 },
3930 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7800GT
, 7, 15, 11, 7341 },
3931 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8300GS
, 7, 15, 11, 7341 },
3932 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600GT
, 7, 15, 11, 7341 },
3933 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600MGT
, 7, 15, 11, 7341 },
3934 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8800GTS
, 7, 15, 11, 7341 },
3935 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9600GT
, 7, 15, 11, 7341 },
3936 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9800GT
, 7, 15, 11, 7341 },
3937 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GTX280
, 7, 15, 11, 7341 },
3939 /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode */
3940 {VENDOR_ATI
, CARD_ATI_RADEON_9500
, 6, 14, 10, 6764 },
3941 {VENDOR_ATI
, CARD_ATI_RADEON_X700
, 6, 14, 10, 6764 },
3942 {VENDOR_ATI
, CARD_ATI_RADEON_X1600
, 6, 14, 10, 6764 },
3943 {VENDOR_ATI
, CARD_ATI_RADEON_HD2300
, 6, 14, 10, 6764 },
3944 {VENDOR_ATI
, CARD_ATI_RADEON_HD2600
, 6, 14, 10, 6764 },
3945 {VENDOR_ATI
, CARD_ATI_RADEON_HD2900
, 6, 14, 10, 6764 },
3947 /* TODO: Add information about legacy nvidia and ATI hardware, Intel and other cards */
3950 static void fixup_extensions(WineD3D_GL_Info
*gl_info
) {
3952 BOOL apple
= implementation_is_apple(gl_info
);
3955 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
3956 * used it falls back to software. While the compiler can detect if the shader uses all declared
3957 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
3958 * using relative addressing falls back to software.
3960 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL
3962 if(gl_info
->vs_glsl_constantsF
<= gl_info
->vs_arb_constantsF
) {
3963 FIXME("GLSL doesn't advertise more vertex shader uniforms than ARB. Driver fixup outdated?\n");
3965 TRACE("Driver claims %u GLSL vs uniforms, replacing with %u ARB vp uniforms\n",
3966 gl_info
->vs_glsl_constantsF
, gl_info
->vs_arb_constantsF
);
3967 gl_info
->vs_glsl_constantsF
= gl_info
->vs_arb_constantsF
;
3970 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
3971 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
3972 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
3973 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
3974 * according to the spec.
3976 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
3977 * makes the shader slower and eats instruction slots which should be available to the d3d app.
3979 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
3980 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
3981 * this workaround is activated on cards that do not need it, it won't break things, just affect
3982 * performance negatively.
3984 if(gl_info
->gl_vendor
== VENDOR_INTEL
||
3985 (gl_info
->gl_vendor
== VENDOR_ATI
&& gl_info
->gl_card
!= CARD_ATI_RADEON_X1600
)) {
3986 TRACE("Enabling vertex texture coord fixes in vertex shaders\n");
3987 gl_info
->set_texcoord_w
= TRUE
;
3991 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
3992 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
3993 * If real NP2 textures are used, the driver falls back to software. We could just remove the
3994 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
3995 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
3996 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
3997 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
3999 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
4000 * has this extension promoted to core. The extension loading code sets this extension supported
4001 * due to that, so this code works on fglrx as well.
4003 if(gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] && gl_info
->gl_vendor
== VENDOR_ATI
) {
4004 if(gl_info
->gl_card
== CARD_ATI_RADEON_X700
|| gl_info
->gl_card
== CARD_ATI_RADEON_X1600
||
4005 gl_info
->gl_card
== CARD_ATI_RADEON_9500
|| gl_info
->gl_card
== CARD_ATI_RADEON_8500
||
4006 gl_info
->gl_card
== CARD_ATI_RADEON_7200
|| gl_info
->gl_card
== CARD_ATI_RAGE_128PRO
) {
4007 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing\n");
4008 gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] = FALSE
;
4009 gl_info
->supported
[WINE_NORMALIZED_TEXRECT
] = TRUE
;
4013 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
4014 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
4015 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
4016 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
4017 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
4018 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
4020 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
4021 * triggering the software fallback. There is not much we can do here apart from disabling the
4022 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
4023 * in IWineD3DImpl_FillGLCaps).
4024 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
4025 * post-processing effects in the game "Max Payne 2").
4026 * The behaviour can be verified through a simple test app attached in bugreport #14724.
4028 if(gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] && gl_info
->gl_vendor
== VENDOR_NVIDIA
) {
4029 if(gl_info
->gl_card
== CARD_NVIDIA_GEFORCEFX_5800
|| gl_info
->gl_card
== CARD_NVIDIA_GEFORCEFX_5600
) {
4030 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing\n");
4031 gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] = FALSE
;
4032 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = TRUE
;
4036 /* Find out if PBOs work as they are supposed to */
4037 test_pbo_functionality(gl_info
);
4039 /* Fixup the driver version */
4040 for(i
= 0; i
< (sizeof(driver_version_table
) / sizeof(driver_version_table
[0])); i
++) {
4041 if(gl_info
->gl_vendor
== driver_version_table
[i
].vendor
&&
4042 gl_info
->gl_card
== driver_version_table
[i
].card
) {
4043 TRACE_(d3d_caps
)("Found card 0x%04x, 0x%04x in driver version DB\n", gl_info
->gl_vendor
, gl_info
->gl_card
);
4045 gl_info
->driver_version
= MAKEDWORD_VERSION(driver_version_table
[i
].lopart_hi
,
4046 driver_version_table
[i
].lopart_lo
);
4047 gl_info
->driver_version_hipart
= MAKEDWORD_VERSION(driver_version_table
[i
].hipart_hi
,
4048 driver_version_table
[i
].hipart_lo
);
4054 static void WINE_GLAPI
invalid_func(const void *data
)
4056 ERR("Invalid vertex attribute function called\n");
4060 static void WINE_GLAPI
invalid_texcoord_func(GLenum unit
, const void *data
)
4062 ERR("Invalid texcoord function called\n");
4066 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4067 * the extension detection and are used in drawStridedSlow
4069 static void WINE_GLAPI
position_d3dcolor(const void *data
)
4071 DWORD pos
= *((const DWORD
*)data
);
4073 FIXME("Add a test for fixed function position from d3dcolor type\n");
4074 glVertex4s(D3DCOLOR_B_R(pos
),
4080 static void WINE_GLAPI
position_float4(const void *data
)
4082 const GLfloat
*pos
= data
;
4084 if (pos
[3] < eps
&& pos
[3] > -eps
)
4087 float w
= 1.0 / pos
[3];
4089 glVertex4f(pos
[0] * w
, pos
[1] * w
, pos
[2] * w
, w
);
4093 static void WINE_GLAPI
diffuse_d3dcolor(const void *data
)
4095 DWORD diffuseColor
= *((const DWORD
*)data
);
4097 glColor4ub(D3DCOLOR_B_R(diffuseColor
),
4098 D3DCOLOR_B_G(diffuseColor
),
4099 D3DCOLOR_B_B(diffuseColor
),
4100 D3DCOLOR_B_A(diffuseColor
));
4103 static void WINE_GLAPI
specular_d3dcolor(const void *data
)
4105 DWORD specularColor
= *((const DWORD
*)data
);
4106 GLbyte d
[] = {D3DCOLOR_B_R(specularColor
),
4107 D3DCOLOR_B_G(specularColor
),
4108 D3DCOLOR_B_B(specularColor
)};
4110 specular_func_3ubv(d
);
4113 static void WINE_GLAPI
warn_no_specular_func(const void *data
)
4115 WARN("GL_EXT_secondary_color not supported\n");
4118 static void fillGLAttribFuncs(const WineD3D_GL_Info
*gl_info
)
4120 position_funcs
[WINED3DDECLTYPE_FLOAT1
] = invalid_func
;
4121 position_funcs
[WINED3DDECLTYPE_FLOAT2
] = invalid_func
;
4122 position_funcs
[WINED3DDECLTYPE_FLOAT3
] = (glAttribFunc
)glVertex3fv
;
4123 position_funcs
[WINED3DDECLTYPE_FLOAT4
] = position_float4
;
4124 position_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = position_d3dcolor
;
4125 position_funcs
[WINED3DDECLTYPE_UBYTE4
] = invalid_func
;
4126 position_funcs
[WINED3DDECLTYPE_SHORT2
] = invalid_func
;
4127 position_funcs
[WINED3DDECLTYPE_SHORT4
] = (glAttribFunc
)glVertex2sv
;
4128 position_funcs
[WINED3DDECLTYPE_UBYTE4N
] = invalid_func
;
4129 position_funcs
[WINED3DDECLTYPE_SHORT2N
] = invalid_func
;
4130 position_funcs
[WINED3DDECLTYPE_SHORT4N
] = invalid_func
;
4131 position_funcs
[WINED3DDECLTYPE_USHORT2N
] = invalid_func
;
4132 position_funcs
[WINED3DDECLTYPE_USHORT4N
] = invalid_func
;
4133 position_funcs
[WINED3DDECLTYPE_UDEC3
] = invalid_func
;
4134 position_funcs
[WINED3DDECLTYPE_DEC3N
] = invalid_func
;
4135 position_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = invalid_func
;
4136 position_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = invalid_func
;
4138 diffuse_funcs
[WINED3DDECLTYPE_FLOAT1
] = invalid_func
;
4139 diffuse_funcs
[WINED3DDECLTYPE_FLOAT2
] = invalid_func
;
4140 diffuse_funcs
[WINED3DDECLTYPE_FLOAT3
] = (glAttribFunc
)glColor3fv
;
4141 diffuse_funcs
[WINED3DDECLTYPE_FLOAT4
] = (glAttribFunc
)glColor4fv
;
4142 diffuse_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = diffuse_d3dcolor
;
4143 diffuse_funcs
[WINED3DDECLTYPE_UBYTE4
] = invalid_func
;
4144 diffuse_funcs
[WINED3DDECLTYPE_SHORT2
] = invalid_func
;
4145 diffuse_funcs
[WINED3DDECLTYPE_SHORT4
] = invalid_func
;
4146 diffuse_funcs
[WINED3DDECLTYPE_UBYTE4N
] = (glAttribFunc
)glColor4ubv
;
4147 diffuse_funcs
[WINED3DDECLTYPE_SHORT2N
] = invalid_func
;
4148 diffuse_funcs
[WINED3DDECLTYPE_SHORT4N
] = (glAttribFunc
)glColor4sv
;
4149 diffuse_funcs
[WINED3DDECLTYPE_USHORT2N
] = invalid_func
;
4150 diffuse_funcs
[WINED3DDECLTYPE_USHORT4N
] = (glAttribFunc
)glColor4usv
;
4151 diffuse_funcs
[WINED3DDECLTYPE_UDEC3
] = invalid_func
;
4152 diffuse_funcs
[WINED3DDECLTYPE_DEC3N
] = invalid_func
;
4153 diffuse_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = invalid_func
;
4154 diffuse_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = invalid_func
;
4156 /* No 4 component entry points here */
4157 specular_funcs
[WINED3DDECLTYPE_FLOAT1
] = invalid_func
;
4158 specular_funcs
[WINED3DDECLTYPE_FLOAT2
] = invalid_func
;
4159 if(GL_SUPPORT(EXT_SECONDARY_COLOR
)) {
4160 specular_funcs
[WINED3DDECLTYPE_FLOAT3
] = (glAttribFunc
)GL_EXTCALL(glSecondaryColor3fvEXT
);
4162 specular_funcs
[WINED3DDECLTYPE_FLOAT3
] = warn_no_specular_func
;
4164 specular_funcs
[WINED3DDECLTYPE_FLOAT4
] = invalid_func
;
4165 if(GL_SUPPORT(EXT_SECONDARY_COLOR
)) {
4166 specular_func_3ubv
= (glAttribFunc
)GL_EXTCALL(glSecondaryColor3ubvEXT
);
4167 specular_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = specular_d3dcolor
;
4169 specular_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = warn_no_specular_func
;
4171 specular_funcs
[WINED3DDECLTYPE_UBYTE4
] = invalid_func
;
4172 specular_funcs
[WINED3DDECLTYPE_SHORT2
] = invalid_func
;
4173 specular_funcs
[WINED3DDECLTYPE_SHORT4
] = invalid_func
;
4174 specular_funcs
[WINED3DDECLTYPE_UBYTE4N
] = invalid_func
;
4175 specular_funcs
[WINED3DDECLTYPE_SHORT2N
] = invalid_func
;
4176 specular_funcs
[WINED3DDECLTYPE_SHORT4N
] = invalid_func
;
4177 specular_funcs
[WINED3DDECLTYPE_USHORT2N
] = invalid_func
;
4178 specular_funcs
[WINED3DDECLTYPE_USHORT4N
] = invalid_func
;
4179 specular_funcs
[WINED3DDECLTYPE_UDEC3
] = invalid_func
;
4180 specular_funcs
[WINED3DDECLTYPE_DEC3N
] = invalid_func
;
4181 specular_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = invalid_func
;
4182 specular_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = invalid_func
;
4184 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4185 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4187 normal_funcs
[WINED3DDECLTYPE_FLOAT1
] = invalid_func
;
4188 normal_funcs
[WINED3DDECLTYPE_FLOAT2
] = invalid_func
;
4189 normal_funcs
[WINED3DDECLTYPE_FLOAT3
] = (glAttribFunc
)glNormal3fv
;
4190 normal_funcs
[WINED3DDECLTYPE_FLOAT4
] = (glAttribFunc
)glNormal3fv
; /* Just ignore the 4th value */
4191 normal_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = invalid_func
;
4192 normal_funcs
[WINED3DDECLTYPE_UBYTE4
] = invalid_func
;
4193 normal_funcs
[WINED3DDECLTYPE_SHORT2
] = invalid_func
;
4194 normal_funcs
[WINED3DDECLTYPE_SHORT4
] = invalid_func
;
4195 normal_funcs
[WINED3DDECLTYPE_UBYTE4N
] = invalid_func
;
4196 normal_funcs
[WINED3DDECLTYPE_SHORT2N
] = invalid_func
;
4197 normal_funcs
[WINED3DDECLTYPE_SHORT4N
] = invalid_func
;
4198 normal_funcs
[WINED3DDECLTYPE_USHORT2N
] = invalid_func
;
4199 normal_funcs
[WINED3DDECLTYPE_USHORT4N
] = invalid_func
;
4200 normal_funcs
[WINED3DDECLTYPE_UDEC3
] = invalid_func
;
4201 normal_funcs
[WINED3DDECLTYPE_DEC3N
] = invalid_func
;
4202 normal_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = invalid_func
;
4203 normal_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = invalid_func
;
4205 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT1
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord1fvARB
);
4206 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2fvARB
);
4207 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT3
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord3fvARB
);
4208 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4fvARB
);
4209 multi_texcoord_funcs
[WINED3DDECLTYPE_D3DCOLOR
] = invalid_texcoord_func
;
4210 multi_texcoord_funcs
[WINED3DDECLTYPE_UBYTE4
] = invalid_texcoord_func
;
4211 multi_texcoord_funcs
[WINED3DDECLTYPE_SHORT2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2svARB
);
4212 multi_texcoord_funcs
[WINED3DDECLTYPE_SHORT4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4svARB
);
4213 multi_texcoord_funcs
[WINED3DDECLTYPE_UBYTE4N
] = invalid_texcoord_func
;
4214 multi_texcoord_funcs
[WINED3DDECLTYPE_SHORT2N
] = invalid_texcoord_func
;
4215 multi_texcoord_funcs
[WINED3DDECLTYPE_SHORT4N
] = invalid_texcoord_func
;
4216 multi_texcoord_funcs
[WINED3DDECLTYPE_USHORT2N
] = invalid_texcoord_func
;
4217 multi_texcoord_funcs
[WINED3DDECLTYPE_USHORT4N
] = invalid_texcoord_func
;
4218 multi_texcoord_funcs
[WINED3DDECLTYPE_UDEC3
] = invalid_texcoord_func
;
4219 multi_texcoord_funcs
[WINED3DDECLTYPE_DEC3N
] = invalid_texcoord_func
;
4220 if (GL_SUPPORT(NV_HALF_FLOAT
))
4222 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2hvNV
);
4223 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4hvNV
);
4225 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT16_2
] = invalid_texcoord_func
;
4226 multi_texcoord_funcs
[WINED3DDECLTYPE_FLOAT16_4
] = invalid_texcoord_func
;
4230 BOOL
InitAdapters(IWineD3DImpl
*This
)
4232 static HMODULE mod_gl
;
4234 int ps_selected_mode
, vs_selected_mode
;
4236 /* No need to hold any lock. The calling library makes sure only one thread calls
4237 * wined3d simultaneously
4240 TRACE("Initializing adapters\n");
4243 #ifdef USE_WIN32_OPENGL
4244 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
4245 mod_gl
= LoadLibraryA("opengl32.dll");
4247 ERR("Can't load opengl32.dll!\n");
4251 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
4252 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
4253 mod_gl
= GetModuleHandleA("gdi32.dll");
4257 /* Load WGL core functions from opengl32.dll */
4258 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
4262 if(!pwglGetProcAddress
) {
4263 ERR("Unable to load wglGetProcAddress!\n");
4267 /* Dynamically load all GL core functions */
4271 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
4272 * otherwise because we have to use winex11.drv's override
4274 #ifdef USE_WIN32_OPENGL
4275 glFinish
= (void*)GetProcAddress(mod_gl
, "glFinish");
4276 glFlush
= (void*)GetProcAddress(mod_gl
, "glFlush");
4278 glFinish
= (void*)pwglGetProcAddress("wglFinish");
4279 glFlush
= (void*)pwglGetProcAddress("wglFlush");
4282 glEnableWINE
= glEnable
;
4283 glDisableWINE
= glDisable
;
4285 /* For now only one default adapter */
4287 struct WineD3DAdapter
*adapter
= &This
->adapters
[0];
4288 const WineD3D_GL_Info
*gl_info
= &adapter
->gl_info
;
4292 WineD3D_PixelFormat
*cfgs
;
4293 DISPLAY_DEVICEW DisplayDevice
;
4296 TRACE("Initializing default adapter\n");
4298 adapter
->monitorPoint
.x
= -1;
4299 adapter
->monitorPoint
.y
= -1;
4301 if (!WineD3D_CreateFakeGLContext()) {
4302 ERR("Failed to get a gl context for default adapter\n");
4303 WineD3D_ReleaseFakeGLContext();
4307 ret
= IWineD3DImpl_FillGLCaps(&adapter
->gl_info
);
4309 ERR("Failed to initialize gl caps for default adapter\n");
4310 WineD3D_ReleaseFakeGLContext();
4313 ret
= initPixelFormats(&adapter
->gl_info
);
4315 ERR("Failed to init gl formats\n");
4316 WineD3D_ReleaseFakeGLContext();
4320 hdc
= pwglGetCurrentDC();
4322 ERR("Failed to get gl HDC\n");
4323 WineD3D_ReleaseFakeGLContext();
4327 adapter
->driver
= "Display";
4328 adapter
->description
= "Direct3D HAL";
4330 /* Use the VideoRamSize registry setting when set */
4331 if(wined3d_settings
.emulated_textureram
)
4332 adapter
->TextureRam
= wined3d_settings
.emulated_textureram
;
4334 adapter
->TextureRam
= adapter
->gl_info
.vidmem
;
4335 adapter
->UsedTextureRam
= 0;
4336 TRACE("Emulating %dMB of texture ram\n", adapter
->TextureRam
/(1024*1024));
4338 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
4339 DisplayDevice
.cb
= sizeof(DisplayDevice
);
4340 EnumDisplayDevicesW(NULL
, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice
, 0);
4341 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice
.DeviceName
));
4342 strcpyW(adapter
->DeviceName
, DisplayDevice
.DeviceName
);
4344 if(GL_SUPPORT(WGL_ARB_PIXEL_FORMAT
))
4351 attribute
= WGL_NUMBER_PIXEL_FORMATS_ARB
;
4352 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, 0, 0, 1, &attribute
, &adapter
->nCfgs
));
4354 adapter
->cfgs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, adapter
->nCfgs
*sizeof(WineD3D_PixelFormat
));
4355 cfgs
= adapter
->cfgs
;
4356 attribs
[nAttribs
++] = WGL_RED_BITS_ARB
;
4357 attribs
[nAttribs
++] = WGL_GREEN_BITS_ARB
;
4358 attribs
[nAttribs
++] = WGL_BLUE_BITS_ARB
;
4359 attribs
[nAttribs
++] = WGL_ALPHA_BITS_ARB
;
4360 attribs
[nAttribs
++] = WGL_DEPTH_BITS_ARB
;
4361 attribs
[nAttribs
++] = WGL_STENCIL_BITS_ARB
;
4362 attribs
[nAttribs
++] = WGL_DRAW_TO_WINDOW_ARB
;
4363 attribs
[nAttribs
++] = WGL_PIXEL_TYPE_ARB
;
4364 attribs
[nAttribs
++] = WGL_DOUBLE_BUFFER_ARB
;
4365 attribs
[nAttribs
++] = WGL_AUX_BUFFERS_ARB
;
4367 for (iPixelFormat
=1; iPixelFormat
<= adapter
->nCfgs
; ++iPixelFormat
)
4369 res
= GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, nAttribs
, attribs
, values
));
4374 /* Cache the pixel format */
4375 cfgs
->iPixelFormat
= iPixelFormat
;
4376 cfgs
->redSize
= values
[0];
4377 cfgs
->greenSize
= values
[1];
4378 cfgs
->blueSize
= values
[2];
4379 cfgs
->alphaSize
= values
[3];
4380 cfgs
->depthSize
= values
[4];
4381 cfgs
->stencilSize
= values
[5];
4382 cfgs
->windowDrawable
= values
[6];
4383 cfgs
->iPixelType
= values
[7];
4384 cfgs
->doubleBuffer
= values
[8];
4385 cfgs
->auxBuffers
= values
[9];
4387 cfgs
->pbufferDrawable
= FALSE
;
4388 /* Check for pbuffer support when it is around as wglGetPixelFormatAttribiv fails for unknown attributes. */
4389 if(GL_SUPPORT(WGL_ARB_PBUFFER
)) {
4390 int attrib
= WGL_DRAW_TO_PBUFFER_ARB
;
4392 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, 1, &attrib
, &value
)))
4393 cfgs
->pbufferDrawable
= value
;
4396 cfgs
->numSamples
= 0;
4397 /* Check multisample support */
4398 if(GL_SUPPORT(ARB_MULTISAMPLE
)) {
4399 int attrib
[2] = {WGL_SAMPLE_BUFFERS_ARB
, WGL_SAMPLES_ARB
};
4401 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, 2, attrib
, value
))) {
4402 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
4403 * value[1] = number of multi sample buffers*/
4405 cfgs
->numSamples
= value
[1];
4409 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d, windowDrawable=%d, pbufferDrawable=%d\n", cfgs
->iPixelFormat
, cfgs
->iPixelType
, cfgs
->doubleBuffer
, cfgs
->redSize
, cfgs
->greenSize
, cfgs
->blueSize
, cfgs
->alphaSize
, cfgs
->depthSize
, cfgs
->stencilSize
, cfgs
->windowDrawable
, cfgs
->pbufferDrawable
);
4415 int nCfgs
= DescribePixelFormat(hdc
, 0, 0, 0);
4416 adapter
->cfgs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, nCfgs
*sizeof(WineD3D_PixelFormat
));
4417 adapter
->nCfgs
= 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
4419 cfgs
= adapter
->cfgs
;
4420 for(iPixelFormat
=1; iPixelFormat
<=nCfgs
; iPixelFormat
++)
4422 PIXELFORMATDESCRIPTOR ppfd
;
4424 res
= DescribePixelFormat(hdc
, iPixelFormat
, sizeof(PIXELFORMATDESCRIPTOR
), &ppfd
);
4428 /* We only want HW acceleration using an OpenGL ICD driver.
4429 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
4430 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
4432 if(ppfd
.dwFlags
& (PFD_GENERIC_FORMAT
| PFD_GENERIC_ACCELERATED
))
4434 TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat
);
4438 cfgs
->iPixelFormat
= iPixelFormat
;
4439 cfgs
->redSize
= ppfd
.cRedBits
;
4440 cfgs
->greenSize
= ppfd
.cGreenBits
;
4441 cfgs
->blueSize
= ppfd
.cBlueBits
;
4442 cfgs
->alphaSize
= ppfd
.cAlphaBits
;
4443 cfgs
->depthSize
= ppfd
.cDepthBits
;
4444 cfgs
->stencilSize
= ppfd
.cStencilBits
;
4445 cfgs
->pbufferDrawable
= 0;
4446 cfgs
->windowDrawable
= (ppfd
.dwFlags
& PFD_DRAW_TO_WINDOW
) ? 1 : 0;
4447 cfgs
->iPixelType
= (ppfd
.iPixelType
== PFD_TYPE_RGBA
) ? WGL_TYPE_RGBA_ARB
: WGL_TYPE_COLORINDEX_ARB
;
4448 cfgs
->doubleBuffer
= (ppfd
.dwFlags
& PFD_DOUBLEBUFFER
) ? 1 : 0;
4449 cfgs
->auxBuffers
= ppfd
.cAuxBuffers
;
4450 cfgs
->numSamples
= 0;
4452 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d, windowDrawable=%d, pbufferDrawable=%d\n", cfgs
->iPixelFormat
, cfgs
->iPixelType
, cfgs
->doubleBuffer
, cfgs
->redSize
, cfgs
->greenSize
, cfgs
->blueSize
, cfgs
->alphaSize
, cfgs
->depthSize
, cfgs
->stencilSize
, cfgs
->windowDrawable
, cfgs
->pbufferDrawable
);
4457 /* Yikes we haven't found any suitable formats. This should only happen in case of GDI software rendering which we can't use anyway as its 3D functionality is very, very limited */
4460 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
4462 WineD3D_ReleaseFakeGLContext();
4463 HeapFree(GetProcessHeap(), 0, adapter
->cfgs
);
4468 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
4469 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
4470 * but just fake it using D24(X8?) which is fine. D3D also allows that.
4471 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
4472 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
4473 * driver is allowed to consume more bits EXCEPT for stencil bits.
4475 * Mark an adapter with this broken stencil behavior.
4477 adapter
->brokenStencil
= TRUE
;
4478 for (i
= 0, cfgs
= adapter
->cfgs
; i
< adapter
->nCfgs
; ++i
)
4480 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
4481 if(cfgs
[i
].depthSize
&& !cfgs
[i
].stencilSize
) {
4482 adapter
->brokenStencil
= FALSE
;
4487 fixup_extensions(&adapter
->gl_info
);
4488 add_gl_compat_wrappers(&adapter
->gl_info
);
4490 WineD3D_ReleaseFakeGLContext();
4492 select_shader_mode(&adapter
->gl_info
, WINED3DDEVTYPE_HAL
, &ps_selected_mode
, &vs_selected_mode
);
4493 select_shader_max_constants(ps_selected_mode
, vs_selected_mode
, &adapter
->gl_info
);
4494 fillGLAttribFuncs(&adapter
->gl_info
);
4495 init_type_lookup(&adapter
->gl_info
);
4496 adapter
->opengl
= TRUE
;
4498 This
->adapter_count
= 1;
4499 TRACE("%u adapters successfully initialized\n", This
->adapter_count
);
4504 /* Initialize an adapter for ddraw-only memory counting */
4505 memset(This
->adapters
, 0, sizeof(This
->adapters
));
4506 This
->adapters
[0].num
= 0;
4507 This
->adapters
[0].opengl
= FALSE
;
4508 This
->adapters
[0].monitorPoint
.x
= -1;
4509 This
->adapters
[0].monitorPoint
.y
= -1;
4511 This
->adapters
[0].driver
= "Display";
4512 This
->adapters
[0].description
= "WineD3D DirectDraw Emulation";
4513 if(wined3d_settings
.emulated_textureram
) {
4514 This
->adapters
[0].TextureRam
= wined3d_settings
.emulated_textureram
;
4516 This
->adapters
[0].TextureRam
= 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
4519 initPixelFormatsNoGL(&This
->adapters
[0].gl_info
);
4521 This
->adapter_count
= 1;
4525 /**********************************************************
4526 * IWineD3D VTbl follows
4527 **********************************************************/
4529 const IWineD3DVtbl IWineD3D_Vtbl
=
4532 IWineD3DImpl_QueryInterface
,
4533 IWineD3DImpl_AddRef
,
4534 IWineD3DImpl_Release
,
4536 IWineD3DImpl_GetParent
,
4537 IWineD3DImpl_GetAdapterCount
,
4538 IWineD3DImpl_RegisterSoftwareDevice
,
4539 IWineD3DImpl_GetAdapterMonitor
,
4540 IWineD3DImpl_GetAdapterModeCount
,
4541 IWineD3DImpl_EnumAdapterModes
,
4542 IWineD3DImpl_GetAdapterDisplayMode
,
4543 IWineD3DImpl_GetAdapterIdentifier
,
4544 IWineD3DImpl_CheckDeviceMultiSampleType
,
4545 IWineD3DImpl_CheckDepthStencilMatch
,
4546 IWineD3DImpl_CheckDeviceType
,
4547 IWineD3DImpl_CheckDeviceFormat
,
4548 IWineD3DImpl_CheckDeviceFormatConversion
,
4549 IWineD3DImpl_GetDeviceCaps
,
4550 IWineD3DImpl_CreateDevice