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
9 * Copyright 2009 Henri Verbeet for CodeWeavers
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wined3d_private.h"
29 WINE_DEFAULT_DEBUG_CHANNEL(d3d
);
30 WINE_DECLARE_DEBUG_CHANNEL(d3d_caps
);
32 #define GLINFO_LOCATION (*gl_info)
33 #define WINE_DEFAULT_VIDMEM (64 * 1024 * 1024)
34 #define MAKEDWORD_VERSION(maj, min) ((maj & 0xffff) << 16) | (min & 0xffff)
36 /* The d3d device ID */
37 static const GUID IID_D3DDEVICE_D3DUID
= { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } };
39 /* Extension detection */
41 const char *extension_string
;
42 GL_SupportedExt extension
;
46 {"GL_APPLE_client_storage", APPLE_CLIENT_STORAGE
, 0 },
47 {"GL_APPLE_fence", APPLE_FENCE
, 0 },
48 {"GL_APPLE_float_pixels", APPLE_FLOAT_PIXELS
, 0 },
49 {"GL_APPLE_flush_buffer_range", APPLE_FLUSH_BUFFER_RANGE
, 0 },
50 {"GL_APPLE_flush_render", APPLE_FLUSH_RENDER
, 0 },
51 {"GL_APPLE_ycbcr_422", APPLE_YCBCR_422
, 0 },
54 {"GL_ARB_color_buffer_float", ARB_COLOR_BUFFER_FLOAT
, 0 },
55 {"GL_ARB_depth_buffer_float", ARB_DEPTH_BUFFER_FLOAT
, 0 },
56 {"GL_ARB_depth_clamp", ARB_DEPTH_CLAMP
, 0 },
57 {"GL_ARB_depth_texture", ARB_DEPTH_TEXTURE
, 0 },
58 {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS
, 0 },
59 {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM
, 0 },
60 {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER
, 0 },
61 {"GL_ARB_framebuffer_object", ARB_FRAMEBUFFER_OBJECT
, 0 },
62 {"GL_ARB_geometry_shader4", ARB_GEOMETRY_SHADER4
, 0 },
63 {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL
, 0 },
64 {"GL_ARB_half_float_vertex", ARB_HALF_FLOAT_VERTEX
, 0 },
65 {"GL_ARB_imaging", ARB_IMAGING
, 0 },
66 {"GL_ARB_map_buffer_range", ARB_MAP_BUFFER_RANGE
, 0 },
67 {"GL_ARB_multisample", ARB_MULTISAMPLE
, 0 }, /* needs GLX_ARB_MULTISAMPLE as well */
68 {"GL_ARB_multitexture", ARB_MULTITEXTURE
, 0 },
69 {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY
, 0 },
70 {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT
, 0 },
71 {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS
, 0 },
72 {"GL_ARB_point_sprite", ARB_POINT_SPRITE
, 0 },
73 {"GL_ARB_provoking_vertex", ARB_PROVOKING_VERTEX
, 0 },
74 {"GL_ARB_shader_objects", ARB_SHADER_OBJECTS
, 0 },
75 {"GL_ARB_shader_texture_lod", ARB_SHADER_TEXTURE_LOD
, 0 },
76 {"GL_ARB_shading_language_100", ARB_SHADING_LANGUAGE_100
, 0 },
77 {"GL_ARB_sync", ARB_SYNC
, 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_array_bgra", ARB_VERTEX_ARRAY_BGRA
, 0 },
90 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND
, 0 },
91 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT
, 0 },
92 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM
, 0 },
93 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER
, 0 },
96 {"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER
, 0 },
97 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL
, 0 },
98 {"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC
, 0 },
99 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3
, 0 },
100 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE
, 0 },
103 {"GL_EXT_blend_color", EXT_BLEND_COLOR
, 0 },
104 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE
, 0 },
105 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE
, 0 },
106 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX
, 0 },
107 {"GL_EXT_fog_coord", EXT_FOG_COORD
, 0 },
108 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT
, 0 },
109 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE
, 0 },
110 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT
, 0 },
111 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS
, 0 },
112 {"GL_EXT_gpu_shader4", EXT_GPU_SHADER4
, 0 },
113 {"GL_EXT_packed_depth_stencil", EXT_PACKED_DEPTH_STENCIL
, 0 },
114 {"GL_EXT_paletted_texture", EXT_PALETTED_TEXTURE
, 0 },
115 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS
, 0 },
116 {"GL_EXT_provoking_vertex", EXT_PROVOKING_VERTEX
, 0 },
117 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR
, 0 },
118 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE
, 0 },
119 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP
, 0 },
120 {"GL_EXT_texture3D", EXT_TEXTURE3D
, MAKEDWORD_VERSION(1, 2) },
121 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC
, 0 },
122 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC
, 0 },
123 {"GL_EXT_texture_env_add", EXT_TEXTURE_ENV_ADD
, 0 },
124 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE
, 0 },
125 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3
, 0 },
126 {"GL_EXT_texture_filter_anisotropic", EXT_TEXTURE_FILTER_ANISOTROPIC
, 0 },
127 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS
, 0 },
128 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB
, 0 },
129 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA
, 0 },
132 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP
, 0 },
133 {"GL_NV_fence", NV_FENCE
, 0 },
134 {"GL_NV_fog_distance", NV_FOG_DISTANCE
, 0 },
135 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM
, 0 },
136 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2
, 0 },
137 {"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION
, 0 },
138 {"GL_NV_half_float", NV_HALF_FLOAT
, 0 },
139 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT
, 0 },
140 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS
, 0 },
141 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2
, 0 },
142 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION
, 0 },
143 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4
, 0 },
144 {"GL_NV_texture_shader", NV_TEXTURE_SHADER
, 0 },
145 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2
, 0 },
146 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM
, 0 },
147 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1
, 0 },
148 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2
, 0 },
149 {"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION
, 0 },
150 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3
, 0 },
153 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP
, 0 },
156 /**********************************************************
157 * Utility functions follow
158 **********************************************************/
160 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
, WINED3DSURFTYPE SurfaceType
);
162 const struct min_lookup minMipLookup
[] =
164 /* NONE POINT LINEAR */
165 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* NONE */
166 {{GL_NEAREST
, GL_NEAREST_MIPMAP_NEAREST
, GL_NEAREST_MIPMAP_LINEAR
}}, /* POINT*/
167 {{GL_LINEAR
, GL_LINEAR_MIPMAP_NEAREST
, GL_LINEAR_MIPMAP_LINEAR
}}, /* LINEAR */
170 const struct min_lookup minMipLookup_noFilter
[] =
172 /* NONE POINT LINEAR */
173 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* NONE */
174 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* POINT */
175 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* LINEAR */
178 const struct min_lookup minMipLookup_noMip
[] =
180 /* NONE POINT LINEAR */
181 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* NONE */
182 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* POINT */
183 {{GL_LINEAR
, GL_LINEAR
, GL_LINEAR
}}, /* LINEAR */
186 const GLenum magLookup
[] =
188 /* NONE POINT LINEAR */
189 GL_NEAREST
, GL_NEAREST
, GL_LINEAR
,
192 const GLenum magLookup_noFilter
[] =
194 /* NONE POINT LINEAR */
195 GL_NEAREST
, GL_NEAREST
, GL_NEAREST
,
198 /* drawStridedSlow attributes */
199 glAttribFunc position_funcs
[WINED3D_FFP_EMIT_COUNT
];
200 glAttribFunc diffuse_funcs
[WINED3D_FFP_EMIT_COUNT
];
201 glAttribFunc specular_func_3ubv
;
202 glAttribFunc specular_funcs
[WINED3D_FFP_EMIT_COUNT
];
203 glAttribFunc normal_funcs
[WINED3D_FFP_EMIT_COUNT
];
204 glMultiTexCoordFunc multi_texcoord_funcs
[WINED3D_FFP_EMIT_COUNT
];
207 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
208 * i.e., there is no GL Context - Get a default rendering context to enable the
209 * function query some info from GL.
212 struct wined3d_fake_gl_ctx
218 HGLRC restore_gl_ctx
;
221 static void WineD3D_ReleaseFakeGLContext(struct wined3d_fake_gl_ctx
*ctx
)
223 TRACE_(d3d_caps
)("Destroying fake GL context.\n");
225 if (!pwglMakeCurrent(NULL
, NULL
))
227 ERR_(d3d_caps
)("Failed to disable fake GL context.\n");
230 if (!pwglDeleteContext(ctx
->gl_ctx
))
232 DWORD err
= GetLastError();
233 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx
->gl_ctx
, err
);
236 ReleaseDC(ctx
->wnd
, ctx
->dc
);
237 DestroyWindow(ctx
->wnd
);
239 if (ctx
->restore_gl_ctx
&& !pwglMakeCurrent(ctx
->restore_dc
, ctx
->restore_gl_ctx
))
241 ERR_(d3d_caps
)("Failed to restore previous GL context.\n");
245 static BOOL
WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx
*ctx
)
247 PIXELFORMATDESCRIPTOR pfd
;
250 TRACE("getting context...\n");
252 ctx
->restore_dc
= pwglGetCurrentDC();
253 ctx
->restore_gl_ctx
= pwglGetCurrentContext();
255 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
256 ctx
->wnd
= CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME
, "WineD3D fake window",
257 WS_OVERLAPPEDWINDOW
, 10, 10, 10, 10, NULL
, NULL
, NULL
, NULL
);
260 ERR_(d3d_caps
)("Failed to create a window.\n");
264 ctx
->dc
= GetDC(ctx
->wnd
);
267 ERR_(d3d_caps
)("Failed to get a DC.\n");
271 /* PixelFormat selection */
272 ZeroMemory(&pfd
, sizeof(pfd
));
273 pfd
.nSize
= sizeof(pfd
);
275 pfd
.dwFlags
= PFD_SUPPORT_OPENGL
| PFD_DOUBLEBUFFER
| PFD_DRAW_TO_WINDOW
; /* PFD_GENERIC_ACCELERATED */
276 pfd
.iPixelType
= PFD_TYPE_RGBA
;
278 pfd
.iLayerType
= PFD_MAIN_PLANE
;
280 iPixelFormat
= ChoosePixelFormat(ctx
->dc
, &pfd
);
283 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
284 ERR_(d3d_caps
)("Can't find a suitable iPixelFormat.\n");
287 DescribePixelFormat(ctx
->dc
, iPixelFormat
, sizeof(pfd
), &pfd
);
288 SetPixelFormat(ctx
->dc
, iPixelFormat
, &pfd
);
290 /* Create a GL context. */
291 ctx
->gl_ctx
= pwglCreateContext(ctx
->dc
);
294 WARN_(d3d_caps
)("Error creating default context for capabilities initialization.\n");
298 /* Make it the current GL context. */
299 if (!context_set_current(NULL
))
301 ERR_(d3d_caps
)("Failed to clear current D3D context.\n");
304 if (!pwglMakeCurrent(ctx
->dc
, ctx
->gl_ctx
))
306 ERR_(d3d_caps
)("Failed to make fake GL context current.\n");
313 if (ctx
->gl_ctx
) pwglDeleteContext(ctx
->gl_ctx
);
315 if (ctx
->dc
) ReleaseDC(ctx
->wnd
, ctx
->dc
);
317 if (ctx
->wnd
) DestroyWindow(ctx
->wnd
);
319 if (ctx
->restore_gl_ctx
&& !pwglMakeCurrent(ctx
->restore_dc
, ctx
->restore_gl_ctx
))
321 ERR_(d3d_caps
)("Failed to restore previous GL context.\n");
327 /* Adjust the amount of used texture memory */
328 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl
*D3DDevice
, long glram
)
330 struct wined3d_adapter
*adapter
= D3DDevice
->adapter
;
332 adapter
->UsedTextureRam
+= glram
;
333 TRACE("Adjusted gl ram by %ld to %d\n", glram
, adapter
->UsedTextureRam
);
334 return adapter
->UsedTextureRam
;
337 static void wined3d_adapter_cleanup(struct wined3d_adapter
*adapter
)
339 HeapFree(GetProcessHeap(), 0, adapter
->gl_info
.gl_formats
);
340 HeapFree(GetProcessHeap(), 0, adapter
->cfgs
);
343 /**********************************************************
344 * IUnknown parts follows
345 **********************************************************/
347 static HRESULT WINAPI
IWineD3DImpl_QueryInterface(IWineD3D
*iface
,REFIID riid
,LPVOID
*ppobj
)
349 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
351 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
352 if (IsEqualGUID(riid
, &IID_IUnknown
)
353 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
354 || IsEqualGUID(riid
, &IID_IWineD3DDevice
)) {
355 IUnknown_AddRef(iface
);
360 return E_NOINTERFACE
;
363 static ULONG WINAPI
IWineD3DImpl_AddRef(IWineD3D
*iface
) {
364 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
365 ULONG refCount
= InterlockedIncrement(&This
->ref
);
367 TRACE("(%p) : AddRef increasing from %d\n", This
, refCount
- 1);
371 static ULONG WINAPI
IWineD3DImpl_Release(IWineD3D
*iface
) {
372 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
374 TRACE("(%p) : Releasing from %d\n", This
, This
->ref
);
375 ref
= InterlockedDecrement(&This
->ref
);
379 for (i
= 0; i
< This
->adapter_count
; ++i
)
381 wined3d_adapter_cleanup(&This
->adapters
[i
]);
383 HeapFree(GetProcessHeap(), 0, This
);
389 /**********************************************************
390 * IWineD3D parts follows
391 **********************************************************/
393 /* GL locking is done by the caller */
394 static inline BOOL
test_arb_vs_offset_limit(const struct wined3d_gl_info
*gl_info
)
398 const char *testcode
=
400 "PARAM C[66] = { program.env[0..65] };\n"
402 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
403 "ARL A0.x, zero.x;\n"
404 "MOV result.position, C[A0.x + 65];\n"
408 GL_EXTCALL(glGenProgramsARB(1, &prog
));
410 ERR("Failed to create an ARB offset limit test program\n");
412 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, prog
));
413 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
,
414 strlen(testcode
), testcode
));
415 if(glGetError() != 0) {
416 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
417 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB
)));
419 } else TRACE("OpenGL implementation allows offsets > 63\n");
421 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, 0));
422 GL_EXTCALL(glDeleteProgramsARB(1, &prog
));
423 checkGLcall("ARB vp offset limit test cleanup");
428 static DWORD
ver_for_ext(GL_SupportedExt ext
)
431 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
432 if(EXTENSION_MAP
[i
].extension
== ext
) {
433 return EXTENSION_MAP
[i
].version
;
439 static BOOL
match_ati_r300_to_500(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
440 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
442 if (vendor
!= VENDOR_ATI
) return FALSE
;
443 if (device
== CARD_ATI_RADEON_9500
) return TRUE
;
444 if (device
== CARD_ATI_RADEON_X700
) return TRUE
;
445 if (device
== CARD_ATI_RADEON_X1600
) return TRUE
;
449 static BOOL
match_geforce5(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
450 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
452 if (vendor
== VENDOR_NVIDIA
)
454 if (device
== CARD_NVIDIA_GEFORCEFX_5800
|| device
== CARD_NVIDIA_GEFORCEFX_5600
)
462 static BOOL
match_apple(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
463 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
465 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
466 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
467 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
469 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
470 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
471 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
472 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
473 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
474 * the chance that other implementations support them is rather small since Win32 QuickTime uses
475 * DirectDraw, not OpenGL. */
476 if (gl_info
->supported
[APPLE_FENCE
]
477 && gl_info
->supported
[APPLE_CLIENT_STORAGE
]
478 && gl_info
->supported
[APPLE_FLUSH_RENDER
]
479 && gl_info
->supported
[APPLE_YCBCR_422
])
489 /* Context activation is done by the caller. */
490 static void test_pbo_functionality(struct wined3d_gl_info
*gl_info
)
492 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
493 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
494 * all the texture. This function detects this bug by its symptom and disables PBOs
497 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
498 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
499 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
500 * read back is compared to the original. If they are equal PBOs are assumed to work,
501 * otherwise the PBO extension is disabled. */
503 static const unsigned int pattern
[] =
505 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
506 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
507 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
508 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
510 unsigned int check
[sizeof(pattern
) / sizeof(pattern
[0])];
512 /* No PBO -> No point in testing them. */
513 if (!gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
]) return;
517 while (glGetError());
518 glGenTextures(1, &texture
);
519 glBindTexture(GL_TEXTURE_2D
, texture
);
521 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAX_LEVEL
, 0);
522 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA8
, 4, 4, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, 0);
523 checkGLcall("Specifying the PBO test texture");
525 GL_EXTCALL(glGenBuffersARB(1, &pbo
));
526 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, pbo
));
527 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, sizeof(pattern
), pattern
, GL_STREAM_DRAW_ARB
));
528 checkGLcall("Specifying the PBO test pbo");
530 glTexSubImage2D(GL_TEXTURE_2D
, 0, 0, 0, 4, 4, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, NULL
);
531 checkGLcall("Loading the PBO test texture");
533 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
534 wglFinish(); /* just to be sure */
536 memset(check
, 0, sizeof(check
));
537 glGetTexImage(GL_TEXTURE_2D
, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, check
);
538 checkGLcall("Reading back the PBO test texture");
540 glDeleteTextures(1, &texture
);
541 GL_EXTCALL(glDeleteBuffersARB(1, &pbo
));
542 checkGLcall("PBO test cleanup");
546 if (memcmp(check
, pattern
, sizeof(check
)))
548 WARN_(d3d_caps
)("PBO test failed, read back data doesn't match original.\n");
549 WARN_(d3d_caps
)("Disabling PBOs. This may result in slower performance.\n");
550 gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
] = FALSE
;
554 TRACE_(d3d_caps
)("PBO test successful.\n");
558 static BOOL
match_apple_intel(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
559 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
561 return vendor
== VENDOR_INTEL
&& match_apple(gl_info
, gl_renderer
, vendor
, device
);
564 static BOOL
match_apple_nonr500ati(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
565 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
567 if (!match_apple(gl_info
, gl_renderer
, vendor
, device
)) return FALSE
;
568 if (vendor
!= VENDOR_ATI
) return FALSE
;
569 if (device
== CARD_ATI_RADEON_X1600
) return FALSE
;
573 static BOOL
match_fglrx(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
574 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
576 if (vendor
!= VENDOR_ATI
) return FALSE
;
577 if (match_apple(gl_info
, gl_renderer
, vendor
, device
)) return FALSE
;
578 if (strstr(gl_renderer
, "DRI")) return FALSE
; /* Filter out Mesa DRI drivers. */
582 static BOOL
match_dx10_capable(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
583 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
585 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
586 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
587 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
588 * varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
591 * dx10 cards usually have 64 varyings */
592 return gl_info
->limits
.glsl_varyings
> 44;
595 /* A GL context is provided by the caller */
596 static BOOL
match_allows_spec_alpha(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
597 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
602 if (!gl_info
->supported
[EXT_SECONDARY_COLOR
]) return FALSE
;
606 GL_EXTCALL(glSecondaryColorPointerEXT
)(4, GL_UNSIGNED_BYTE
, 4, data
);
607 error
= glGetError();
610 if(error
== GL_NO_ERROR
)
612 TRACE("GL Implementation accepts 4 component specular color pointers\n");
617 TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
618 debug_glerror(error
));
623 static BOOL
match_apple_nvts(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
624 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
626 if (!match_apple(gl_info
, gl_renderer
, vendor
, device
)) return FALSE
;
627 return gl_info
->supported
[NV_TEXTURE_SHADER
];
630 /* A GL context is provided by the caller */
631 static BOOL
match_broken_nv_clip(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
632 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
637 const char *testcode
=
639 "OPTION NV_vertex_program2;\n"
640 "MOV result.clip[0], 0.0;\n"
641 "MOV result.position, 0.0;\n"
644 if (!gl_info
->supported
[NV_VERTEX_PROGRAM2_OPTION
]) return FALSE
;
649 GL_EXTCALL(glGenProgramsARB(1, &prog
));
652 ERR("Failed to create the NVvp clip test program\n");
656 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, prog
));
657 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
,
658 strlen(testcode
), testcode
));
659 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB
, &pos
);
662 WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
663 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB
)));
667 else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
669 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, 0));
670 GL_EXTCALL(glDeleteProgramsARB(1, &prog
));
671 checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
677 static void quirk_arb_constants(struct wined3d_gl_info
*gl_info
)
679 TRACE_(d3d_caps
)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info
->limits
.arb_vs_native_constants
);
680 gl_info
->limits
.glsl_vs_float_constants
= gl_info
->limits
.arb_vs_native_constants
;
681 TRACE_(d3d_caps
)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info
->limits
.arb_ps_native_constants
);
682 gl_info
->limits
.glsl_ps_float_constants
= gl_info
->limits
.arb_ps_native_constants
;
685 static void quirk_apple_glsl_constants(struct wined3d_gl_info
*gl_info
)
687 quirk_arb_constants(gl_info
);
688 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
689 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
690 * allow 48 different offsets or other helper immediate values. */
691 TRACE_(d3d_caps
)("Reserving 12 GLSL constants for compiler private use.\n");
692 gl_info
->reserved_glsl_constants
= max(gl_info
->reserved_glsl_constants
, 12);
695 /* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
696 * on more than one texture unit. This means that the d3d9 visual point size test will cause a
697 * kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
698 * quirk only enables point sprites on the first texture unit. This keeps point sprites working in
699 * most games, but avoids the crash
701 * A more sophisticated way would be to find all units that need texture coordinates and enable
702 * point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
703 * if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
705 * Note that disabling the extension entirely does not gain predictability because there is no point
706 * sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
707 static void quirk_one_point_sprite(struct wined3d_gl_info
*gl_info
)
709 if (gl_info
->supported
[ARB_POINT_SPRITE
])
711 TRACE("Limiting point sprites to one texture unit.\n");
712 gl_info
->limits
.point_sprite_units
= 1;
716 static void quirk_ati_dx9(struct wined3d_gl_info
*gl_info
)
718 quirk_arb_constants(gl_info
);
720 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
721 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
722 * If real NP2 textures are used, the driver falls back to software. We could just remove the
723 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
724 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
725 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
726 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
728 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
729 * has this extension promoted to core. The extension loading code sets this extension supported
730 * due to that, so this code works on fglrx as well. */
731 if(gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
])
733 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
734 gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] = FALSE
;
735 gl_info
->supported
[WINE_NORMALIZED_TEXRECT
] = TRUE
;
738 /* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
739 * it is generally more efficient. Reserve just 8 constants. */
740 TRACE_(d3d_caps
)("Reserving 8 GLSL constants for compiler private use.\n");
741 gl_info
->reserved_glsl_constants
= max(gl_info
->reserved_glsl_constants
, 8);
744 static void quirk_no_np2(struct wined3d_gl_info
*gl_info
)
746 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
747 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
748 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
749 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
750 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
751 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
753 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
754 * triggering the software fallback. There is not much we can do here apart from disabling the
755 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
756 * in IWineD3DImpl_FillGLCaps).
757 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
758 * post-processing effects in the game "Max Payne 2").
759 * The behaviour can be verified through a simple test app attached in bugreport #14724. */
760 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
761 gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] = FALSE
;
762 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = TRUE
;
765 static void quirk_texcoord_w(struct wined3d_gl_info
*gl_info
)
767 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
768 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
769 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
770 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
771 * according to the spec.
773 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
774 * makes the shader slower and eats instruction slots which should be available to the d3d app.
776 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
777 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
778 * this workaround is activated on cards that do not need it, it won't break things, just affect
779 * performance negatively. */
780 TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
781 gl_info
->quirks
|= WINED3D_QUIRK_SET_TEXCOORD_W
;
784 static void quirk_clip_varying(struct wined3d_gl_info
*gl_info
)
786 gl_info
->quirks
|= WINED3D_QUIRK_GLSL_CLIP_VARYING
;
789 static void quirk_allows_specular_alpha(struct wined3d_gl_info
*gl_info
)
791 gl_info
->quirks
|= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA
;
794 static void quirk_apple_nvts(struct wined3d_gl_info
*gl_info
)
796 gl_info
->supported
[NV_TEXTURE_SHADER
] = FALSE
;
797 gl_info
->supported
[NV_TEXTURE_SHADER2
] = FALSE
;
800 static void quirk_disable_nvvp_clip(struct wined3d_gl_info
*gl_info
)
802 gl_info
->quirks
|= WINED3D_QUIRK_NV_CLIP_BROKEN
;
807 BOOL (*match
)(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
808 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
);
809 void (*apply
)(struct wined3d_gl_info
*gl_info
);
810 const char *description
;
813 static const struct driver_quirk quirk_table
[] =
816 match_ati_r300_to_500
,
818 "ATI GLSL constant and normalized texrect quirk"
820 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
821 * used it falls back to software. While the compiler can detect if the shader uses all declared
822 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
823 * using relative addressing falls back to software.
825 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
828 quirk_apple_glsl_constants
,
829 "Apple GLSL uniform override"
834 "Geforce 5 NP2 disable"
839 "Init texcoord .w for Apple Intel GPU driver"
842 match_apple_nonr500ati
,
844 "Init texcoord .w for Apple ATI >= r600 GPU driver"
848 quirk_one_point_sprite
,
849 "Fglrx point sprite crash workaround"
854 "Reserved varying for gl_ClipPos"
857 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
858 * GL implementations accept it. The Mac GL is the only implementation known to
861 * If we can pass 4 component specular colors, do it, because (a) we don't have
862 * to screw around with the data, and (b) the D3D fixed function vertex pipeline
863 * passes specular alpha to the pixel shader if any is used. Otherwise the
864 * specular alpha is used to pass the fog coordinate, which we pass to opengl
865 * via GL_EXT_fog_coord.
867 match_allows_spec_alpha
,
868 quirk_allows_specular_alpha
,
869 "Allow specular alpha quirk"
872 /* The pixel formats provided by GL_NV_texture_shader are broken on OSX
877 "Apple NV_texture_shader disable"
880 match_broken_nv_clip
,
881 quirk_disable_nvvp_clip
,
882 "Apple NV_vertex_program clip bug quirk"
886 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
887 * reporting a driver version is moot because we are not the Windows driver, and we have different
888 * bugs, features, etc.
890 * The driver version has the form "x.y.z.w".
892 * "x" is the Windows version the driver is meant for:
899 * "y" is the Direct3D level the driver supports:
906 * "z" is unknown, possibly vendor specific.
908 * "w" is the vendor specific driver version.
910 struct driver_version_information
912 WORD vendor
; /* reported PCI card vendor ID */
913 WORD card
; /* reported PCI card device ID */
914 const char *description
; /* Description of the card e.g. NVIDIA RIVA TNT */
915 WORD d3d_level
; /* driver hiword to report */
916 WORD lopart_hi
, lopart_lo
; /* driver loword to report */
919 static const struct driver_version_information driver_version_table
[] =
921 /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (180.x)
922 * GeforceFX support is up to 173.x, - driver uses numbering x.y.11.7341 for 173.41 where x is the windows revision (6=2000/xp, 7=vista), y is unknown
923 * Geforce2MX/3/4 up to 96.x - driver uses numbering 9.6.8.9 for 96.89
924 * TNT/Geforce1/2 up to 71.x - driver uses numbering 7.1.8.6 for 71.86
926 * All version numbers used below are from the Linux nvidia drivers. */
927 {VENDOR_NVIDIA
, CARD_NVIDIA_RIVA_TNT
, "NVIDIA RIVA TNT", 1, 8, 6 },
928 {VENDOR_NVIDIA
, CARD_NVIDIA_RIVA_TNT2
, "NVIDIA RIVA TNT2/TNT2 Pro", 1, 8, 6 },
929 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE
, "NVIDIA GeForce 256", 1, 8, 6 },
930 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE2_MX
, "NVIDIA GeForce2 MX/MX 400", 6, 4, 3 },
931 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE2
, "NVIDIA GeForce2 GTS/GeForce2 Pro", 1, 8, 6 },
932 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE3
, "NVIDIA GeForce3", 6, 10, 9371 },
933 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE4_MX
, "NVIDIA GeForce4 MX 460", 6, 10, 9371 },
934 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE4_TI4200
, "NVIDIA GeForce4 Ti 4200", 6, 10, 9371 },
935 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5200
, "NVIDIA GeForce FX 5200", 15, 11, 7516 },
936 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5600
, "NVIDIA GeForce FX 5600", 15, 11, 7516 },
937 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5800
, "NVIDIA GeForce FX 5800", 15, 11, 7516 },
938 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6200
, "NVIDIA GeForce 6200", 15, 11, 8618 },
939 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6600GT
, "NVIDIA GeForce 6600 GT", 15, 11, 8618 },
940 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6800
, "NVIDIA GeForce 6800", 15, 11, 8618 },
941 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7300
, "NVIDIA GeForce Go 7300", 15, 11, 8585 },
942 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7400
, "NVIDIA GeForce Go 7400", 15, 11, 8585 },
943 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7600
, "NVIDIA GeForce 7600 GT", 15, 11, 8618 },
944 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7800GT
, "NVIDIA GeForce 7800 GT", 15, 11, 8618 },
945 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8300GS
, "NVIDIA GeForce 8300 GS", 15, 11, 8618 },
946 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600GT
, "NVIDIA GeForce 8600 GT", 15, 11, 8618 },
947 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600MGT
, "NVIDIA GeForce 8600M GT", 15, 11, 8585 },
948 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8800GTS
, "NVIDIA GeForce 8800 GTS", 15, 11, 8618 },
949 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9200
, "NVIDIA GeForce 9200", 15, 11, 8618 },
950 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9400GT
, "NVIDIA GeForce 9400 GT", 15, 11, 8618 },
951 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9500GT
, "NVIDIA GeForce 9500 GT", 15, 11, 8618 },
952 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9600GT
, "NVIDIA GeForce 9600 GT", 15, 11, 8618 },
953 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9800GT
, "NVIDIA GeForce 9800 GT", 15, 11, 8618 },
954 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GTX260
, "NVIDIA GeForce GTX 260", 15, 11, 8618 },
955 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GTX275
, "NVIDIA GeForce GTX 275", 15, 11, 8618 },
956 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GTX280
, "NVIDIA GeForce GTX 280", 15, 11, 8618 },
957 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GT240
, "NVIDIA GeForce GT 240", 15, 11, 8618 },
959 /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode. */
960 {VENDOR_ATI
, CARD_ATI_RADEON_9500
, "ATI Radeon 9500", 14, 10, 6764 },
961 {VENDOR_ATI
, CARD_ATI_RADEON_X700
, "ATI Radeon X700 SE", 14, 10, 6764 },
962 {VENDOR_ATI
, CARD_ATI_RADEON_X1600
, "ATI Radeon X1600 Series", 14, 10, 6764 },
963 {VENDOR_ATI
, CARD_ATI_RADEON_HD2300
, "ATI Mobility Radeon HD 2300", 14, 10, 6764 },
964 {VENDOR_ATI
, CARD_ATI_RADEON_HD2600
, "ATI Mobility Radeon HD 2600", 14, 10, 6764 },
965 {VENDOR_ATI
, CARD_ATI_RADEON_HD2900
, "ATI Radeon HD 2900 XT", 14, 10, 6764 },
966 {VENDOR_ATI
, CARD_ATI_RADEON_HD4350
, "ATI Radeon HD 4350", 14, 10, 6764 },
967 {VENDOR_ATI
, CARD_ATI_RADEON_HD4600
, "ATI Radeon HD 4600 Series", 14, 10, 6764 },
968 {VENDOR_ATI
, CARD_ATI_RADEON_HD4700
, "ATI Radeon HD 4700 Series", 14, 10, 6764 },
969 {VENDOR_ATI
, CARD_ATI_RADEON_HD4800
, "ATI Radeon HD 4800 Series", 14, 10, 6764 },
970 {VENDOR_ATI
, CARD_ATI_RADEON_HD5700
, "ATI Radeon HD 5700 Series", 14, 10, 8681 },
971 {VENDOR_ATI
, CARD_ATI_RADEON_HD5800
, "ATI Radeon HD 5800 Series", 14, 10, 8681 },
973 /* TODO: Add information about legacy ATI hardware, Intel and other cards. */
976 static void init_driver_info(struct wined3d_driver_info
*driver_info
,
977 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
979 OSVERSIONINFOW os_version
;
980 WORD driver_os_version
;
983 if (wined3d_settings
.pci_vendor_id
!= PCI_VENDOR_NONE
)
985 TRACE_(d3d_caps
)("Overriding PCI vendor ID with: %04x\n", wined3d_settings
.pci_vendor_id
);
986 vendor
= wined3d_settings
.pci_vendor_id
;
988 driver_info
->vendor
= vendor
;
990 if (wined3d_settings
.pci_device_id
!= PCI_DEVICE_NONE
)
992 TRACE_(d3d_caps
)("Overriding PCI device ID with: %04x\n", wined3d_settings
.pci_device_id
);
993 device
= wined3d_settings
.pci_device_id
;
995 driver_info
->device
= device
;
1000 driver_info
->name
= "ati2dvag.dll";
1004 driver_info
->name
= "nv4_disp.dll";
1008 FIXME_(d3d_caps
)("Unhandled vendor %04x.\n", vendor
);
1009 driver_info
->name
= "Display";
1013 memset(&os_version
, 0, sizeof(os_version
));
1014 os_version
.dwOSVersionInfoSize
= sizeof(os_version
);
1015 if (!GetVersionExW(&os_version
))
1017 ERR("Failed to get OS version, reporting 2000/XP.\n");
1018 driver_os_version
= 6;
1022 TRACE("OS version %u.%u.\n", os_version
.dwMajorVersion
, os_version
.dwMinorVersion
);
1023 switch (os_version
.dwMajorVersion
)
1026 driver_os_version
= 4;
1030 driver_os_version
= 6;
1034 if (os_version
.dwMinorVersion
== 0)
1036 driver_os_version
= 7;
1040 if (os_version
.dwMinorVersion
> 1)
1042 FIXME("Unhandled OS version %u.%u, reporting Win 7.\n",
1043 os_version
.dwMajorVersion
, os_version
.dwMinorVersion
);
1045 driver_os_version
= 8;
1050 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
1051 os_version
.dwMajorVersion
, os_version
.dwMinorVersion
);
1052 driver_os_version
= 6;
1057 driver_info
->description
= "Direct3D HAL";
1058 driver_info
->version_high
= MAKEDWORD_VERSION(driver_os_version
, 15);
1059 driver_info
->version_low
= MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
1061 for (i
= 0; i
< (sizeof(driver_version_table
) / sizeof(driver_version_table
[0])); ++i
)
1063 if (vendor
== driver_version_table
[i
].vendor
&& device
== driver_version_table
[i
].card
)
1065 TRACE_(d3d_caps
)("Found card %04x:%04x in driver DB.\n", vendor
, device
);
1067 driver_info
->description
= driver_version_table
[i
].description
;
1068 driver_info
->version_high
= MAKEDWORD_VERSION(driver_os_version
, driver_version_table
[i
].d3d_level
);
1069 driver_info
->version_low
= MAKEDWORD_VERSION(driver_version_table
[i
].lopart_hi
,
1070 driver_version_table
[i
].lopart_lo
);
1075 TRACE_(d3d_caps
)("Reporting (fake) driver version 0x%08x-0x%08x.\n",
1076 driver_info
->version_high
, driver_info
->version_low
);
1079 /* Context activation is done by the caller. */
1080 static void fixup_extensions(struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
1081 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
1085 for (i
= 0; i
< (sizeof(quirk_table
) / sizeof(*quirk_table
)); ++i
)
1087 if (!quirk_table
[i
].match(gl_info
, gl_renderer
, vendor
, device
)) continue;
1088 TRACE_(d3d_caps
)("Applying driver quirk \"%s\".\n", quirk_table
[i
].description
);
1089 quirk_table
[i
].apply(gl_info
);
1092 /* Find out if PBOs work as they are supposed to. */
1093 test_pbo_functionality(gl_info
);
1096 static DWORD
wined3d_parse_gl_version(const char *gl_version
)
1098 const char *ptr
= gl_version
;
1102 if (major
<= 0) ERR_(d3d_caps
)("Invalid opengl major version: %d.\n", major
);
1104 while (isdigit(*ptr
)) ++ptr
;
1105 if (*ptr
++ != '.') ERR_(d3d_caps
)("Invalid opengl version string: %s.\n", debugstr_a(gl_version
));
1109 TRACE_(d3d_caps
)("Found OpenGL version: %d.%d.\n", major
, minor
);
1111 return MAKEDWORD_VERSION(major
, minor
);
1114 static enum wined3d_pci_vendor
wined3d_guess_vendor(const char *gl_vendor
, const char *gl_renderer
)
1116 if (strstr(gl_vendor
, "NVIDIA"))
1117 return VENDOR_NVIDIA
;
1119 if (strstr(gl_vendor
, "ATI"))
1122 if (strstr(gl_vendor
, "Intel(R)")
1123 || strstr(gl_renderer
, "Intel(R)")
1124 || strstr(gl_vendor
, "Intel Inc."))
1125 return VENDOR_INTEL
;
1127 if (strstr(gl_vendor
, "Mesa")
1128 || strstr(gl_vendor
, "Advanced Micro Devices, Inc.")
1129 || strstr(gl_vendor
, "DRI R300 Project")
1130 || strstr(gl_vendor
, "Tungsten Graphics, Inc")
1131 || strstr(gl_vendor
, "VMware, Inc."))
1134 FIXME_(d3d_caps
)("Received unrecognized GL_VENDOR %s. Returning VENDOR_WINE.\n", debugstr_a(gl_vendor
));
1139 static enum wined3d_pci_device
wined3d_guess_card(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
1140 enum wined3d_pci_vendor
*vendor
, unsigned int *vidmem
)
1142 /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of
1143 * different GPUs with roughly the same features. In most cases GPUs from a
1144 * certain family differ in clockspeeds, the amount of video memory and the
1145 * number of shader pipelines.
1147 * A Direct3D device object contains the PCI id (vendor + device) of the
1148 * videocard which is used for rendering. Various applications use this
1149 * information to get a rough estimation of the features of the card and
1150 * some might use it for enabling 3d effects only on certain types of
1151 * videocards. In some cases games might even use it to work around bugs
1152 * which happen on certain videocards/driver combinations. The problem is
1153 * that OpenGL only exposes a rendering string containing the name of the
1154 * videocard and not the PCI id.
1156 * Various games depend on the PCI id, so somehow we need to provide one.
1157 * A simple option is to parse the renderer string and translate this to
1158 * the right PCI id. This is a lot of work because there are more than 200
1159 * GPUs just for Nvidia. Various cards share the same renderer string, so
1160 * the amount of code might be 'small' but there are quite a number of
1161 * exceptions which would make this a pain to maintain. Another way would
1162 * be to query the PCI id from the operating system (assuming this is the
1163 * videocard which is used for rendering which is not always the case).
1164 * This would work but it is not very portable. Second it would not work
1165 * well in, let's say, a remote X situation in which the amount of 3d
1166 * features which can be used is limited.
1168 * As said most games only use the PCI id to get an indication of the
1169 * capabilities of the card. It doesn't really matter if the given id is
1170 * the correct one if we return the id of a card with similar 3d features.
1172 * The code below checks the OpenGL capabilities of a videocard and matches
1173 * that to a certain level of Direct3D functionality. Once a card passes
1174 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
1175 * least a GeforceFX. To give a better estimate we do a basic check on the
1176 * renderer string but if that won't pass we return a default card. This
1177 * way is better than maintaining a full card database as even without a
1178 * full database we can return a card with similar features. Second the
1179 * size of the database can be made quite small because when you know what
1180 * type of 3d functionality a card has, you know to which GPU family the
1181 * GPU must belong. Because of this you only have to check a small part of
1182 * the renderer string to distinguishes between different models from that
1185 * The code also selects a default amount of video memory which we will
1186 * use for an estimation of the amount of free texture memory. In case of
1187 * real D3D the amount of texture memory includes video memory and system
1188 * memory (to be specific AGP memory or in case of PCIE TurboCache /
1189 * HyperMemory). We don't know how much system memory can be addressed by
1190 * the system but we can make a reasonable estimation about the amount of
1191 * video memory. If the value is slightly wrong it doesn't matter as we
1192 * didn't include AGP-like memory which makes the amount of addressable
1193 * memory higher and second OpenGL isn't that critical it moves to system
1194 * memory behind our backs if really needed. Note that the amount of video
1195 * memory can be overruled using a registry setting. */
1200 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1201 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1203 if (WINE_D3D9_CAPABLE(gl_info
) && gl_info
->supported
[NV_VERTEX_PROGRAM3
])
1205 /* Geforce 200 - highend */
1206 if (strstr(gl_renderer
, "GTX 280")
1207 || strstr(gl_renderer
, "GTX 285")
1208 || strstr(gl_renderer
, "GTX 295"))
1211 return CARD_NVIDIA_GEFORCE_GTX280
;
1214 /* Geforce 200 - midend high */
1215 if (strstr(gl_renderer
, "GTX 275"))
1218 return CARD_NVIDIA_GEFORCE_GTX275
;
1221 /* Geforce 200 - midend */
1222 if (strstr(gl_renderer
, "GTX 260"))
1225 return CARD_NVIDIA_GEFORCE_GTX260
;
1227 /* Geforce 200 - midend */
1228 if (strstr(gl_renderer
, "GT 240"))
1231 return CARD_NVIDIA_GEFORCE_GT240
;
1234 /* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
1235 if (strstr(gl_renderer
, "9800")
1236 || strstr(gl_renderer
, "GTS 150")
1237 || strstr(gl_renderer
, "GTS 250"))
1240 return CARD_NVIDIA_GEFORCE_9800GT
;
1243 /* Geforce9 - midend */
1244 if (strstr(gl_renderer
, "9600"))
1246 *vidmem
= 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1247 return CARD_NVIDIA_GEFORCE_9600GT
;
1250 /* Geforce9 - midend low / Geforce 200 - low */
1251 if (strstr(gl_renderer
, "9500")
1252 || strstr(gl_renderer
, "GT 120")
1253 || strstr(gl_renderer
, "GT 130"))
1255 *vidmem
= 256; /* The 9500GT has 256-1024MB */
1256 return CARD_NVIDIA_GEFORCE_9500GT
;
1259 /* Geforce9 - lowend */
1260 if (strstr(gl_renderer
, "9400"))
1262 *vidmem
= 256; /* The 9400GT has 256-1024MB */
1263 return CARD_NVIDIA_GEFORCE_9400GT
;
1266 /* Geforce9 - lowend low */
1267 if (strstr(gl_renderer
, "9100")
1268 || strstr(gl_renderer
, "9200")
1269 || strstr(gl_renderer
, "9300")
1270 || strstr(gl_renderer
, "G 100"))
1272 *vidmem
= 256; /* The 9100-9300 cards have 256MB */
1273 return CARD_NVIDIA_GEFORCE_9200
;
1276 /* Geforce8 - highend */
1277 if (strstr(gl_renderer
, "8800"))
1279 *vidmem
= 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1280 return CARD_NVIDIA_GEFORCE_8800GTS
;
1283 /* Geforce8 - midend mobile */
1284 if (strstr(gl_renderer
, "8600 M"))
1287 return CARD_NVIDIA_GEFORCE_8600MGT
;
1290 /* Geforce8 - midend */
1291 if (strstr(gl_renderer
, "8600")
1292 || strstr(gl_renderer
, "8700"))
1295 return CARD_NVIDIA_GEFORCE_8600GT
;
1298 /* Geforce8 - lowend */
1299 if (strstr(gl_renderer
, "8100")
1300 || strstr(gl_renderer
, "8200")
1301 || strstr(gl_renderer
, "8300")
1302 || strstr(gl_renderer
, "8400")
1303 || strstr(gl_renderer
, "8500"))
1305 *vidmem
= 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1306 return CARD_NVIDIA_GEFORCE_8300GS
;
1309 /* Geforce7 - highend */
1310 if (strstr(gl_renderer
, "7800")
1311 || strstr(gl_renderer
, "7900")
1312 || strstr(gl_renderer
, "7950")
1313 || strstr(gl_renderer
, "Quadro FX 4")
1314 || strstr(gl_renderer
, "Quadro FX 5"))
1316 *vidmem
= 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1317 return CARD_NVIDIA_GEFORCE_7800GT
;
1320 /* Geforce7 midend */
1321 if (strstr(gl_renderer
, "7600")
1322 || strstr(gl_renderer
, "7700"))
1324 *vidmem
= 256; /* The 7600 uses 256-512MB */
1325 return CARD_NVIDIA_GEFORCE_7600
;
1328 /* Geforce7 lower medium */
1329 if (strstr(gl_renderer
, "7400"))
1331 *vidmem
= 256; /* The 7400 uses 256-512MB */
1332 return CARD_NVIDIA_GEFORCE_7400
;
1335 /* Geforce7 lowend */
1336 if (strstr(gl_renderer
, "7300"))
1338 *vidmem
= 256; /* Mac Pros with this card have 256 MB */
1339 return CARD_NVIDIA_GEFORCE_7300
;
1342 /* Geforce6 highend */
1343 if (strstr(gl_renderer
, "6800"))
1345 *vidmem
= 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1346 return CARD_NVIDIA_GEFORCE_6800
;
1349 /* Geforce6 - midend */
1350 if (strstr(gl_renderer
, "6600")
1351 || strstr(gl_renderer
, "6610")
1352 || strstr(gl_renderer
, "6700"))
1354 *vidmem
= 128; /* A 6600GT has 128-256MB */
1355 return CARD_NVIDIA_GEFORCE_6600GT
;
1358 /* Geforce6/7 lowend */
1360 return CARD_NVIDIA_GEFORCE_6200
; /* Geforce 6100/6150/6200/7300/7400/7500 */
1363 if (WINE_D3D9_CAPABLE(gl_info
))
1365 /* GeforceFX - highend */
1366 if (strstr(gl_renderer
, "5800")
1367 || strstr(gl_renderer
, "5900")
1368 || strstr(gl_renderer
, "5950")
1369 || strstr(gl_renderer
, "Quadro FX"))
1371 *vidmem
= 256; /* 5800-5900 cards use 256MB */
1372 return CARD_NVIDIA_GEFORCEFX_5800
;
1375 /* GeforceFX - midend */
1376 if (strstr(gl_renderer
, "5600")
1377 || strstr(gl_renderer
, "5650")
1378 || strstr(gl_renderer
, "5700")
1379 || strstr(gl_renderer
, "5750"))
1381 *vidmem
= 128; /* A 5600 uses 128-256MB */
1382 return CARD_NVIDIA_GEFORCEFX_5600
;
1385 /* GeforceFX - lowend */
1386 *vidmem
= 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1387 return CARD_NVIDIA_GEFORCEFX_5200
; /* GeforceFX 5100/5200/5250/5300/5500 */
1390 if (WINE_D3D8_CAPABLE(gl_info
))
1392 if (strstr(gl_renderer
, "GeForce4 Ti") || strstr(gl_renderer
, "Quadro4"))
1394 *vidmem
= 64; /* Geforce4 Ti cards have 64-128MB */
1395 return CARD_NVIDIA_GEFORCE4_TI4200
; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1398 *vidmem
= 64; /* Geforce3 cards have 64-128MB */
1399 return CARD_NVIDIA_GEFORCE3
; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1402 if (WINE_D3D7_CAPABLE(gl_info
))
1404 if (strstr(gl_renderer
, "GeForce4 MX"))
1406 /* Most Geforce4MX GPUs have at least 64MB of memory, some
1407 * early models had 32MB but most have 64MB or even 128MB. */
1409 return CARD_NVIDIA_GEFORCE4_MX
; /* MX420/MX440/MX460/MX4000 */
1412 if (strstr(gl_renderer
, "GeForce2 MX") || strstr(gl_renderer
, "Quadro2 MXR"))
1414 *vidmem
= 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1415 return CARD_NVIDIA_GEFORCE2_MX
; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1418 if (strstr(gl_renderer
, "GeForce2") || strstr(gl_renderer
, "Quadro2"))
1420 *vidmem
= 32; /* Geforce2 GPUs have 32-64MB of video memory */
1421 return CARD_NVIDIA_GEFORCE2
; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1424 /* Most Geforce1 cards have 32MB, there are also some rare 16
1425 * and 64MB (Dell) models. */
1427 return CARD_NVIDIA_GEFORCE
; /* Geforce 256/DDR, Quadro */
1430 if (strstr(gl_renderer
, "TNT2"))
1432 *vidmem
= 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1433 return CARD_NVIDIA_RIVA_TNT2
; /* Riva TNT2 standard/M64/Pro/Ultra */
1436 *vidmem
= 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1437 return CARD_NVIDIA_RIVA_TNT
; /* Riva TNT, Vanta */
1440 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1442 * Beware: renderer string do not match exact card model,
1443 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1444 if (WINE_D3D9_CAPABLE(gl_info
))
1446 /* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1447 if (strstr(gl_renderer
, "HD 5800") /* Radeon EG CYPRESS HD58xx generic renderer string */
1448 || strstr(gl_renderer
, "HD 5850") /* Radeon EG CYPRESS XT */
1449 || strstr(gl_renderer
, "HD 5870")) /* Radeon EG CYPRESS PRO */
1451 *vidmem
= 1024; /* note: HD58xx cards use 1024MB */
1452 return CARD_ATI_RADEON_HD5800
;
1455 /* Radeon EG JUNIPER XT / LE HD5700 - midend */
1456 if (strstr(gl_renderer
, "HD 5700") /* Radeon EG JUNIPER HD57xx generic renderer string */
1457 || strstr(gl_renderer
, "HD 5750") /* Radeon EG JUNIPER LE */
1458 || strstr(gl_renderer
, "HD 5770")) /* Radeon EG JUNIPER XT */
1460 *vidmem
= 512; /* note: HD5770 cards use 1024MB and HD5750 cards use 512MB or 1024MB */
1461 return CARD_ATI_RADEON_HD5700
;
1464 /* Radeon R7xx HD4800 - highend */
1465 if (strstr(gl_renderer
, "HD 4800") /* Radeon RV7xx HD48xx generic renderer string */
1466 || strstr(gl_renderer
, "HD 4830") /* Radeon RV770 */
1467 || strstr(gl_renderer
, "HD 4850") /* Radeon RV770 */
1468 || strstr(gl_renderer
, "HD 4870") /* Radeon RV770 */
1469 || strstr(gl_renderer
, "HD 4890")) /* Radeon RV790 */
1471 *vidmem
= 512; /* note: HD4890 cards use 1024MB */
1472 return CARD_ATI_RADEON_HD4800
;
1475 /* Radeon R740 HD4700 - midend */
1476 if (strstr(gl_renderer
, "HD 4700") /* Radeon RV770 */
1477 || strstr(gl_renderer
, "HD 4770")) /* Radeon RV740 */
1480 return CARD_ATI_RADEON_HD4700
;
1483 /* Radeon R730 HD4600 - midend */
1484 if (strstr(gl_renderer
, "HD 4600") /* Radeon RV730 */
1485 || strstr(gl_renderer
, "HD 4650") /* Radeon RV730 */
1486 || strstr(gl_renderer
, "HD 4670")) /* Radeon RV730 */
1489 return CARD_ATI_RADEON_HD4600
;
1492 /* Radeon R710 HD4500/HD4350 - lowend */
1493 if (strstr(gl_renderer
, "HD 4350") /* Radeon RV710 */
1494 || strstr(gl_renderer
, "HD 4550")) /* Radeon RV710 */
1497 return CARD_ATI_RADEON_HD4350
;
1500 /* Radeon R6xx HD2900/HD3800 - highend */
1501 if (strstr(gl_renderer
, "HD 2900")
1502 || strstr(gl_renderer
, "HD 3870")
1503 || strstr(gl_renderer
, "HD 3850"))
1505 *vidmem
= 512; /* HD2900/HD3800 uses 256-1024MB */
1506 return CARD_ATI_RADEON_HD2900
;
1509 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1510 if (strstr(gl_renderer
, "HD 2600")
1511 || strstr(gl_renderer
, "HD 3830")
1512 || strstr(gl_renderer
, "HD 3690")
1513 || strstr(gl_renderer
, "HD 3650"))
1515 *vidmem
= 256; /* HD2600/HD3600 uses 256-512MB */
1516 return CARD_ATI_RADEON_HD2600
;
1519 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1520 if (strstr(gl_renderer
, "HD 2300")
1521 || strstr(gl_renderer
, "HD 2400")
1522 || strstr(gl_renderer
, "HD 3470")
1523 || strstr(gl_renderer
, "HD 3450")
1524 || strstr(gl_renderer
, "HD 3430")
1525 || strstr(gl_renderer
, "HD 3400"))
1527 *vidmem
= 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1528 return CARD_ATI_RADEON_HD2300
;
1531 /* Radeon R6xx/R7xx integrated */
1532 if (strstr(gl_renderer
, "HD 3100")
1533 || strstr(gl_renderer
, "HD 3200")
1534 || strstr(gl_renderer
, "HD 3300"))
1536 *vidmem
= 128; /* 128MB */
1537 return CARD_ATI_RADEON_HD3200
;
1541 if (strstr(gl_renderer
, "X1600")
1542 || strstr(gl_renderer
, "X1650")
1543 || strstr(gl_renderer
, "X1800")
1544 || strstr(gl_renderer
, "X1900")
1545 || strstr(gl_renderer
, "X1950"))
1547 *vidmem
= 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1548 return CARD_ATI_RADEON_X1600
;
1551 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1552 if (strstr(gl_renderer
, "X700")
1553 || strstr(gl_renderer
, "X800")
1554 || strstr(gl_renderer
, "X850")
1555 || strstr(gl_renderer
, "X1300")
1556 || strstr(gl_renderer
, "X1400")
1557 || strstr(gl_renderer
, "X1450")
1558 || strstr(gl_renderer
, "X1550"))
1560 *vidmem
= 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1561 return CARD_ATI_RADEON_X700
;
1564 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1565 if (strstr(gl_renderer
, "Radeon Xpress"))
1567 *vidmem
= 64; /* Shared RAM, BIOS configurable, 64-256M */
1568 return CARD_ATI_RADEON_XPRESS_200M
;
1572 *vidmem
= 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1573 return CARD_ATI_RADEON_9500
; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1576 if (WINE_D3D8_CAPABLE(gl_info
))
1578 *vidmem
= 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1579 return CARD_ATI_RADEON_8500
; /* Radeon 8500/9000/9100/9200/9300 */
1582 if (WINE_D3D7_CAPABLE(gl_info
))
1584 *vidmem
= 32; /* There are models with up to 64MB */
1585 return CARD_ATI_RADEON_7200
; /* Radeon 7000/7100/7200/7500 */
1588 *vidmem
= 16; /* There are 16-32MB models */
1589 return CARD_ATI_RAGE_128PRO
;
1592 if (strstr(gl_renderer
, "X3100"))
1594 /* MacOS calls the card GMA X3100, Google findings also suggest the name GM965 */
1596 return CARD_INTEL_X3100
;
1599 if (strstr(gl_renderer
, "GMA 950") || strstr(gl_renderer
, "945GM"))
1601 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1603 return CARD_INTEL_I945GM
;
1606 if (strstr(gl_renderer
, "915GM")) return CARD_INTEL_I915GM
;
1607 if (strstr(gl_renderer
, "915G")) return CARD_INTEL_I915G
;
1608 if (strstr(gl_renderer
, "865G")) return CARD_INTEL_I865G
;
1609 if (strstr(gl_renderer
, "855G")) return CARD_INTEL_I855G
;
1610 if (strstr(gl_renderer
, "830G")) return CARD_INTEL_I830G
;
1611 return CARD_INTEL_I915G
;
1616 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1617 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1618 * them a good generic choice. */
1619 *vendor
= VENDOR_NVIDIA
;
1620 if (WINE_D3D9_CAPABLE(gl_info
)) return CARD_NVIDIA_GEFORCEFX_5600
;
1621 if (WINE_D3D8_CAPABLE(gl_info
)) return CARD_NVIDIA_GEFORCE3
;
1622 if (WINE_D3D7_CAPABLE(gl_info
)) return CARD_NVIDIA_GEFORCE
;
1623 if (WINE_D3D6_CAPABLE(gl_info
)) return CARD_NVIDIA_RIVA_TNT
;
1624 return CARD_NVIDIA_RIVA_128
;
1628 static const struct fragment_pipeline
*select_fragment_implementation(struct wined3d_adapter
*adapter
)
1630 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
1631 int vs_selected_mode
, ps_selected_mode
;
1633 select_shader_mode(gl_info
, &ps_selected_mode
, &vs_selected_mode
);
1634 if ((ps_selected_mode
== SHADER_ARB
|| ps_selected_mode
== SHADER_GLSL
)
1635 && gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) return &arbfp_fragment_pipeline
;
1636 else if (ps_selected_mode
== SHADER_ATI
) return &atifs_fragment_pipeline
;
1637 else if (gl_info
->supported
[NV_REGISTER_COMBINERS
]
1638 && gl_info
->supported
[NV_TEXTURE_SHADER2
]) return &nvts_fragment_pipeline
;
1639 else if (gl_info
->supported
[NV_REGISTER_COMBINERS
]) return &nvrc_fragment_pipeline
;
1640 else return &ffp_fragment_pipeline
;
1643 static const shader_backend_t
*select_shader_backend(struct wined3d_adapter
*adapter
)
1645 int vs_selected_mode
, ps_selected_mode
;
1647 select_shader_mode(&adapter
->gl_info
, &ps_selected_mode
, &vs_selected_mode
);
1648 if (vs_selected_mode
== SHADER_GLSL
|| ps_selected_mode
== SHADER_GLSL
) return &glsl_shader_backend
;
1649 if (vs_selected_mode
== SHADER_ARB
|| ps_selected_mode
== SHADER_ARB
) return &arb_program_shader_backend
;
1650 return &none_shader_backend
;
1653 static const struct blit_shader
*select_blit_implementation(struct wined3d_adapter
*adapter
)
1655 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
1656 int vs_selected_mode
, ps_selected_mode
;
1658 select_shader_mode(gl_info
, &ps_selected_mode
, &vs_selected_mode
);
1659 if ((ps_selected_mode
== SHADER_ARB
|| ps_selected_mode
== SHADER_GLSL
)
1660 && gl_info
->supported
[ARB_FRAGMENT_PROGRAM
]) return &arbfp_blit
;
1661 else return &ffp_blit
;
1664 /* Context activation is done by the caller. */
1665 static BOOL
IWineD3DImpl_FillGLCaps(struct wined3d_adapter
*adapter
)
1667 struct wined3d_driver_info
*driver_info
= &adapter
->driver_info
;
1668 struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
1669 const char *GL_Extensions
= NULL
;
1670 const char *WGL_Extensions
= NULL
;
1671 const char *gl_string
= NULL
;
1672 struct fragment_caps fragment_caps
;
1673 enum wined3d_pci_vendor vendor
;
1674 enum wined3d_pci_device device
;
1676 GLfloat gl_floatv
[2];
1679 unsigned int vidmem
=0;
1684 TRACE_(d3d_caps
)("(%p)\n", gl_info
);
1688 gl_string
= (const char *)glGetString(GL_RENDERER
);
1689 TRACE_(d3d_caps
)("GL_RENDERER: %s.\n", debugstr_a(gl_string
));
1693 ERR_(d3d_caps
)("Received a NULL GL_RENDERER.\n");
1697 len
= strlen(gl_string
) + 1;
1698 gl_renderer
= HeapAlloc(GetProcessHeap(), 0, len
);
1702 ERR_(d3d_caps
)("Failed to allocate gl_renderer memory.\n");
1705 memcpy(gl_renderer
, gl_string
, len
);
1707 gl_string
= (const char *)glGetString(GL_VENDOR
);
1708 TRACE_(d3d_caps
)("GL_VENDOR: %s.\n", debugstr_a(gl_string
));
1712 ERR_(d3d_caps
)("Received a NULL GL_VENDOR.\n");
1713 HeapFree(GetProcessHeap(), 0, gl_renderer
);
1716 vendor
= wined3d_guess_vendor(gl_string
, gl_renderer
);
1717 TRACE_(d3d_caps
)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string
), vendor
);
1719 /* Parse the GL_VERSION field into major and minor information */
1720 gl_string
= (const char *)glGetString(GL_VERSION
);
1721 TRACE_(d3d_caps
)("GL_VERSION: %s.\n", debugstr_a(gl_string
));
1725 ERR_(d3d_caps
)("Received a NULL GL_VERSION.\n");
1726 HeapFree(GetProcessHeap(), 0, gl_renderer
);
1729 gl_version
= wined3d_parse_gl_version(gl_string
);
1732 * Initialize openGL extension related variables
1733 * with Default values
1735 memset(gl_info
->supported
, 0, sizeof(gl_info
->supported
));
1736 gl_info
->limits
.buffers
= 1;
1737 gl_info
->limits
.textures
= 1;
1738 gl_info
->limits
.fragment_samplers
= 1;
1739 gl_info
->limits
.vertex_samplers
= 0;
1740 gl_info
->limits
.combined_samplers
= gl_info
->limits
.fragment_samplers
+ gl_info
->limits
.vertex_samplers
;
1741 gl_info
->limits
.sampler_stages
= 1;
1742 gl_info
->limits
.glsl_vs_float_constants
= 0;
1743 gl_info
->limits
.glsl_ps_float_constants
= 0;
1744 gl_info
->limits
.arb_vs_float_constants
= 0;
1745 gl_info
->limits
.arb_vs_native_constants
= 0;
1746 gl_info
->limits
.arb_vs_instructions
= 0;
1747 gl_info
->limits
.arb_vs_temps
= 0;
1748 gl_info
->limits
.arb_ps_float_constants
= 0;
1749 gl_info
->limits
.arb_ps_local_constants
= 0;
1750 gl_info
->limits
.arb_ps_instructions
= 0;
1751 gl_info
->limits
.arb_ps_temps
= 0;
1753 /* Retrieve opengl defaults */
1754 glGetIntegerv(GL_MAX_CLIP_PLANES
, &gl_max
);
1755 gl_info
->limits
.clipplanes
= min(WINED3DMAXUSERCLIPPLANES
, gl_max
);
1756 TRACE_(d3d_caps
)("ClipPlanes support - num Planes=%d\n", gl_max
);
1758 glGetIntegerv(GL_MAX_LIGHTS
, &gl_max
);
1759 gl_info
->limits
.lights
= gl_max
;
1760 TRACE_(d3d_caps
)("Lights support - max lights=%d\n", gl_max
);
1762 glGetIntegerv(GL_MAX_TEXTURE_SIZE
, &gl_max
);
1763 gl_info
->limits
.texture_size
= gl_max
;
1764 TRACE_(d3d_caps
)("Maximum texture size support - max texture size=%d\n", gl_max
);
1766 glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE
, gl_floatv
);
1767 gl_info
->limits
.pointsize_min
= gl_floatv
[0];
1768 gl_info
->limits
.pointsize_max
= gl_floatv
[1];
1769 TRACE_(d3d_caps
)("Maximum point size support - max point size=%f\n", gl_floatv
[1]);
1771 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
1772 GL_Extensions
= (const char *)glGetString(GL_EXTENSIONS
);
1776 ERR_(d3d_caps
)("Received a NULL GL_EXTENSIONS.\n");
1777 HeapFree(GetProcessHeap(), 0, gl_renderer
);
1783 TRACE_(d3d_caps
)("GL_Extensions reported:\n");
1785 gl_info
->supported
[WINED3D_GL_EXT_NONE
] = TRUE
;
1787 while (*GL_Extensions
)
1790 char current_ext
[256];
1792 while (isspace(*GL_Extensions
)) ++GL_Extensions
;
1793 start
= GL_Extensions
;
1794 while (!isspace(*GL_Extensions
) && *GL_Extensions
) ++GL_Extensions
;
1796 len
= GL_Extensions
- start
;
1797 if (!len
|| len
>= sizeof(current_ext
)) continue;
1799 memcpy(current_ext
, start
, len
);
1800 current_ext
[len
] = '\0';
1801 TRACE_(d3d_caps
)("- %s\n", debugstr_a(current_ext
));
1803 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
)
1805 if (!strcmp(current_ext
, EXTENSION_MAP
[i
].extension_string
))
1807 TRACE_(d3d_caps
)(" FOUND: %s support.\n", EXTENSION_MAP
[i
].extension_string
);
1808 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
1814 /* Now work out what GL support this card really has */
1815 #define USE_GL_FUNC(type, pfn, ext, replace) \
1817 DWORD ver = ver_for_ext(ext); \
1818 if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
1819 else if (ver && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
1820 else gl_info->pfn = NULL; \
1825 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
1831 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
1832 * loading the functions, otherwise the code above will load the extension entry points instead of the
1833 * core functions, which may not work. */
1834 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
)
1836 if (!gl_info
->supported
[EXTENSION_MAP
[i
].extension
]
1837 && EXTENSION_MAP
[i
].version
<= gl_version
&& EXTENSION_MAP
[i
].version
)
1839 TRACE_(d3d_caps
)(" GL CORE: %s support.\n", EXTENSION_MAP
[i
].extension_string
);
1840 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
1844 if (gl_info
->supported
[APPLE_FENCE
])
1846 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
1847 * The apple extension interacts with some other apple exts. Disable the NV
1848 * extension if the apple one is support to prevent confusion in other parts
1850 gl_info
->supported
[NV_FENCE
] = FALSE
;
1852 if (gl_info
->supported
[APPLE_FLOAT_PIXELS
])
1854 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
1856 * The enums are the same:
1857 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
1858 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
1859 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
1860 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
1861 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
1863 if (!gl_info
->supported
[ARB_TEXTURE_FLOAT
])
1865 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
1866 gl_info
->supported
[ARB_TEXTURE_FLOAT
] = TRUE
;
1868 if (!gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
])
1870 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
1871 gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
] = TRUE
;
1874 if (gl_info
->supported
[ARB_MAP_BUFFER_RANGE
])
1876 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
1877 * functionality. Prefer the ARB extension */
1878 gl_info
->supported
[APPLE_FLUSH_BUFFER_RANGE
] = FALSE
;
1880 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
1882 TRACE_(d3d_caps
)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
1883 gl_info
->supported
[NV_TEXGEN_REFLECTION
] = TRUE
;
1885 if (!gl_info
->supported
[ARB_DEPTH_CLAMP
] && gl_info
->supported
[NV_DEPTH_CLAMP
])
1887 TRACE_(d3d_caps
)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
1888 gl_info
->supported
[ARB_DEPTH_CLAMP
] = TRUE
;
1890 if (!gl_info
->supported
[ARB_VERTEX_ARRAY_BGRA
] && gl_info
->supported
[EXT_VERTEX_ARRAY_BGRA
])
1892 TRACE_(d3d_caps
)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
1893 gl_info
->supported
[ARB_VERTEX_ARRAY_BGRA
] = TRUE
;
1895 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
1897 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
1899 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
1900 * are supported. The nv extensions provide the same functionality as the
1901 * ATI one, and a bit more(signed pixelformats). */
1902 gl_info
->supported
[ATI_FRAGMENT_SHADER
] = FALSE
;
1906 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
1908 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV
, &gl_max
);
1909 gl_info
->limits
.general_combiners
= gl_max
;
1910 TRACE_(d3d_caps
)("Max general combiners: %d.\n", gl_max
);
1912 if (gl_info
->supported
[ARB_DRAW_BUFFERS
])
1914 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB
, &gl_max
);
1915 gl_info
->limits
.buffers
= gl_max
;
1916 TRACE_(d3d_caps
)("Max draw buffers: %u.\n", gl_max
);
1918 if (gl_info
->supported
[ARB_MULTITEXTURE
])
1920 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB
, &gl_max
);
1921 gl_info
->limits
.textures
= min(MAX_TEXTURES
, gl_max
);
1922 TRACE_(d3d_caps
)("Max textures: %d.\n", gl_info
->limits
.textures
);
1924 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
])
1927 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
1928 gl_info
->limits
.fragment_samplers
= min(MAX_FRAGMENT_SAMPLERS
, tmp
);
1932 gl_info
->limits
.fragment_samplers
= max(gl_info
->limits
.fragment_samplers
, gl_max
);
1934 TRACE_(d3d_caps
)("Max fragment samplers: %d.\n", gl_info
->limits
.fragment_samplers
);
1936 if (gl_info
->supported
[ARB_VERTEX_SHADER
])
1939 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
1940 gl_info
->limits
.vertex_samplers
= tmp
;
1941 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
1942 gl_info
->limits
.combined_samplers
= tmp
;
1944 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
1945 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
1946 * an issue because then the sampler setup only depends on the two shaders. If a pixel
1947 * shader is used with fixed function vertex processing we're fine too because fixed function
1948 * vertex processing doesn't use any samplers. If fixed function fragment processing is
1949 * used we have to make sure that all vertex sampler setups are valid together with all
1950 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
1951 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
1952 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
1953 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
1954 * a fixed function pipeline anymore.
1956 * So this is just a check to check that our assumption holds true. If not, write a warning
1957 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
1958 if (gl_info
->limits
.vertex_samplers
&& gl_info
->limits
.combined_samplers
< 12
1959 && MAX_TEXTURES
+ gl_info
->limits
.vertex_samplers
> gl_info
->limits
.combined_samplers
)
1961 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
1962 gl_info
->limits
.vertex_samplers
, gl_info
->limits
.combined_samplers
);
1963 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
1964 if (gl_info
->limits
.combined_samplers
> MAX_TEXTURES
)
1965 gl_info
->limits
.vertex_samplers
= gl_info
->limits
.combined_samplers
- MAX_TEXTURES
;
1967 gl_info
->limits
.vertex_samplers
= 0;
1972 gl_info
->limits
.combined_samplers
= gl_info
->limits
.fragment_samplers
;
1974 TRACE_(d3d_caps
)("Max vertex samplers: %u.\n", gl_info
->limits
.vertex_samplers
);
1975 TRACE_(d3d_caps
)("Max combined samplers: %u.\n", gl_info
->limits
.combined_samplers
);
1977 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
1979 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB
, &gl_max
);
1980 gl_info
->limits
.blends
= gl_max
;
1981 TRACE_(d3d_caps
)("Max blends: %u.\n", gl_info
->limits
.blends
);
1983 if (gl_info
->supported
[EXT_TEXTURE3D
])
1985 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT
, &gl_max
);
1986 gl_info
->limits
.texture3d_size
= gl_max
;
1987 TRACE_(d3d_caps
)("Max texture3D size: %d.\n", gl_info
->limits
.texture3d_size
);
1989 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
1991 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
, &gl_max
);
1992 gl_info
->limits
.anisotropy
= gl_max
;
1993 TRACE_(d3d_caps
)("Max anisotropy: %d.\n", gl_info
->limits
.anisotropy
);
1995 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
])
1997 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
1998 gl_info
->limits
.arb_ps_float_constants
= gl_max
;
1999 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info
->limits
.arb_ps_float_constants
);
2000 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
, &gl_max
));
2001 gl_info
->limits
.arb_ps_native_constants
= gl_max
;
2002 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
2003 gl_info
->limits
.arb_ps_native_constants
);
2004 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
2005 gl_info
->limits
.arb_ps_temps
= gl_max
;
2006 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info
->limits
.arb_ps_temps
);
2007 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
2008 gl_info
->limits
.arb_ps_instructions
= gl_max
;
2009 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info
->limits
.arb_ps_instructions
);
2010 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
, &gl_max
));
2011 gl_info
->limits
.arb_ps_local_constants
= gl_max
;
2012 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info
->limits
.arb_ps_instructions
);
2014 if (gl_info
->supported
[ARB_VERTEX_PROGRAM
])
2016 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
2017 gl_info
->limits
.arb_vs_float_constants
= gl_max
;
2018 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info
->limits
.arb_vs_float_constants
);
2019 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
, &gl_max
));
2020 gl_info
->limits
.arb_vs_native_constants
= gl_max
;
2021 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
2022 gl_info
->limits
.arb_vs_native_constants
);
2023 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
2024 gl_info
->limits
.arb_vs_temps
= gl_max
;
2025 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info
->limits
.arb_vs_temps
);
2026 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
2027 gl_info
->limits
.arb_vs_instructions
= gl_max
;
2028 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info
->limits
.arb_vs_instructions
);
2030 if (test_arb_vs_offset_limit(gl_info
)) gl_info
->quirks
|= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT
;
2032 if (gl_info
->supported
[ARB_VERTEX_SHADER
])
2034 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
, &gl_max
);
2035 gl_info
->limits
.glsl_vs_float_constants
= gl_max
/ 4;
2036 TRACE_(d3d_caps
)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info
->limits
.glsl_vs_float_constants
);
2038 if (gl_info
->supported
[ARB_FRAGMENT_SHADER
])
2040 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB
, &gl_max
);
2041 gl_info
->limits
.glsl_ps_float_constants
= gl_max
/ 4;
2042 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info
->limits
.glsl_ps_float_constants
);
2043 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB
, &gl_max
);
2044 gl_info
->limits
.glsl_varyings
= gl_max
;
2045 TRACE_(d3d_caps
)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max
, gl_max
/ 4);
2047 if (gl_info
->supported
[ARB_SHADING_LANGUAGE_100
])
2049 const char *str
= (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB
);
2050 TRACE_(d3d_caps
)("GLSL version string: %s.\n", debugstr_a(str
));
2052 if (gl_info
->supported
[NV_LIGHT_MAX_EXPONENT
])
2054 glGetFloatv(GL_MAX_SHININESS_NV
, &gl_info
->limits
.shininess
);
2058 gl_info
->limits
.shininess
= 128.0f
;
2060 if (gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
])
2062 /* If we have full NP2 texture support, disable
2063 * GL_ARB_texture_rectangle because we will never use it.
2064 * This saves a few redundant glDisable calls. */
2065 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = FALSE
;
2067 if (gl_info
->supported
[ATI_FRAGMENT_SHADER
])
2069 /* Disable NV_register_combiners and fragment shader if this is supported.
2070 * generally the NV extensions are preferred over the ATI ones, and this
2071 * extension is disabled if register_combiners and texture_shader2 are both
2072 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2073 * fragment processing support. */
2074 gl_info
->supported
[NV_REGISTER_COMBINERS
] = FALSE
;
2075 gl_info
->supported
[NV_REGISTER_COMBINERS2
] = FALSE
;
2076 gl_info
->supported
[NV_TEXTURE_SHADER
] = FALSE
;
2077 gl_info
->supported
[NV_TEXTURE_SHADER2
] = FALSE
;
2079 if (gl_info
->supported
[NV_HALF_FLOAT
])
2081 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2082 gl_info
->supported
[ARB_HALF_FLOAT_VERTEX
] = TRUE
;
2084 if (gl_info
->supported
[ARB_POINT_SPRITE
])
2086 gl_info
->limits
.point_sprite_units
= gl_info
->limits
.textures
;
2090 gl_info
->limits
.point_sprite_units
= 0;
2092 checkGLcall("extension detection");
2096 adapter
->fragment_pipe
= select_fragment_implementation(adapter
);
2097 adapter
->shader_backend
= select_shader_backend(adapter
);
2098 adapter
->blitter
= select_blit_implementation(adapter
);
2100 adapter
->fragment_pipe
->get_caps(gl_info
, &fragment_caps
);
2101 gl_info
->limits
.texture_stages
= fragment_caps
.MaxTextureBlendStages
;
2102 TRACE_(d3d_caps
)("Max texture stages: %u.\n", gl_info
->limits
.texture_stages
);
2104 /* In some cases the number of texture stages can be larger than the number
2105 * of samplers. The GF4 for example can use only 2 samplers (no fragment
2106 * shaders), but 8 texture stages (register combiners). */
2107 gl_info
->limits
.sampler_stages
= max(gl_info
->limits
.fragment_samplers
, gl_info
->limits
.texture_stages
);
2109 if (gl_info
->supported
[ARB_FRAMEBUFFER_OBJECT
])
2111 gl_info
->fbo_ops
.glIsRenderbuffer
= gl_info
->glIsRenderbuffer
;
2112 gl_info
->fbo_ops
.glBindRenderbuffer
= gl_info
->glBindRenderbuffer
;
2113 gl_info
->fbo_ops
.glDeleteRenderbuffers
= gl_info
->glDeleteRenderbuffers
;
2114 gl_info
->fbo_ops
.glGenRenderbuffers
= gl_info
->glGenRenderbuffers
;
2115 gl_info
->fbo_ops
.glRenderbufferStorage
= gl_info
->glRenderbufferStorage
;
2116 gl_info
->fbo_ops
.glRenderbufferStorageMultisample
= gl_info
->glRenderbufferStorageMultisample
;
2117 gl_info
->fbo_ops
.glGetRenderbufferParameteriv
= gl_info
->glGetRenderbufferParameteriv
;
2118 gl_info
->fbo_ops
.glIsFramebuffer
= gl_info
->glIsFramebuffer
;
2119 gl_info
->fbo_ops
.glBindFramebuffer
= gl_info
->glBindFramebuffer
;
2120 gl_info
->fbo_ops
.glDeleteFramebuffers
= gl_info
->glDeleteFramebuffers
;
2121 gl_info
->fbo_ops
.glGenFramebuffers
= gl_info
->glGenFramebuffers
;
2122 gl_info
->fbo_ops
.glCheckFramebufferStatus
= gl_info
->glCheckFramebufferStatus
;
2123 gl_info
->fbo_ops
.glFramebufferTexture1D
= gl_info
->glFramebufferTexture1D
;
2124 gl_info
->fbo_ops
.glFramebufferTexture2D
= gl_info
->glFramebufferTexture2D
;
2125 gl_info
->fbo_ops
.glFramebufferTexture3D
= gl_info
->glFramebufferTexture3D
;
2126 gl_info
->fbo_ops
.glFramebufferRenderbuffer
= gl_info
->glFramebufferRenderbuffer
;
2127 gl_info
->fbo_ops
.glGetFramebufferAttachmentParameteriv
= gl_info
->glGetFramebufferAttachmentParameteriv
;
2128 gl_info
->fbo_ops
.glBlitFramebuffer
= gl_info
->glBlitFramebuffer
;
2129 gl_info
->fbo_ops
.glGenerateMipmap
= gl_info
->glGenerateMipmap
;
2133 if (gl_info
->supported
[EXT_FRAMEBUFFER_OBJECT
])
2135 gl_info
->fbo_ops
.glIsRenderbuffer
= gl_info
->glIsRenderbufferEXT
;
2136 gl_info
->fbo_ops
.glBindRenderbuffer
= gl_info
->glBindRenderbufferEXT
;
2137 gl_info
->fbo_ops
.glDeleteRenderbuffers
= gl_info
->glDeleteRenderbuffersEXT
;
2138 gl_info
->fbo_ops
.glGenRenderbuffers
= gl_info
->glGenRenderbuffersEXT
;
2139 gl_info
->fbo_ops
.glRenderbufferStorage
= gl_info
->glRenderbufferStorageEXT
;
2140 gl_info
->fbo_ops
.glGetRenderbufferParameteriv
= gl_info
->glGetRenderbufferParameterivEXT
;
2141 gl_info
->fbo_ops
.glIsFramebuffer
= gl_info
->glIsFramebufferEXT
;
2142 gl_info
->fbo_ops
.glBindFramebuffer
= gl_info
->glBindFramebufferEXT
;
2143 gl_info
->fbo_ops
.glDeleteFramebuffers
= gl_info
->glDeleteFramebuffersEXT
;
2144 gl_info
->fbo_ops
.glGenFramebuffers
= gl_info
->glGenFramebuffersEXT
;
2145 gl_info
->fbo_ops
.glCheckFramebufferStatus
= gl_info
->glCheckFramebufferStatusEXT
;
2146 gl_info
->fbo_ops
.glFramebufferTexture1D
= gl_info
->glFramebufferTexture1DEXT
;
2147 gl_info
->fbo_ops
.glFramebufferTexture2D
= gl_info
->glFramebufferTexture2DEXT
;
2148 gl_info
->fbo_ops
.glFramebufferTexture3D
= gl_info
->glFramebufferTexture3DEXT
;
2149 gl_info
->fbo_ops
.glFramebufferRenderbuffer
= gl_info
->glFramebufferRenderbufferEXT
;
2150 gl_info
->fbo_ops
.glGetFramebufferAttachmentParameteriv
= gl_info
->glGetFramebufferAttachmentParameterivEXT
;
2151 gl_info
->fbo_ops
.glGenerateMipmap
= gl_info
->glGenerateMipmapEXT
;
2153 else if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
)
2155 WARN_(d3d_caps
)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2156 wined3d_settings
.offscreen_rendering_mode
= ORM_BACKBUFFER
;
2158 if (gl_info
->supported
[EXT_FRAMEBUFFER_BLIT
])
2160 gl_info
->fbo_ops
.glBlitFramebuffer
= gl_info
->glBlitFramebufferEXT
;
2162 if (gl_info
->supported
[EXT_FRAMEBUFFER_MULTISAMPLE
])
2164 gl_info
->fbo_ops
.glRenderbufferStorageMultisample
= gl_info
->glRenderbufferStorageMultisampleEXT
;
2168 /* MRTs are currently only supported when FBOs are used. */
2169 if (wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
)
2171 gl_info
->limits
.buffers
= 1;
2174 device
= wined3d_guess_card(gl_info
, gl_renderer
, &vendor
, &vidmem
);
2175 TRACE_(d3d_caps
)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", vendor
, device
);
2177 /* If we have an estimate use it, else default to 64MB; */
2179 gl_info
->vidmem
= vidmem
*1024*1024; /* convert from MBs to bytes */
2181 gl_info
->vidmem
= WINE_DEFAULT_VIDMEM
;
2183 gl_info
->wrap_lookup
[WINED3DTADDRESS_WRAP
- WINED3DTADDRESS_WRAP
] = GL_REPEAT
;
2184 gl_info
->wrap_lookup
[WINED3DTADDRESS_MIRROR
- WINED3DTADDRESS_WRAP
] =
2185 gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
] ? GL_MIRRORED_REPEAT_ARB
: GL_REPEAT
;
2186 gl_info
->wrap_lookup
[WINED3DTADDRESS_CLAMP
- WINED3DTADDRESS_WRAP
] = GL_CLAMP_TO_EDGE
;
2187 gl_info
->wrap_lookup
[WINED3DTADDRESS_BORDER
- WINED3DTADDRESS_WRAP
] =
2188 gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
] ? GL_CLAMP_TO_BORDER_ARB
: GL_REPEAT
;
2189 gl_info
->wrap_lookup
[WINED3DTADDRESS_MIRRORONCE
- WINED3DTADDRESS_WRAP
] =
2190 gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
] ? GL_MIRROR_CLAMP_TO_EDGE_ATI
: GL_REPEAT
;
2192 /* Make sure there's an active HDC else the WGL extensions will fail */
2193 hdc
= pwglGetCurrentDC();
2195 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2196 if(GL_EXTCALL(wglGetExtensionsStringARB
))
2197 WGL_Extensions
= GL_EXTCALL(wglGetExtensionsStringARB(hdc
));
2199 if (NULL
== WGL_Extensions
) {
2200 ERR(" WGL_Extensions returns NULL\n");
2202 TRACE_(d3d_caps
)("WGL_Extensions reported:\n");
2203 while (*WGL_Extensions
!= 0x00) {
2207 while (isspace(*WGL_Extensions
)) WGL_Extensions
++;
2208 Start
= WGL_Extensions
;
2209 while (!isspace(*WGL_Extensions
) && *WGL_Extensions
!= 0x00) {
2213 len
= WGL_Extensions
- Start
;
2214 if (len
== 0 || len
>= sizeof(ThisExtn
))
2217 memcpy(ThisExtn
, Start
, len
);
2218 ThisExtn
[len
] = '\0';
2219 TRACE_(d3d_caps
)("- %s\n", debugstr_a(ThisExtn
));
2221 if (!strcmp(ThisExtn
, "WGL_ARB_pbuffer")) {
2222 gl_info
->supported
[WGL_ARB_PBUFFER
] = TRUE
;
2223 TRACE_(d3d_caps
)("FOUND: WGL_ARB_pbuffer support\n");
2225 if (!strcmp(ThisExtn
, "WGL_ARB_pixel_format")) {
2226 gl_info
->supported
[WGL_ARB_PIXEL_FORMAT
] = TRUE
;
2227 TRACE_(d3d_caps
)("FOUND: WGL_ARB_pixel_format support\n");
2229 if (!strcmp(ThisExtn
, "WGL_WINE_pixel_format_passthrough")) {
2230 gl_info
->supported
[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH
] = TRUE
;
2231 TRACE_(d3d_caps
)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2237 fixup_extensions(gl_info
, gl_renderer
, vendor
, device
);
2238 init_driver_info(driver_info
, vendor
, device
);
2239 add_gl_compat_wrappers(gl_info
);
2241 HeapFree(GetProcessHeap(), 0, gl_renderer
);
2245 /**********************************************************
2246 * IWineD3D implementation follows
2247 **********************************************************/
2249 static UINT WINAPI
IWineD3DImpl_GetAdapterCount (IWineD3D
*iface
) {
2250 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2252 TRACE_(d3d_caps
)("(%p): Reporting %u adapters\n", This
, This
->adapter_count
);
2254 return This
->adapter_count
;
2257 static HRESULT WINAPI
IWineD3DImpl_RegisterSoftwareDevice(IWineD3D
*iface
, void *init_function
)
2259 FIXME("iface %p, init_function %p stub!\n", iface
, init_function
);
2264 static HMONITOR WINAPI
IWineD3DImpl_GetAdapterMonitor(IWineD3D
*iface
, UINT Adapter
) {
2265 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2267 TRACE_(d3d_caps
)("(%p)->(%d)\n", This
, Adapter
);
2269 if (Adapter
>= IWineD3DImpl_GetAdapterCount(iface
)) {
2273 return MonitorFromPoint(This
->adapters
[Adapter
].monitorPoint
, MONITOR_DEFAULTTOPRIMARY
);
2276 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2277 of the same bpp but different resolutions */
2279 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2280 static UINT WINAPI
IWineD3DImpl_GetAdapterModeCount(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
) {
2281 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2282 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Format: %s)\n", This
, Adapter
, debug_d3dformat(Format
));
2284 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2288 /* TODO: Store modes per adapter and read it from the adapter structure */
2289 if (Adapter
== 0) { /* Display */
2290 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(Format
, &This
->adapters
[Adapter
].gl_info
);
2291 UINT format_bits
= format_desc
->byte_count
* CHAR_BIT
;
2296 memset(&mode
, 0, sizeof(mode
));
2297 mode
.dmSize
= sizeof(mode
);
2299 while (EnumDisplaySettingsExW(NULL
, j
, &mode
, 0))
2303 if (Format
== WINED3DFMT_UNKNOWN
)
2305 /* This is for D3D8, do not enumerate P8 here */
2306 if (mode
.dmBitsPerPel
== 32 || mode
.dmBitsPerPel
== 16) ++i
;
2308 else if (mode
.dmBitsPerPel
== format_bits
)
2314 TRACE_(d3d_caps
)("(%p}->(Adapter: %d) => %d (out of %d)\n", This
, Adapter
, i
, j
);
2317 FIXME_(d3d_caps
)("Adapter not primary display\n");
2322 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2323 static HRESULT WINAPI
IWineD3DImpl_EnumAdapterModes(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
, UINT Mode
, WINED3DDISPLAYMODE
* pMode
) {
2324 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2325 TRACE_(d3d_caps
)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This
, Adapter
, Mode
, pMode
, debug_d3dformat(Format
));
2327 /* Validate the parameters as much as possible */
2328 if (NULL
== pMode
||
2329 Adapter
>= IWineD3DImpl_GetAdapterCount(iface
) ||
2330 Mode
>= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, Format
)) {
2331 return WINED3DERR_INVALIDCALL
;
2334 /* TODO: Store modes per adapter and read it from the adapter structure */
2337 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(Format
, &This
->adapters
[Adapter
].gl_info
);
2338 UINT format_bits
= format_desc
->byte_count
* CHAR_BIT
;
2344 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
2345 DevModeW
.dmSize
= sizeof(DevModeW
);
2347 /* If we are filtering to a specific format (D3D9), then need to skip
2348 all unrelated modes, but if mode is irrelevant (D3D8), then we can
2349 just count through the ones with valid bit depths */
2350 while ((i
<=Mode
) && EnumDisplaySettingsExW(NULL
, j
++, &DevModeW
, 0))
2352 if (Format
== WINED3DFMT_UNKNOWN
)
2354 /* This is for D3D8, do not enumerate P8 here */
2355 if (DevModeW
.dmBitsPerPel
== 32 || DevModeW
.dmBitsPerPel
== 16) ++i
;
2357 else if (DevModeW
.dmBitsPerPel
== format_bits
)
2364 TRACE_(d3d_caps
)("No modes found for format (%x - %s)\n", Format
, debug_d3dformat(Format
));
2365 return WINED3DERR_INVALIDCALL
;
2369 /* Now get the display mode via the calculated index */
2370 if (EnumDisplaySettingsExW(NULL
, ModeIdx
, &DevModeW
, 0)) {
2371 pMode
->Width
= DevModeW
.dmPelsWidth
;
2372 pMode
->Height
= DevModeW
.dmPelsHeight
;
2373 pMode
->RefreshRate
= DEFAULT_REFRESH_RATE
;
2374 if (DevModeW
.dmFields
& DM_DISPLAYFREQUENCY
)
2375 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
2377 if (Format
== WINED3DFMT_UNKNOWN
) {
2378 pMode
->Format
= pixelformat_for_depth(DevModeW
.dmBitsPerPel
);
2380 pMode
->Format
= Format
;
2383 TRACE_(d3d_caps
)("Requested mode out of range %d\n", Mode
);
2384 return WINED3DERR_INVALIDCALL
;
2387 TRACE_(d3d_caps
)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode
->Width
, pMode
->Height
,
2388 pMode
->RefreshRate
, pMode
->Format
, debug_d3dformat(pMode
->Format
),
2389 DevModeW
.dmBitsPerPel
);
2394 FIXME_(d3d_caps
)("Adapter not primary display\n");
2400 static HRESULT WINAPI
IWineD3DImpl_GetAdapterDisplayMode(IWineD3D
*iface
, UINT Adapter
, WINED3DDISPLAYMODE
*pMode
)
2402 TRACE("iface %p, adapter_idx %u, display_mode %p.\n", iface
, Adapter
, pMode
);
2404 if (NULL
== pMode
||
2405 Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2406 return WINED3DERR_INVALIDCALL
;
2409 if (Adapter
== 0) { /* Display */
2413 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
2414 DevModeW
.dmSize
= sizeof(DevModeW
);
2416 EnumDisplaySettingsExW(NULL
, ENUM_CURRENT_SETTINGS
, &DevModeW
, 0);
2417 pMode
->Width
= DevModeW
.dmPelsWidth
;
2418 pMode
->Height
= DevModeW
.dmPelsHeight
;
2419 bpp
= DevModeW
.dmBitsPerPel
;
2420 pMode
->RefreshRate
= DEFAULT_REFRESH_RATE
;
2421 if (DevModeW
.dmFields
&DM_DISPLAYFREQUENCY
)
2423 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
2426 pMode
->Format
= pixelformat_for_depth(bpp
);
2428 FIXME_(d3d_caps
)("Adapter not primary display\n");
2431 TRACE_(d3d_caps
)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode
->Width
,
2432 pMode
->Height
, pMode
->RefreshRate
, debug_d3dformat(pMode
->Format
));
2436 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2437 and fields being inserted in the middle, a new structure is used in place */
2438 static HRESULT WINAPI
IWineD3DImpl_GetAdapterIdentifier(IWineD3D
*iface
, UINT Adapter
, DWORD Flags
,
2439 WINED3DADAPTER_IDENTIFIER
* pIdentifier
) {
2440 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2441 struct wined3d_adapter
*adapter
;
2444 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This
, Adapter
, Flags
, pIdentifier
);
2446 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2447 return WINED3DERR_INVALIDCALL
;
2450 adapter
= &This
->adapters
[Adapter
];
2452 /* Return the information requested */
2453 TRACE_(d3d_caps
)("device/Vendor Name and Version detection using FillGLCaps\n");
2455 if (pIdentifier
->driver_size
)
2457 const char *name
= adapter
->driver_info
.name
;
2458 len
= min(strlen(name
), pIdentifier
->driver_size
- 1);
2459 memcpy(pIdentifier
->driver
, name
, len
);
2460 pIdentifier
->driver
[len
] = '\0';
2463 if (pIdentifier
->description_size
)
2465 const char *description
= adapter
->driver_info
.description
;
2466 len
= min(strlen(description
), pIdentifier
->description_size
- 1);
2467 memcpy(pIdentifier
->description
, description
, len
);
2468 pIdentifier
->description
[len
] = '\0';
2471 /* Note that d3d8 doesn't supply a device name. */
2472 if (pIdentifier
->device_name_size
)
2474 static const char *device_name
= "\\\\.\\DISPLAY1"; /* FIXME: May depend on desktop? */
2476 len
= strlen(device_name
);
2477 if (len
>= pIdentifier
->device_name_size
)
2479 ERR("Device name size too small.\n");
2480 return WINED3DERR_INVALIDCALL
;
2483 memcpy(pIdentifier
->device_name
, device_name
, len
);
2484 pIdentifier
->device_name
[len
] = '\0';
2487 pIdentifier
->driver_version
.u
.HighPart
= adapter
->driver_info
.version_high
;
2488 pIdentifier
->driver_version
.u
.LowPart
= adapter
->driver_info
.version_low
;
2489 pIdentifier
->vendor_id
= adapter
->driver_info
.vendor
;
2490 pIdentifier
->device_id
= adapter
->driver_info
.device
;
2491 pIdentifier
->subsystem_id
= 0;
2492 pIdentifier
->revision
= 0;
2493 memcpy(&pIdentifier
->device_identifier
, &IID_D3DDEVICE_D3DUID
, sizeof(pIdentifier
->device_identifier
));
2494 pIdentifier
->whql_level
= (Flags
& WINED3DENUM_NO_WHQL_LEVEL
) ? 0 : 1;
2495 memcpy(&pIdentifier
->adapter_luid
, &adapter
->luid
, sizeof(pIdentifier
->adapter_luid
));
2496 pIdentifier
->video_memory
= adapter
->TextureRam
;
2501 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info
*gl_info
,
2502 const WineD3D_PixelFormat
*cfg
, const struct GlPixelFormatDesc
*format_desc
)
2504 short redSize
, greenSize
, blueSize
, alphaSize
, colorBits
;
2509 if(cfg
->iPixelType
== WGL_TYPE_RGBA_ARB
) { /* Integer RGBA formats */
2510 if (!getColorBits(format_desc
, &redSize
, &greenSize
, &blueSize
, &alphaSize
, &colorBits
))
2512 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc
->format
));
2516 if(cfg
->redSize
< redSize
)
2519 if(cfg
->greenSize
< greenSize
)
2522 if(cfg
->blueSize
< blueSize
)
2525 if(cfg
->alphaSize
< alphaSize
)
2529 } else if(cfg
->iPixelType
== WGL_TYPE_RGBA_FLOAT_ARB
) { /* Float RGBA formats; TODO: WGL_NV_float_buffer */
2530 if (format_desc
->format
== WINED3DFMT_R16_FLOAT
)
2531 return (cfg
->redSize
== 16 && cfg
->greenSize
== 0 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2532 if (format_desc
->format
== WINED3DFMT_R16G16_FLOAT
)
2533 return (cfg
->redSize
== 16 && cfg
->greenSize
== 16 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2534 if (format_desc
->format
== WINED3DFMT_R16G16B16A16_FLOAT
)
2535 return (cfg
->redSize
== 16 && cfg
->greenSize
== 16 && cfg
->blueSize
== 16 && cfg
->alphaSize
== 16);
2536 if (format_desc
->format
== WINED3DFMT_R32_FLOAT
)
2537 return (cfg
->redSize
== 32 && cfg
->greenSize
== 0 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2538 if (format_desc
->format
== WINED3DFMT_R32G32_FLOAT
)
2539 return (cfg
->redSize
== 32 && cfg
->greenSize
== 32 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2540 if (format_desc
->format
== WINED3DFMT_R32G32B32A32_FLOAT
)
2541 return (cfg
->redSize
== 32 && cfg
->greenSize
== 32 && cfg
->blueSize
== 32 && cfg
->alphaSize
== 32);
2543 /* Probably a color index mode */
2550 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info
*gl_info
,
2551 const WineD3D_PixelFormat
*cfg
, const struct GlPixelFormatDesc
*format_desc
)
2553 short depthSize
, stencilSize
;
2554 BOOL lockable
= FALSE
;
2559 if (!getDepthStencilBits(format_desc
, &depthSize
, &stencilSize
))
2561 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc
->format
));
2565 if ((format_desc
->format
== WINED3DFMT_D16_LOCKABLE
) || (format_desc
->format
== WINED3DFMT_D32_FLOAT
))
2568 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
2569 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
2570 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
2571 if(!(cfg
->depthSize
== depthSize
|| (!lockable
&& cfg
->depthSize
> depthSize
)))
2574 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
2575 * allow more stencil bits than requested. */
2576 if(cfg
->stencilSize
< stencilSize
)
2582 static HRESULT WINAPI
IWineD3DImpl_CheckDepthStencilMatch(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2583 WINED3DFORMAT AdapterFormat
,
2584 WINED3DFORMAT RenderTargetFormat
,
2585 WINED3DFORMAT DepthStencilFormat
) {
2586 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2588 const WineD3D_PixelFormat
*cfgs
;
2589 const struct wined3d_adapter
*adapter
;
2590 const struct GlPixelFormatDesc
*rt_format_desc
;
2591 const struct GlPixelFormatDesc
*ds_format_desc
;
2594 WARN_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
2596 DeviceType
, debug_d3ddevicetype(DeviceType
),
2597 AdapterFormat
, debug_d3dformat(AdapterFormat
),
2598 RenderTargetFormat
, debug_d3dformat(RenderTargetFormat
),
2599 DepthStencilFormat
, debug_d3dformat(DepthStencilFormat
));
2601 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2602 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This
, Adapter
, IWineD3D_GetAdapterCount(iface
));
2603 return WINED3DERR_INVALIDCALL
;
2606 adapter
= &This
->adapters
[Adapter
];
2607 rt_format_desc
= getFormatDescEntry(RenderTargetFormat
, &adapter
->gl_info
);
2608 ds_format_desc
= getFormatDescEntry(DepthStencilFormat
, &adapter
->gl_info
);
2609 cfgs
= adapter
->cfgs
;
2610 nCfgs
= adapter
->nCfgs
;
2611 for (it
= 0; it
< nCfgs
; ++it
) {
2612 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
, &cfgs
[it
], rt_format_desc
))
2614 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, &cfgs
[it
], ds_format_desc
))
2616 TRACE_(d3d_caps
)("(%p) : Formats matched\n", This
);
2621 WARN_(d3d_caps
)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat
), debug_d3dformat(DepthStencilFormat
));
2623 return WINED3DERR_NOTAVAILABLE
;
2626 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2627 WINED3DFORMAT SurfaceFormat
, BOOL Windowed
, WINED3DMULTISAMPLE_TYPE MultiSampleType
, DWORD
*pQualityLevels
)
2629 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2630 const struct GlPixelFormatDesc
*glDesc
;
2631 const struct wined3d_adapter
*adapter
;
2633 TRACE_(d3d_caps
)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
2636 DeviceType
, debug_d3ddevicetype(DeviceType
),
2637 SurfaceFormat
, debug_d3dformat(SurfaceFormat
),
2642 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2643 return WINED3DERR_INVALIDCALL
;
2646 /* TODO: handle Windowed, add more quality levels */
2648 if (WINED3DMULTISAMPLE_NONE
== MultiSampleType
) {
2649 if(pQualityLevels
) *pQualityLevels
= 1;
2653 /* By default multisampling is disabled right now as it causes issues
2654 * on some Nvidia driver versions and it doesn't work well in combination
2656 if(!wined3d_settings
.allow_multisampling
)
2657 return WINED3DERR_NOTAVAILABLE
;
2659 adapter
= &This
->adapters
[Adapter
];
2660 glDesc
= getFormatDescEntry(SurfaceFormat
, &adapter
->gl_info
);
2661 if (!glDesc
) return WINED3DERR_INVALIDCALL
;
2663 if(glDesc
->Flags
& (WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
)) {
2665 const WineD3D_PixelFormat
*cfgs
;
2667 cfgs
= adapter
->cfgs
;
2668 nCfgs
= adapter
->nCfgs
;
2669 for(i
=0; i
<nCfgs
; i
++) {
2670 if(cfgs
[i
].numSamples
!= MultiSampleType
)
2673 if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, &cfgs
[i
], glDesc
))
2676 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs
[i
].iPixelFormat
, MultiSampleType
, debug_d3dformat(SurfaceFormat
));
2679 *pQualityLevels
= 1; /* Guess at a value! */
2683 else if(glDesc
->Flags
& WINED3DFMT_FLAG_RENDERTARGET
) {
2684 short redSize
, greenSize
, blueSize
, alphaSize
, colorBits
;
2686 const WineD3D_PixelFormat
*cfgs
;
2688 if (!getColorBits(glDesc
, &redSize
, &greenSize
, &blueSize
, &alphaSize
, &colorBits
))
2690 ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat
);
2691 return WINED3DERR_NOTAVAILABLE
;
2694 cfgs
= adapter
->cfgs
;
2695 nCfgs
= adapter
->nCfgs
;
2696 for(i
=0; i
<nCfgs
; i
++) {
2697 if(cfgs
[i
].numSamples
!= MultiSampleType
)
2699 if(cfgs
[i
].redSize
!= redSize
)
2701 if(cfgs
[i
].greenSize
!= greenSize
)
2703 if(cfgs
[i
].blueSize
!= blueSize
)
2705 /* Not all drivers report alpha-less formats since they use 32-bit anyway, so accept alpha even if we didn't ask for it. */
2706 if(alphaSize
&& cfgs
[i
].alphaSize
!= alphaSize
)
2708 if(cfgs
[i
].colorSize
!= (glDesc
->byte_count
<< 3))
2711 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs
[i
].iPixelFormat
, MultiSampleType
, debug_d3dformat(SurfaceFormat
));
2714 *pQualityLevels
= 1; /* Guess at a value! */
2718 return WINED3DERR_NOTAVAILABLE
;
2721 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2722 WINED3DFORMAT DisplayFormat
, WINED3DFORMAT BackBufferFormat
, BOOL Windowed
)
2724 HRESULT hr
= WINED3DERR_NOTAVAILABLE
;
2727 TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
2728 iface
, Adapter
, debug_d3ddevicetype(DeviceType
), debug_d3dformat(DisplayFormat
),
2729 debug_d3dformat(BackBufferFormat
), Windowed
);
2731 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2732 WARN_(d3d_caps
)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
2733 return WINED3DERR_INVALIDCALL
;
2736 /* The task of this function is to check whether a certain display / backbuffer format
2737 * combination is available on the given adapter. In fullscreen mode microsoft specified
2738 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
2739 * and display format should match exactly.
2740 * In windowed mode format conversion can occur and this depends on the driver. When format
2741 * conversion is done, this function should nevertheless fail and applications need to use
2742 * CheckDeviceFormatConversion.
2743 * At the moment we assume that fullscreen and windowed have the same capabilities */
2745 /* There are only 4 display formats */
2746 if (!(DisplayFormat
== WINED3DFMT_B5G6R5_UNORM
2747 || DisplayFormat
== WINED3DFMT_B5G5R5X1_UNORM
2748 || DisplayFormat
== WINED3DFMT_B8G8R8X8_UNORM
2749 || DisplayFormat
== WINED3DFMT_B10G10R10A2_UNORM
))
2751 TRACE_(d3d_caps
)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat
));
2752 return WINED3DERR_NOTAVAILABLE
;
2755 /* If the requested DisplayFormat is not available, don't continue */
2756 nmodes
= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, DisplayFormat
);
2758 TRACE_(d3d_caps
)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat
));
2759 return WINED3DERR_NOTAVAILABLE
;
2762 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
2763 if(!Windowed
&& BackBufferFormat
== WINED3DFMT_UNKNOWN
) {
2764 TRACE_(d3d_caps
)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
2765 return WINED3DERR_NOTAVAILABLE
;
2768 /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
2769 if (DisplayFormat
== WINED3DFMT_B5G6R5_UNORM
&& BackBufferFormat
!= WINED3DFMT_B5G6R5_UNORM
)
2771 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2772 return WINED3DERR_NOTAVAILABLE
;
2775 /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
2776 if (DisplayFormat
== WINED3DFMT_B5G5R5X1_UNORM
2777 && !(BackBufferFormat
== WINED3DFMT_B5G5R5X1_UNORM
|| BackBufferFormat
== WINED3DFMT_B5G5R5A1_UNORM
))
2779 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2780 return WINED3DERR_NOTAVAILABLE
;
2783 /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
2784 if (DisplayFormat
== WINED3DFMT_B8G8R8X8_UNORM
2785 && !(BackBufferFormat
== WINED3DFMT_B8G8R8X8_UNORM
|| BackBufferFormat
== WINED3DFMT_B8G8R8A8_UNORM
))
2787 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2788 return WINED3DERR_NOTAVAILABLE
;
2791 /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
2792 if (DisplayFormat
== WINED3DFMT_B10G10R10A2_UNORM
2793 && (BackBufferFormat
!= WINED3DFMT_B10G10R10A2_UNORM
|| Windowed
))
2795 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2796 return WINED3DERR_NOTAVAILABLE
;
2799 /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
2800 hr
= IWineD3DImpl_CheckDeviceFormat(iface
, Adapter
, DeviceType
, DisplayFormat
, WINED3DUSAGE_RENDERTARGET
, WINED3DRTYPE_SURFACE
, BackBufferFormat
, SURFACE_OPENGL
);
2802 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2808 /* Check if we support bumpmapping for a format */
2809 static BOOL
CheckBumpMapCapability(struct wined3d_adapter
*adapter
,
2810 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2812 switch(format_desc
->format
)
2814 case WINED3DFMT_R8G8_SNORM
:
2815 case WINED3DFMT_R16G16_SNORM
:
2816 case WINED3DFMT_R5G5_SNORM_L6_UNORM
:
2817 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM
:
2818 case WINED3DFMT_R8G8B8A8_SNORM
:
2819 /* Ask the fixed function pipeline implementation if it can deal
2820 * with the conversion. If we've got a GL extension giving native
2821 * support this will be an identity conversion. */
2822 if (adapter
->fragment_pipe
->color_fixup_supported(format_desc
->color_fixup
))
2824 TRACE_(d3d_caps
)("[OK]\n");
2827 TRACE_(d3d_caps
)("[FAILED]\n");
2831 TRACE_(d3d_caps
)("[FAILED]\n");
2836 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
2837 static BOOL
CheckDepthStencilCapability(struct wined3d_adapter
*adapter
,
2838 const struct GlPixelFormatDesc
*display_format_desc
, const struct GlPixelFormatDesc
*ds_format_desc
)
2842 /* Only allow depth/stencil formats */
2843 if (!(ds_format_desc
->depth_size
|| ds_format_desc
->stencil_size
)) return FALSE
;
2845 /* Walk through all WGL pixel formats to find a match */
2846 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2848 WineD3D_PixelFormat
*cfg
= &adapter
->cfgs
[it
];
2849 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
, cfg
, display_format_desc
))
2851 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, cfg
, ds_format_desc
))
2861 static BOOL
CheckFilterCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2863 /* The flags entry of a format contains the filtering capability */
2864 if (format_desc
->Flags
& WINED3DFMT_FLAG_FILTERING
) return TRUE
;
2869 /* Check the render target capabilities of a format */
2870 static BOOL
CheckRenderTargetCapability(struct wined3d_adapter
*adapter
,
2871 const struct GlPixelFormatDesc
*adapter_format_desc
, const struct GlPixelFormatDesc
*check_format_desc
)
2873 /* Filter out non-RT formats */
2874 if (!(check_format_desc
->Flags
& WINED3DFMT_FLAG_RENDERTARGET
)) return FALSE
;
2876 if(wined3d_settings
.offscreen_rendering_mode
== ORM_BACKBUFFER
) {
2877 WineD3D_PixelFormat
*cfgs
= adapter
->cfgs
;
2879 short AdapterRed
, AdapterGreen
, AdapterBlue
, AdapterAlpha
, AdapterTotalSize
;
2880 short CheckRed
, CheckGreen
, CheckBlue
, CheckAlpha
, CheckTotalSize
;
2882 getColorBits(adapter_format_desc
, &AdapterRed
, &AdapterGreen
, &AdapterBlue
, &AdapterAlpha
, &AdapterTotalSize
);
2883 getColorBits(check_format_desc
, &CheckRed
, &CheckGreen
, &CheckBlue
, &CheckAlpha
, &CheckTotalSize
);
2885 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
2886 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
2887 if(!((AdapterRed
== CheckRed
) && (AdapterGreen
== CheckGreen
) && (AdapterBlue
== CheckBlue
))) {
2888 TRACE_(d3d_caps
)("[FAILED]\n");
2892 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
2893 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
2894 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2896 if (cfgs
[it
].windowDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
,
2897 &cfgs
[it
], check_format_desc
))
2899 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
2900 cfgs
[it
].iPixelFormat
, debug_d3dformat(check_format_desc
->format
));
2904 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_PBUFFER
) {
2905 /* We can probably use this function in FBO mode too on some drivers to get some basic indication of the capabilities. */
2906 WineD3D_PixelFormat
*cfgs
= adapter
->cfgs
;
2909 /* Check if there is a WGL pixel format matching the requirements, the pixel format should also be usable with pbuffers */
2910 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2912 if (cfgs
[it
].pbufferDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
,
2913 &cfgs
[it
], check_format_desc
))
2915 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
2916 cfgs
[it
].iPixelFormat
, debug_d3dformat(check_format_desc
->format
));
2920 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
){
2921 /* For now return TRUE for FBOs until we have some proper checks.
2922 * Note that this function will only be called when the format is around for texturing. */
2928 static BOOL
CheckSrgbReadCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2930 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
2932 /* Check for supported sRGB formats (Texture loading and framebuffer) */
2933 if (!gl_info
->supported
[EXT_TEXTURE_SRGB
])
2935 TRACE_(d3d_caps
)("[FAILED] GL_EXT_texture_sRGB not supported\n");
2939 switch (format_desc
->format
)
2941 case WINED3DFMT_B8G8R8A8_UNORM
:
2942 case WINED3DFMT_B8G8R8X8_UNORM
:
2943 case WINED3DFMT_B4G4R4A4_UNORM
:
2944 case WINED3DFMT_L8_UNORM
:
2945 case WINED3DFMT_L8A8_UNORM
:
2946 case WINED3DFMT_DXT1
:
2947 case WINED3DFMT_DXT2
:
2948 case WINED3DFMT_DXT3
:
2949 case WINED3DFMT_DXT4
:
2950 case WINED3DFMT_DXT5
:
2951 TRACE_(d3d_caps
)("[OK]\n");
2955 TRACE_(d3d_caps
)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(format_desc
->format
));
2961 static BOOL
CheckSrgbWriteCapability(struct wined3d_adapter
*adapter
,
2962 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2964 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
2965 * doing the color fixup in shaders.
2966 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
2967 if ((format_desc
->format
== WINED3DFMT_B8G8R8X8_UNORM
) || (format_desc
->format
== WINED3DFMT_B8G8R8A8_UNORM
))
2969 int vs_selected_mode
;
2970 int ps_selected_mode
;
2971 select_shader_mode(&adapter
->gl_info
, &ps_selected_mode
, &vs_selected_mode
);
2973 if((ps_selected_mode
== SHADER_ARB
) || (ps_selected_mode
== SHADER_GLSL
)) {
2974 TRACE_(d3d_caps
)("[OK]\n");
2979 TRACE_(d3d_caps
)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(format_desc
->format
));
2983 /* Check if a format support blending in combination with pixel shaders */
2984 static BOOL
CheckPostPixelShaderBlendingCapability(struct wined3d_adapter
*adapter
,
2985 const struct GlPixelFormatDesc
*format_desc
)
2987 /* The flags entry of a format contains the post pixel shader blending capability */
2988 if (format_desc
->Flags
& WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
) return TRUE
;
2993 static BOOL
CheckWrapAndMipCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2995 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
2996 * but we have to report mipmapping so we cannot reject this flag. Tests show that
2997 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
2998 * that wrapping is supported. The lack of filtering will sort out the mipmapping
2999 * capability anyway.
3001 * For now lets report this on all formats, but in the future we may want to
3002 * restrict it to some should games need that
3007 /* Check if a texture format is supported on the given adapter */
3008 static BOOL
CheckTextureCapability(struct wined3d_adapter
*adapter
,
3009 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
3011 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
3013 switch (format_desc
->format
)
3016 * supported: RGB(A) formats
3018 case WINED3DFMT_B8G8R8_UNORM
: /* Enable for dx7, blacklisted for 8 and 9 above */
3019 case WINED3DFMT_B8G8R8A8_UNORM
:
3020 case WINED3DFMT_B8G8R8X8_UNORM
:
3021 case WINED3DFMT_B5G6R5_UNORM
:
3022 case WINED3DFMT_B5G5R5X1_UNORM
:
3023 case WINED3DFMT_B5G5R5A1_UNORM
:
3024 case WINED3DFMT_B4G4R4A4_UNORM
:
3025 case WINED3DFMT_A8_UNORM
:
3026 case WINED3DFMT_B4G4R4X4_UNORM
:
3027 case WINED3DFMT_R8G8B8A8_UNORM
:
3028 case WINED3DFMT_R8G8B8X8_UNORM
:
3029 case WINED3DFMT_B10G10R10A2_UNORM
:
3030 case WINED3DFMT_R10G10B10A2_UNORM
:
3031 case WINED3DFMT_R16G16_UNORM
:
3032 TRACE_(d3d_caps
)("[OK]\n");
3035 case WINED3DFMT_B2G3R3_UNORM
:
3036 TRACE_(d3d_caps
)("[FAILED] - Not supported on Windows\n");
3040 * supported: Palettized
3042 case WINED3DFMT_P8_UINT
:
3043 TRACE_(d3d_caps
)("[OK]\n");
3045 /* No Windows driver offers WINED3DFMT_P8_UINT_A8_UNORM, so don't offer it either */
3046 case WINED3DFMT_P8_UINT_A8_UNORM
:
3050 * Supported: (Alpha)-Luminance
3052 case WINED3DFMT_L8_UNORM
:
3053 case WINED3DFMT_L8A8_UNORM
:
3054 case WINED3DFMT_L16_UNORM
:
3055 TRACE_(d3d_caps
)("[OK]\n");
3058 /* Not supported on Windows, thus disabled */
3059 case WINED3DFMT_L4A4_UNORM
:
3060 TRACE_(d3d_caps
)("[FAILED] - not supported on windows\n");
3064 * Supported: Depth/Stencil formats
3066 case WINED3DFMT_D16_LOCKABLE
:
3067 case WINED3DFMT_D16_UNORM
:
3068 case WINED3DFMT_S1_UINT_D15_UNORM
:
3069 case WINED3DFMT_X8D24_UNORM
:
3070 case WINED3DFMT_S4X4_UINT_D24_UNORM
:
3071 case WINED3DFMT_D24_UNORM_S8_UINT
:
3072 case WINED3DFMT_S8_UINT_D24_FLOAT
:
3073 case WINED3DFMT_D32_UNORM
:
3074 case WINED3DFMT_D32_FLOAT
:
3078 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3079 * GL_NV_texture_shader). Emulated by shaders
3081 case WINED3DFMT_R8G8_SNORM
:
3082 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM
:
3083 case WINED3DFMT_R5G5_SNORM_L6_UNORM
:
3084 case WINED3DFMT_R8G8B8A8_SNORM
:
3085 case WINED3DFMT_R16G16_SNORM
:
3086 /* Ask the shader backend if it can deal with the conversion. If
3087 * we've got a GL extension giving native support this will be an
3088 * identity conversion. */
3089 if (adapter
->shader_backend
->shader_color_fixup_supported(format_desc
->color_fixup
))
3091 TRACE_(d3d_caps
)("[OK]\n");
3094 TRACE_(d3d_caps
)("[FAILED]\n");
3097 case WINED3DFMT_DXT1
:
3098 case WINED3DFMT_DXT2
:
3099 case WINED3DFMT_DXT3
:
3100 case WINED3DFMT_DXT4
:
3101 case WINED3DFMT_DXT5
:
3102 if (gl_info
->supported
[EXT_TEXTURE_COMPRESSION_S3TC
])
3104 TRACE_(d3d_caps
)("[OK]\n");
3107 TRACE_(d3d_caps
)("[FAILED]\n");
3112 * Odd formats - not supported
3114 case WINED3DFMT_VERTEXDATA
:
3115 case WINED3DFMT_R16_UINT
:
3116 case WINED3DFMT_R32_UINT
:
3117 case WINED3DFMT_R16G16B16A16_SNORM
:
3118 case WINED3DFMT_R10G10B10_SNORM_A2_UNORM
:
3119 case WINED3DFMT_R10G11B11_SNORM
:
3120 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
3124 * WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3126 case WINED3DFMT_R8G8_SNORM_Cx
:
3127 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
3131 case WINED3DFMT_UYVY
:
3132 case WINED3DFMT_YUY2
:
3133 if (gl_info
->supported
[APPLE_YCBCR_422
])
3135 TRACE_(d3d_caps
)("[OK]\n");
3138 TRACE_(d3d_caps
)("[FAILED]\n");
3140 case WINED3DFMT_YV12
:
3141 TRACE_(d3d_caps
)("[FAILED]\n");
3145 case WINED3DFMT_R16G16B16A16_UNORM
:
3146 case WINED3DFMT_B2G3R3A8_UNORM
:
3147 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
3150 /* Floating point formats */
3151 case WINED3DFMT_R16_FLOAT
:
3152 case WINED3DFMT_R16G16_FLOAT
:
3153 case WINED3DFMT_R16G16B16A16_FLOAT
:
3154 if (gl_info
->supported
[ARB_TEXTURE_FLOAT
] && gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
])
3156 TRACE_(d3d_caps
)("[OK]\n");
3159 TRACE_(d3d_caps
)("[FAILED]\n");
3162 case WINED3DFMT_R32_FLOAT
:
3163 case WINED3DFMT_R32G32_FLOAT
:
3164 case WINED3DFMT_R32G32B32A32_FLOAT
:
3165 if (gl_info
->supported
[ARB_TEXTURE_FLOAT
])
3167 TRACE_(d3d_caps
)("[OK]\n");
3170 TRACE_(d3d_caps
)("[FAILED]\n");
3173 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3174 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3175 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3176 * We can do instancing with all shader versions, but we need vertex shaders.
3178 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3179 * to enable instancing. WineD3D doesn't need that and just ignores it.
3181 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3183 case WINED3DFMT_INST
:
3184 TRACE("ATI Instancing check hack\n");
3185 if (gl_info
->supported
[ARB_VERTEX_PROGRAM
] || gl_info
->supported
[ARB_VERTEX_SHADER
])
3187 TRACE_(d3d_caps
)("[OK]\n");
3190 TRACE_(d3d_caps
)("[FAILED]\n");
3193 /* Some weird FOURCC formats */
3194 case WINED3DFMT_R8G8_B8G8
:
3195 case WINED3DFMT_G8R8_G8B8
:
3196 case WINED3DFMT_MULTI2_ARGB8
:
3197 TRACE_(d3d_caps
)("[FAILED]\n");
3200 /* Vendor specific formats */
3201 case WINED3DFMT_ATI2N
:
3202 if (gl_info
->supported
[ATI_TEXTURE_COMPRESSION_3DC
]
3203 || gl_info
->supported
[EXT_TEXTURE_COMPRESSION_RGTC
])
3205 if (adapter
->shader_backend
->shader_color_fixup_supported(format_desc
->color_fixup
)
3206 && adapter
->fragment_pipe
->color_fixup_supported(format_desc
->color_fixup
))
3208 TRACE_(d3d_caps
)("[OK]\n");
3212 TRACE_(d3d_caps
)("[OK]\n");
3215 TRACE_(d3d_caps
)("[FAILED]\n");
3218 case WINED3DFMT_NVHU
:
3219 case WINED3DFMT_NVHS
:
3220 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3221 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3222 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3223 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3224 * Applications have to deal with not having NVHS and NVHU.
3226 TRACE_(d3d_caps
)("[FAILED]\n");
3229 case WINED3DFMT_UNKNOWN
:
3233 ERR("Unhandled format=%s\n", debug_d3dformat(format_desc
->format
));
3239 static BOOL
CheckSurfaceCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*adapter_format_desc
,
3240 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*check_format_desc
, WINED3DSURFTYPE SurfaceType
)
3242 if(SurfaceType
== SURFACE_GDI
) {
3243 switch(check_format_desc
->format
)
3245 case WINED3DFMT_B8G8R8_UNORM
:
3246 case WINED3DFMT_B8G8R8A8_UNORM
:
3247 case WINED3DFMT_B8G8R8X8_UNORM
:
3248 case WINED3DFMT_B5G6R5_UNORM
:
3249 case WINED3DFMT_B5G5R5X1_UNORM
:
3250 case WINED3DFMT_B5G5R5A1_UNORM
:
3251 case WINED3DFMT_B4G4R4A4_UNORM
:
3252 case WINED3DFMT_B2G3R3_UNORM
:
3253 case WINED3DFMT_A8_UNORM
:
3254 case WINED3DFMT_B2G3R3A8_UNORM
:
3255 case WINED3DFMT_B4G4R4X4_UNORM
:
3256 case WINED3DFMT_R10G10B10A2_UNORM
:
3257 case WINED3DFMT_R8G8B8A8_UNORM
:
3258 case WINED3DFMT_R8G8B8X8_UNORM
:
3259 case WINED3DFMT_R16G16_UNORM
:
3260 case WINED3DFMT_B10G10R10A2_UNORM
:
3261 case WINED3DFMT_R16G16B16A16_UNORM
:
3262 case WINED3DFMT_P8_UINT
:
3263 TRACE_(d3d_caps
)("[OK]\n");
3266 TRACE_(d3d_caps
)("[FAILED] - not available on GDI surfaces\n");
3271 /* All format that are supported for textures are supported for surfaces as well */
3272 if (CheckTextureCapability(adapter
, DeviceType
, check_format_desc
)) return TRUE
;
3273 /* All depth stencil formats are supported on surfaces */
3274 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, check_format_desc
)) return TRUE
;
3276 /* If opengl can't process the format natively, the blitter may be able to convert it */
3277 if (adapter
->blitter
->color_fixup_supported(check_format_desc
->color_fixup
))
3279 TRACE_(d3d_caps
)("[OK]\n");
3283 /* Reject other formats */
3284 TRACE_(d3d_caps
)("[FAILED]\n");
3288 static BOOL
CheckVertexTextureCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
3290 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
3292 if (!gl_info
->limits
.vertex_samplers
)
3294 TRACE_(d3d_caps
)("[FAILED]\n");
3298 switch (format_desc
->format
)
3300 case WINED3DFMT_R32G32B32A32_FLOAT
:
3301 if (!gl_info
->supported
[ARB_TEXTURE_FLOAT
])
3303 TRACE_(d3d_caps
)("[FAILED]\n");
3306 TRACE_(d3d_caps
)("[OK]\n");
3310 TRACE_(d3d_caps
)("[FAILED]\n");
3316 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
3317 WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
,
3318 WINED3DSURFTYPE SurfaceType
)
3320 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3321 struct wined3d_adapter
*adapter
= &This
->adapters
[Adapter
];
3322 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
3323 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(CheckFormat
, gl_info
);
3324 const struct GlPixelFormatDesc
*adapter_format_desc
= getFormatDescEntry(AdapterFormat
, gl_info
);
3325 DWORD UsageCaps
= 0;
3327 TRACE_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3330 DeviceType
, debug_d3ddevicetype(DeviceType
),
3331 AdapterFormat
, debug_d3dformat(AdapterFormat
),
3332 Usage
, debug_d3dusage(Usage
), debug_d3dusagequery(Usage
),
3333 RType
, debug_d3dresourcetype(RType
),
3334 CheckFormat
, debug_d3dformat(CheckFormat
));
3336 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
3337 return WINED3DERR_INVALIDCALL
;
3340 if(RType
== WINED3DRTYPE_CUBETEXTURE
) {
3342 if(SurfaceType
!= SURFACE_OPENGL
) {
3343 TRACE("[FAILED]\n");
3344 return WINED3DERR_NOTAVAILABLE
;
3347 /* Cubetexture allows:
3348 * - D3DUSAGE_AUTOGENMIPMAP
3349 * - D3DUSAGE_DEPTHSTENCIL
3350 * - D3DUSAGE_DYNAMIC
3351 * - D3DUSAGE_NONSECURE (d3d9ex)
3352 * - D3DUSAGE_RENDERTARGET
3353 * - D3DUSAGE_SOFTWAREPROCESSING
3354 * - D3DUSAGE_QUERY_WRAPANDMIP
3356 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
3358 /* Check if the texture format is around */
3359 if (CheckTextureCapability(adapter
, DeviceType
, format_desc
))
3361 if(Usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
3362 /* Check for automatic mipmap generation support */
3363 if (gl_info
->supported
[SGIS_GENERATE_MIPMAP
])
3365 UsageCaps
|= WINED3DUSAGE_AUTOGENMIPMAP
;
3367 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
3368 TRACE_(d3d_caps
)("[FAILED] - No autogenmipmap support, but continuing\n");
3372 /* Always report dynamic locking */
3373 if(Usage
& WINED3DUSAGE_DYNAMIC
)
3374 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
3376 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
3377 if(CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
3379 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
3381 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
3382 return WINED3DERR_NOTAVAILABLE
;
3386 /* Always report software processing */
3387 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
3388 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
3390 /* Check QUERY_FILTER support */
3391 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
3392 if (CheckFilterCapability(adapter
, format_desc
))
3394 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
3396 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
3397 return WINED3DERR_NOTAVAILABLE
;
3401 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3402 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3403 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3405 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3407 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3408 return WINED3DERR_NOTAVAILABLE
;
3412 /* Check QUERY_SRGBREAD support */
3413 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
3414 if (CheckSrgbReadCapability(adapter
, format_desc
))
3416 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
3418 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
3419 return WINED3DERR_NOTAVAILABLE
;
3423 /* Check QUERY_SRGBWRITE support */
3424 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
3425 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
3427 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
3429 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
3430 return WINED3DERR_NOTAVAILABLE
;
3434 /* Check QUERY_VERTEXTEXTURE support */
3435 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
3436 if (CheckVertexTextureCapability(adapter
, format_desc
))
3438 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
3440 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
3441 return WINED3DERR_NOTAVAILABLE
;
3445 /* Check QUERY_WRAPANDMIP support */
3446 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
3447 if (CheckWrapAndMipCapability(adapter
, format_desc
))
3449 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
3451 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
3452 return WINED3DERR_NOTAVAILABLE
;
3456 TRACE_(d3d_caps
)("[FAILED] - Cube texture format not supported\n");
3457 return WINED3DERR_NOTAVAILABLE
;
3460 TRACE_(d3d_caps
)("[FAILED] - No cube texture support\n");
3461 return WINED3DERR_NOTAVAILABLE
;
3463 } else if(RType
== WINED3DRTYPE_SURFACE
) {
3465 * - D3DUSAGE_DEPTHSTENCIL
3466 * - D3DUSAGE_NONSECURE (d3d9ex)
3467 * - D3DUSAGE_RENDERTARGET
3470 if (CheckSurfaceCapability(adapter
, adapter_format_desc
, DeviceType
, format_desc
, SurfaceType
))
3472 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
3473 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, format_desc
))
3475 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
3477 TRACE_(d3d_caps
)("[FAILED] - No depthstencil support\n");
3478 return WINED3DERR_NOTAVAILABLE
;
3482 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
3483 if (CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
3485 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
3487 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
3488 return WINED3DERR_NOTAVAILABLE
;
3492 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3493 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3494 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3496 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3498 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3499 return WINED3DERR_NOTAVAILABLE
;
3503 TRACE_(d3d_caps
)("[FAILED] - Not supported for plain surfaces\n");
3504 return WINED3DERR_NOTAVAILABLE
;
3507 } else if(RType
== WINED3DRTYPE_TEXTURE
) {
3509 * - D3DUSAGE_AUTOGENMIPMAP
3510 * - D3DUSAGE_DEPTHSTENCIL
3512 * - D3DUSAGE_DYNAMIC
3513 * - D3DUSAGE_NONSECURE (d3d9ex)
3514 * - D3DUSAGE_RENDERTARGET
3515 * - D3DUSAGE_SOFTWAREPROCESSING
3516 * - D3DUSAGE_TEXTAPI (d3d9ex)
3517 * - D3DUSAGE_QUERY_WRAPANDMIP
3520 if(SurfaceType
!= SURFACE_OPENGL
) {
3521 TRACE("[FAILED]\n");
3522 return WINED3DERR_NOTAVAILABLE
;
3525 /* Check if the texture format is around */
3526 if (CheckTextureCapability(adapter
, DeviceType
, format_desc
))
3528 if(Usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
3529 /* Check for automatic mipmap generation support */
3530 if (gl_info
->supported
[SGIS_GENERATE_MIPMAP
])
3532 UsageCaps
|= WINED3DUSAGE_AUTOGENMIPMAP
;
3534 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
3535 TRACE_(d3d_caps
)("[FAILED] - No autogenmipmap support, but continuing\n");
3539 /* Always report dynamic locking */
3540 if(Usage
& WINED3DUSAGE_DYNAMIC
)
3541 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
3543 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
3544 if (CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
3546 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
3548 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
3549 return WINED3DERR_NOTAVAILABLE
;
3553 /* Always report software processing */
3554 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
3555 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
3557 /* Check QUERY_FILTER support */
3558 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
3559 if (CheckFilterCapability(adapter
, format_desc
))
3561 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
3563 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
3564 return WINED3DERR_NOTAVAILABLE
;
3568 /* Check QUERY_LEGACYBUMPMAP support */
3569 if(Usage
& WINED3DUSAGE_QUERY_LEGACYBUMPMAP
) {
3570 if (CheckBumpMapCapability(adapter
, DeviceType
, format_desc
))
3572 UsageCaps
|= WINED3DUSAGE_QUERY_LEGACYBUMPMAP
;
3574 TRACE_(d3d_caps
)("[FAILED] - No legacy bumpmap support\n");
3575 return WINED3DERR_NOTAVAILABLE
;
3579 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3580 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3581 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3583 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3585 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3586 return WINED3DERR_NOTAVAILABLE
;
3590 /* Check QUERY_SRGBREAD support */
3591 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
3592 if (CheckSrgbReadCapability(adapter
, format_desc
))
3594 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
3596 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
3597 return WINED3DERR_NOTAVAILABLE
;
3601 /* Check QUERY_SRGBWRITE support */
3602 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
3603 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
3605 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
3607 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
3608 return WINED3DERR_NOTAVAILABLE
;
3612 /* Check QUERY_VERTEXTEXTURE support */
3613 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
3614 if (CheckVertexTextureCapability(adapter
, format_desc
))
3616 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
3618 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
3619 return WINED3DERR_NOTAVAILABLE
;
3623 /* Check QUERY_WRAPANDMIP support */
3624 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
3625 if (CheckWrapAndMipCapability(adapter
, format_desc
))
3627 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
3629 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
3630 return WINED3DERR_NOTAVAILABLE
;
3634 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
3635 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, format_desc
))
3637 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
3639 TRACE_(d3d_caps
)("[FAILED] - No depth stencil support\n");
3640 return WINED3DERR_NOTAVAILABLE
;
3644 TRACE_(d3d_caps
)("[FAILED] - Texture format not supported\n");
3645 return WINED3DERR_NOTAVAILABLE
;
3647 } else if((RType
== WINED3DRTYPE_VOLUME
) || (RType
== WINED3DRTYPE_VOLUMETEXTURE
)) {
3648 /* Volume is to VolumeTexture what Surface is to Texture but its usage caps are not documented.
3649 * Most driver seem to offer (nearly) the same on Volume and VolumeTexture, so do that too.
3651 * Volumetexture allows:
3652 * - D3DUSAGE_DYNAMIC
3653 * - D3DUSAGE_NONSECURE (d3d9ex)
3654 * - D3DUSAGE_SOFTWAREPROCESSING
3655 * - D3DUSAGE_QUERY_WRAPANDMIP
3658 if(SurfaceType
!= SURFACE_OPENGL
) {
3659 TRACE("[FAILED]\n");
3660 return WINED3DERR_NOTAVAILABLE
;
3663 /* Check volume texture and volume usage caps */
3664 if (gl_info
->supported
[EXT_TEXTURE3D
])
3666 if (!CheckTextureCapability(adapter
, DeviceType
, format_desc
))
3668 TRACE_(d3d_caps
)("[FAILED] - Format not supported\n");
3669 return WINED3DERR_NOTAVAILABLE
;
3672 /* Always report dynamic locking */
3673 if(Usage
& WINED3DUSAGE_DYNAMIC
)
3674 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
3676 /* Always report software processing */
3677 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
3678 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
3680 /* Check QUERY_FILTER support */
3681 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
3682 if (CheckFilterCapability(adapter
, format_desc
))
3684 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
3686 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
3687 return WINED3DERR_NOTAVAILABLE
;
3691 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3692 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3693 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3695 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3697 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3698 return WINED3DERR_NOTAVAILABLE
;
3702 /* Check QUERY_SRGBREAD support */
3703 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
3704 if (CheckSrgbReadCapability(adapter
, format_desc
))
3706 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
3708 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
3709 return WINED3DERR_NOTAVAILABLE
;
3713 /* Check QUERY_SRGBWRITE support */
3714 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
3715 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
3717 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
3719 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
3720 return WINED3DERR_NOTAVAILABLE
;
3724 /* Check QUERY_VERTEXTEXTURE support */
3725 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
3726 if (CheckVertexTextureCapability(adapter
, format_desc
))
3728 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
3730 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
3731 return WINED3DERR_NOTAVAILABLE
;
3735 /* Check QUERY_WRAPANDMIP support */
3736 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
3737 if (CheckWrapAndMipCapability(adapter
, format_desc
))
3739 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
3741 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
3742 return WINED3DERR_NOTAVAILABLE
;
3746 TRACE_(d3d_caps
)("[FAILED] - No volume texture support\n");
3747 return WINED3DERR_NOTAVAILABLE
;
3750 /* Filter formats that need conversion; For one part, this conversion is unimplemented,
3751 * and volume textures are huge, so it would be a big performance hit. Unless we hit an
3752 * app needing one of those formats, don't advertize them to avoid leading apps into
3753 * temptation. The windows drivers don't support most of those formats on volumes anyway,
3756 switch(CheckFormat
) {
3757 case WINED3DFMT_P8_UINT
:
3758 case WINED3DFMT_L4A4_UNORM
:
3759 case WINED3DFMT_R32_FLOAT
:
3760 case WINED3DFMT_R16_FLOAT
:
3761 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM
:
3762 case WINED3DFMT_R5G5_SNORM_L6_UNORM
:
3763 case WINED3DFMT_R16G16_UNORM
:
3764 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
3765 return WINED3DERR_NOTAVAILABLE
;
3767 case WINED3DFMT_R8G8B8A8_SNORM
:
3768 case WINED3DFMT_R16G16_SNORM
:
3769 if (!gl_info
->supported
[NV_TEXTURE_SHADER
])
3771 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
3772 return WINED3DERR_NOTAVAILABLE
;
3776 case WINED3DFMT_R8G8_SNORM
:
3777 if (!gl_info
->supported
[NV_TEXTURE_SHADER
])
3779 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
3780 return WINED3DERR_NOTAVAILABLE
;
3784 case WINED3DFMT_DXT1
:
3785 case WINED3DFMT_DXT2
:
3786 case WINED3DFMT_DXT3
:
3787 case WINED3DFMT_DXT4
:
3788 case WINED3DFMT_DXT5
:
3789 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
3790 * compressed texture results in an error. While the D3D refrast does
3791 * support s3tc volumes, at least the nvidia windows driver does not, so
3792 * we're free not to support this format.
3794 TRACE_(d3d_caps
)("[FAILED] - DXTn does not support 3D textures\n");
3795 return WINED3DERR_NOTAVAILABLE
;
3798 /* Do nothing, continue with checking the format below */
3801 } else if(RType
== WINED3DRTYPE_BUFFER
){
3802 /* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
3803 TRACE_(d3d_caps
)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
3804 return WINED3DERR_NOTAVAILABLE
;
3807 /* When the UsageCaps exactly matches Usage return WINED3D_OK except for the situation in which
3808 * WINED3DUSAGE_AUTOGENMIPMAP isn't around, then WINED3DOK_NOAUTOGEN is returned if all the other
3809 * usage flags match. */
3810 if(UsageCaps
== Usage
) {
3812 } else if((UsageCaps
== (Usage
& ~WINED3DUSAGE_AUTOGENMIPMAP
)) && (Usage
& WINED3DUSAGE_AUTOGENMIPMAP
)){
3813 return WINED3DOK_NOAUTOGEN
;
3815 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
);
3816 return WINED3DERR_NOTAVAILABLE
;
3820 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D
*iface
, UINT adapter_idx
,
3821 WINED3DDEVTYPE device_type
, WINED3DFORMAT src_format
, WINED3DFORMAT dst_format
)
3823 FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
3824 iface
, adapter_idx
, debug_d3ddevicetype(device_type
), debug_d3dformat(src_format
),
3825 debug_d3dformat(dst_format
));
3830 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
3831 subset of a D3DCAPS9 structure. However, it has to come via a void *
3832 as the d3d8 interface cannot import the d3d9 header */
3833 static HRESULT WINAPI
IWineD3DImpl_GetDeviceCaps(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DCAPS
* pCaps
) {
3835 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3836 struct wined3d_adapter
*adapter
= &This
->adapters
[Adapter
];
3837 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
3838 int vs_selected_mode
;
3839 int ps_selected_mode
;
3840 struct shader_caps shader_caps
;
3841 struct fragment_caps fragment_caps
;
3842 DWORD ckey_caps
, blit_caps
, fx_caps
;
3844 TRACE_(d3d_caps
)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This
, Adapter
, DeviceType
, pCaps
);
3846 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
3847 return WINED3DERR_INVALIDCALL
;
3850 select_shader_mode(&adapter
->gl_info
, &ps_selected_mode
, &vs_selected_mode
);
3852 /* ------------------------------------------------
3853 The following fields apply to both d3d8 and d3d9
3854 ------------------------------------------------ */
3855 pCaps
->DeviceType
= (DeviceType
== WINED3DDEVTYPE_HAL
) ? WINED3DDEVTYPE_HAL
: WINED3DDEVTYPE_REF
; /* Not quite true, but use h/w supported by opengl I suppose */
3856 pCaps
->AdapterOrdinal
= Adapter
;
3859 pCaps
->Caps2
= WINED3DCAPS2_CANRENDERWINDOWED
|
3860 WINED3DCAPS2_FULLSCREENGAMMA
|
3861 WINED3DCAPS2_DYNAMICTEXTURES
;
3862 if (gl_info
->supported
[SGIS_GENERATE_MIPMAP
])
3864 pCaps
->Caps2
|= WINED3DCAPS2_CANAUTOGENMIPMAP
;
3867 pCaps
->Caps3
= WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD
|
3868 WINED3DCAPS3_COPY_TO_VIDMEM
|
3869 WINED3DCAPS3_COPY_TO_SYSTEMMEM
;
3871 pCaps
->PresentationIntervals
= WINED3DPRESENT_INTERVAL_IMMEDIATE
|
3872 WINED3DPRESENT_INTERVAL_ONE
;
3874 pCaps
->CursorCaps
= WINED3DCURSORCAPS_COLOR
|
3875 WINED3DCURSORCAPS_LOWRES
;
3877 pCaps
->DevCaps
= WINED3DDEVCAPS_FLOATTLVERTEX
|
3878 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY
|
3879 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY
|
3880 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY
|
3881 WINED3DDEVCAPS_DRAWPRIMTLVERTEX
|
3882 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT
|
3883 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY
|
3884 WINED3DDEVCAPS_PUREDEVICE
|
3885 WINED3DDEVCAPS_HWRASTERIZATION
|
3886 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY
|
3887 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY
|
3888 WINED3DDEVCAPS_CANRENDERAFTERFLIP
|
3889 WINED3DDEVCAPS_DRAWPRIMITIVES2
|
3890 WINED3DDEVCAPS_DRAWPRIMITIVES2EX
|
3891 WINED3DDEVCAPS_RTPATCHES
;
3893 pCaps
->PrimitiveMiscCaps
= WINED3DPMISCCAPS_CULLNONE
|
3894 WINED3DPMISCCAPS_CULLCCW
|
3895 WINED3DPMISCCAPS_CULLCW
|
3896 WINED3DPMISCCAPS_COLORWRITEENABLE
|
3897 WINED3DPMISCCAPS_CLIPTLVERTS
|
3898 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS
|
3899 WINED3DPMISCCAPS_MASKZ
|
3900 WINED3DPMISCCAPS_BLENDOP
|
3901 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING
;
3903 WINED3DPMISCCAPS_NULLREFERENCE
3904 WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
3905 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
3906 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
3907 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
3909 if (gl_info
->supported
[EXT_BLEND_EQUATION_SEPARATE
] && gl_info
->supported
[EXT_BLEND_FUNC_SEPARATE
])
3910 pCaps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_SEPARATEALPHABLEND
;
3912 pCaps
->RasterCaps
= WINED3DPRASTERCAPS_DITHER
|
3913 WINED3DPRASTERCAPS_PAT
|
3914 WINED3DPRASTERCAPS_WFOG
|
3915 WINED3DPRASTERCAPS_ZFOG
|
3916 WINED3DPRASTERCAPS_FOGVERTEX
|
3917 WINED3DPRASTERCAPS_FOGTABLE
|
3918 WINED3DPRASTERCAPS_STIPPLE
|
3919 WINED3DPRASTERCAPS_SUBPIXEL
|
3920 WINED3DPRASTERCAPS_ZTEST
|
3921 WINED3DPRASTERCAPS_SCISSORTEST
|
3922 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS
|
3923 WINED3DPRASTERCAPS_DEPTHBIAS
;
3925 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
3927 pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_ANISOTROPY
|
3928 WINED3DPRASTERCAPS_ZBIAS
|
3929 WINED3DPRASTERCAPS_MIPMAPLODBIAS
;
3931 if (gl_info
->supported
[NV_FOG_DISTANCE
])
3933 pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_FOGRANGE
;
3936 WINED3DPRASTERCAPS_COLORPERSPECTIVE
3937 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
3938 WINED3DPRASTERCAPS_ANTIALIASEDGES
3939 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
3940 WINED3DPRASTERCAPS_WBUFFER */
3942 pCaps
->ZCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
3943 WINED3DPCMPCAPS_EQUAL
|
3944 WINED3DPCMPCAPS_GREATER
|
3945 WINED3DPCMPCAPS_GREATEREQUAL
|
3946 WINED3DPCMPCAPS_LESS
|
3947 WINED3DPCMPCAPS_LESSEQUAL
|
3948 WINED3DPCMPCAPS_NEVER
|
3949 WINED3DPCMPCAPS_NOTEQUAL
;
3951 pCaps
->SrcBlendCaps
= WINED3DPBLENDCAPS_BOTHINVSRCALPHA
|
3952 WINED3DPBLENDCAPS_BOTHSRCALPHA
|
3953 WINED3DPBLENDCAPS_DESTALPHA
|
3954 WINED3DPBLENDCAPS_DESTCOLOR
|
3955 WINED3DPBLENDCAPS_INVDESTALPHA
|
3956 WINED3DPBLENDCAPS_INVDESTCOLOR
|
3957 WINED3DPBLENDCAPS_INVSRCALPHA
|
3958 WINED3DPBLENDCAPS_INVSRCCOLOR
|
3959 WINED3DPBLENDCAPS_ONE
|
3960 WINED3DPBLENDCAPS_SRCALPHA
|
3961 WINED3DPBLENDCAPS_SRCALPHASAT
|
3962 WINED3DPBLENDCAPS_SRCCOLOR
|
3963 WINED3DPBLENDCAPS_ZERO
;
3965 pCaps
->DestBlendCaps
= WINED3DPBLENDCAPS_DESTALPHA
|
3966 WINED3DPBLENDCAPS_DESTCOLOR
|
3967 WINED3DPBLENDCAPS_INVDESTALPHA
|
3968 WINED3DPBLENDCAPS_INVDESTCOLOR
|
3969 WINED3DPBLENDCAPS_INVSRCALPHA
|
3970 WINED3DPBLENDCAPS_INVSRCCOLOR
|
3971 WINED3DPBLENDCAPS_ONE
|
3972 WINED3DPBLENDCAPS_SRCALPHA
|
3973 WINED3DPBLENDCAPS_SRCCOLOR
|
3974 WINED3DPBLENDCAPS_ZERO
;
3975 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
3976 * according to the glBlendFunc manpage
3978 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
3979 * legacy settings for srcblend only
3982 if (gl_info
->supported
[EXT_BLEND_COLOR
])
3984 pCaps
->SrcBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
3985 pCaps
->DestBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
3989 pCaps
->AlphaCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
3990 WINED3DPCMPCAPS_EQUAL
|
3991 WINED3DPCMPCAPS_GREATER
|
3992 WINED3DPCMPCAPS_GREATEREQUAL
|
3993 WINED3DPCMPCAPS_LESS
|
3994 WINED3DPCMPCAPS_LESSEQUAL
|
3995 WINED3DPCMPCAPS_NEVER
|
3996 WINED3DPCMPCAPS_NOTEQUAL
;
3998 pCaps
->ShadeCaps
= WINED3DPSHADECAPS_SPECULARGOURAUDRGB
|
3999 WINED3DPSHADECAPS_COLORGOURAUDRGB
|
4000 WINED3DPSHADECAPS_ALPHAFLATBLEND
|
4001 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND
|
4002 WINED3DPSHADECAPS_COLORFLATRGB
|
4003 WINED3DPSHADECAPS_FOGFLAT
|
4004 WINED3DPSHADECAPS_FOGGOURAUD
|
4005 WINED3DPSHADECAPS_SPECULARFLATRGB
;
4007 pCaps
->TextureCaps
= WINED3DPTEXTURECAPS_ALPHA
|
4008 WINED3DPTEXTURECAPS_ALPHAPALETTE
|
4009 WINED3DPTEXTURECAPS_TRANSPARENCY
|
4010 WINED3DPTEXTURECAPS_BORDER
|
4011 WINED3DPTEXTURECAPS_MIPMAP
|
4012 WINED3DPTEXTURECAPS_PROJECTED
|
4013 WINED3DPTEXTURECAPS_PERSPECTIVE
;
4015 if (!gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
])
4017 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_POW2
|
4018 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL
;
4021 if (gl_info
->supported
[EXT_TEXTURE3D
])
4023 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_VOLUMEMAP
|
4024 WINED3DPTEXTURECAPS_MIPVOLUMEMAP
|
4025 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2
;
4028 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
4030 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_CUBEMAP
|
4031 WINED3DPTEXTURECAPS_MIPCUBEMAP
|
4032 WINED3DPTEXTURECAPS_CUBEMAP_POW2
;
4036 pCaps
->TextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
4037 WINED3DPTFILTERCAPS_MAGFPOINT
|
4038 WINED3DPTFILTERCAPS_MINFLINEAR
|
4039 WINED3DPTFILTERCAPS_MINFPOINT
|
4040 WINED3DPTFILTERCAPS_MIPFLINEAR
|
4041 WINED3DPTFILTERCAPS_MIPFPOINT
|
4042 WINED3DPTFILTERCAPS_LINEAR
|
4043 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
4044 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
4045 WINED3DPTFILTERCAPS_MIPLINEAR
|
4046 WINED3DPTFILTERCAPS_MIPNEAREST
|
4047 WINED3DPTFILTERCAPS_NEAREST
;
4049 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
4051 pCaps
->TextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
4052 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
4055 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
4057 pCaps
->CubeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
4058 WINED3DPTFILTERCAPS_MAGFPOINT
|
4059 WINED3DPTFILTERCAPS_MINFLINEAR
|
4060 WINED3DPTFILTERCAPS_MINFPOINT
|
4061 WINED3DPTFILTERCAPS_MIPFLINEAR
|
4062 WINED3DPTFILTERCAPS_MIPFPOINT
|
4063 WINED3DPTFILTERCAPS_LINEAR
|
4064 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
4065 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
4066 WINED3DPTFILTERCAPS_MIPLINEAR
|
4067 WINED3DPTFILTERCAPS_MIPNEAREST
|
4068 WINED3DPTFILTERCAPS_NEAREST
;
4070 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
4072 pCaps
->CubeTextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
4073 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
4076 pCaps
->CubeTextureFilterCaps
= 0;
4078 if (gl_info
->supported
[EXT_TEXTURE3D
])
4080 pCaps
->VolumeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
4081 WINED3DPTFILTERCAPS_MAGFPOINT
|
4082 WINED3DPTFILTERCAPS_MINFLINEAR
|
4083 WINED3DPTFILTERCAPS_MINFPOINT
|
4084 WINED3DPTFILTERCAPS_MIPFLINEAR
|
4085 WINED3DPTFILTERCAPS_MIPFPOINT
|
4086 WINED3DPTFILTERCAPS_LINEAR
|
4087 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
4088 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
4089 WINED3DPTFILTERCAPS_MIPLINEAR
|
4090 WINED3DPTFILTERCAPS_MIPNEAREST
|
4091 WINED3DPTFILTERCAPS_NEAREST
;
4093 pCaps
->VolumeTextureFilterCaps
= 0;
4095 pCaps
->TextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
4096 WINED3DPTADDRESSCAPS_CLAMP
|
4097 WINED3DPTADDRESSCAPS_WRAP
;
4099 if (gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
])
4101 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
4103 if (gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
])
4105 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
4107 if (gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
])
4109 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
4112 if (gl_info
->supported
[EXT_TEXTURE3D
])
4114 pCaps
->VolumeTextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
4115 WINED3DPTADDRESSCAPS_CLAMP
|
4116 WINED3DPTADDRESSCAPS_WRAP
;
4117 if (gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
])
4119 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
4121 if (gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
])
4123 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
4125 if (gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
])
4127 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
4130 pCaps
->VolumeTextureAddressCaps
= 0;
4132 pCaps
->LineCaps
= WINED3DLINECAPS_TEXTURE
|
4133 WINED3DLINECAPS_ZTEST
|
4134 WINED3DLINECAPS_BLEND
|
4135 WINED3DLINECAPS_ALPHACMP
|
4136 WINED3DLINECAPS_FOG
;
4137 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4138 * idea how generating the smoothing alpha values works; the result is different
4141 pCaps
->MaxTextureWidth
= gl_info
->limits
.texture_size
;
4142 pCaps
->MaxTextureHeight
= gl_info
->limits
.texture_size
;
4144 if (gl_info
->supported
[EXT_TEXTURE3D
])
4145 pCaps
->MaxVolumeExtent
= gl_info
->limits
.texture3d_size
;
4147 pCaps
->MaxVolumeExtent
= 0;
4149 pCaps
->MaxTextureRepeat
= 32768;
4150 pCaps
->MaxTextureAspectRatio
= gl_info
->limits
.texture_size
;
4151 pCaps
->MaxVertexW
= 1.0f
;
4153 pCaps
->GuardBandLeft
= 0.0f
;
4154 pCaps
->GuardBandTop
= 0.0f
;
4155 pCaps
->GuardBandRight
= 0.0f
;
4156 pCaps
->GuardBandBottom
= 0.0f
;
4158 pCaps
->ExtentsAdjust
= 0.0f
;
4160 pCaps
->StencilCaps
= WINED3DSTENCILCAPS_DECRSAT
|
4161 WINED3DSTENCILCAPS_INCRSAT
|
4162 WINED3DSTENCILCAPS_INVERT
|
4163 WINED3DSTENCILCAPS_KEEP
|
4164 WINED3DSTENCILCAPS_REPLACE
|
4165 WINED3DSTENCILCAPS_ZERO
;
4166 if (gl_info
->supported
[EXT_STENCIL_WRAP
])
4168 pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_DECR
|
4169 WINED3DSTENCILCAPS_INCR
;
4171 if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
] || gl_info
->supported
[ATI_SEPARATE_STENCIL
])
4173 pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_TWOSIDED
;
4176 pCaps
->FVFCaps
= WINED3DFVFCAPS_PSIZE
| 0x0008; /* 8 texture coords */
4178 pCaps
->MaxUserClipPlanes
= gl_info
->limits
.clipplanes
;
4179 pCaps
->MaxActiveLights
= gl_info
->limits
.lights
;
4181 pCaps
->MaxVertexBlendMatrices
= gl_info
->limits
.blends
;
4182 pCaps
->MaxVertexBlendMatrixIndex
= 0;
4184 pCaps
->MaxAnisotropy
= gl_info
->limits
.anisotropy
;
4185 pCaps
->MaxPointSize
= gl_info
->limits
.pointsize_max
;
4188 /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4189 pCaps
->VertexProcessingCaps
= WINED3DVTXPCAPS_DIRECTIONALLIGHTS
|
4190 WINED3DVTXPCAPS_MATERIALSOURCE7
|
4191 WINED3DVTXPCAPS_POSITIONALLIGHTS
|
4192 WINED3DVTXPCAPS_LOCALVIEWER
|
4193 WINED3DVTXPCAPS_VERTEXFOG
|
4194 WINED3DVTXPCAPS_TEXGEN
;
4196 pCaps
->MaxPrimitiveCount
= 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4197 pCaps
->MaxVertexIndex
= 0xFFFFF;
4198 pCaps
->MaxStreams
= MAX_STREAMS
;
4199 pCaps
->MaxStreamStride
= 1024;
4201 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4202 pCaps
->DevCaps2
= WINED3DDEVCAPS2_STREAMOFFSET
|
4203 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET
;
4204 pCaps
->MaxNpatchTessellationLevel
= 0;
4205 pCaps
->MasterAdapterOrdinal
= 0;
4206 pCaps
->AdapterOrdinalInGroup
= 0;
4207 pCaps
->NumberOfAdaptersInGroup
= 1;
4209 pCaps
->NumSimultaneousRTs
= gl_info
->limits
.buffers
;
4211 pCaps
->StretchRectFilterCaps
= WINED3DPTFILTERCAPS_MINFPOINT
|
4212 WINED3DPTFILTERCAPS_MAGFPOINT
|
4213 WINED3DPTFILTERCAPS_MINFLINEAR
|
4214 WINED3DPTFILTERCAPS_MAGFLINEAR
;
4215 pCaps
->VertexTextureFilterCaps
= 0;
4217 memset(&shader_caps
, 0, sizeof(shader_caps
));
4218 adapter
->shader_backend
->shader_get_caps(&adapter
->gl_info
, &shader_caps
);
4220 memset(&fragment_caps
, 0, sizeof(fragment_caps
));
4221 adapter
->fragment_pipe
->get_caps(&adapter
->gl_info
, &fragment_caps
);
4223 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4224 pCaps
->PrimitiveMiscCaps
|= fragment_caps
.PrimitiveMiscCaps
;
4226 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4227 * Ignore shader model capabilities if disabled in config
4229 if(vs_selected_mode
== SHADER_NONE
) {
4230 TRACE_(d3d_caps
)("Vertex shader disabled in config, reporting version 0.0\n");
4231 pCaps
->VertexShaderVersion
= WINED3DVS_VERSION(0,0);
4232 pCaps
->MaxVertexShaderConst
= 0;
4234 pCaps
->VertexShaderVersion
= shader_caps
.VertexShaderVersion
;
4235 pCaps
->MaxVertexShaderConst
= shader_caps
.MaxVertexShaderConst
;
4238 if(ps_selected_mode
== SHADER_NONE
) {
4239 TRACE_(d3d_caps
)("Pixel shader disabled in config, reporting version 0.0\n");
4240 pCaps
->PixelShaderVersion
= WINED3DPS_VERSION(0,0);
4241 pCaps
->PixelShader1xMaxValue
= 0.0f
;
4243 pCaps
->PixelShaderVersion
= shader_caps
.PixelShaderVersion
;
4244 pCaps
->PixelShader1xMaxValue
= shader_caps
.PixelShader1xMaxValue
;
4247 pCaps
->TextureOpCaps
= fragment_caps
.TextureOpCaps
;
4248 pCaps
->MaxTextureBlendStages
= fragment_caps
.MaxTextureBlendStages
;
4249 pCaps
->MaxSimultaneousTextures
= fragment_caps
.MaxSimultaneousTextures
;
4251 pCaps
->VS20Caps
= shader_caps
.VS20Caps
;
4252 pCaps
->MaxVShaderInstructionsExecuted
= shader_caps
.MaxVShaderInstructionsExecuted
;
4253 pCaps
->MaxVertexShader30InstructionSlots
= shader_caps
.MaxVertexShader30InstructionSlots
;
4254 pCaps
->PS20Caps
= shader_caps
.PS20Caps
;
4255 pCaps
->MaxPShaderInstructionsExecuted
= shader_caps
.MaxPShaderInstructionsExecuted
;
4256 pCaps
->MaxPixelShader30InstructionSlots
= shader_caps
.MaxPixelShader30InstructionSlots
;
4258 /* The following caps are shader specific, but they are things we cannot detect, or which
4259 * are the same among all shader models. So to avoid code duplication set the shader version
4260 * specific, but otherwise constant caps here
4262 if(pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(3,0)) {
4263 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4264 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4265 pCaps
->VS20Caps
.Caps
= WINED3DVS20CAPS_PREDICATION
;
4266 pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4267 pCaps
->VS20Caps
.NumTemps
= max(32, adapter
->gl_info
.limits
.arb_vs_temps
);
4268 pCaps
->VS20Caps
.StaticFlowControlDepth
= WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH
; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4270 pCaps
->MaxVShaderInstructionsExecuted
= 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4271 pCaps
->MaxVertexShader30InstructionSlots
= max(512, adapter
->gl_info
.limits
.arb_vs_instructions
);
4273 else if (pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(2,0))
4275 pCaps
->VS20Caps
.Caps
= 0;
4276 pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH
;
4277 pCaps
->VS20Caps
.NumTemps
= max(12, adapter
->gl_info
.limits
.arb_vs_temps
);
4278 pCaps
->VS20Caps
.StaticFlowControlDepth
= 1;
4280 pCaps
->MaxVShaderInstructionsExecuted
= 65535;
4281 pCaps
->MaxVertexShader30InstructionSlots
= 0;
4282 } else { /* VS 1.x */
4283 pCaps
->VS20Caps
.Caps
= 0;
4284 pCaps
->VS20Caps
.DynamicFlowControlDepth
= 0;
4285 pCaps
->VS20Caps
.NumTemps
= 0;
4286 pCaps
->VS20Caps
.StaticFlowControlDepth
= 0;
4288 pCaps
->MaxVShaderInstructionsExecuted
= 0;
4289 pCaps
->MaxVertexShader30InstructionSlots
= 0;
4292 if(pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(3,0)) {
4293 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4294 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4296 /* 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 */
4297 pCaps
->PS20Caps
.Caps
= WINED3DPS20CAPS_ARBITRARYSWIZZLE
|
4298 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS
|
4299 WINED3DPS20CAPS_PREDICATION
|
4300 WINED3DPS20CAPS_NODEPENDENTREADLIMIT
|
4301 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
;
4302 pCaps
->PS20Caps
.DynamicFlowControlDepth
= WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4303 pCaps
->PS20Caps
.NumTemps
= max(32, adapter
->gl_info
.limits
.arb_ps_temps
);
4304 pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4305 pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS
; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4307 pCaps
->MaxPShaderInstructionsExecuted
= 65535;
4308 pCaps
->MaxPixelShader30InstructionSlots
= max(WINED3DMIN30SHADERINSTRUCTIONS
,
4309 adapter
->gl_info
.limits
.arb_ps_instructions
);
4311 else if(pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(2,0))
4313 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4314 pCaps
->PS20Caps
.Caps
= 0;
4315 pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4316 pCaps
->PS20Caps
.NumTemps
= max(12, adapter
->gl_info
.limits
.arb_ps_temps
);
4317 pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH
; /* Minimum: 1 */
4318 pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS
; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4320 pCaps
->MaxPShaderInstructionsExecuted
= 512; /* Minimum value, a GeforceFX uses 1024 */
4321 pCaps
->MaxPixelShader30InstructionSlots
= 0;
4322 } else { /* PS 1.x */
4323 pCaps
->PS20Caps
.Caps
= 0;
4324 pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0;
4325 pCaps
->PS20Caps
.NumTemps
= 0;
4326 pCaps
->PS20Caps
.StaticFlowControlDepth
= 0;
4327 pCaps
->PS20Caps
.NumInstructionSlots
= 0;
4329 pCaps
->MaxPShaderInstructionsExecuted
= 0;
4330 pCaps
->MaxPixelShader30InstructionSlots
= 0;
4333 if(pCaps
->VertexShaderVersion
>= WINED3DVS_VERSION(2,0)) {
4334 /* OpenGL supports all the formats below, perhaps not always
4335 * without conversion, but it supports them.
4336 * Further GLSL doesn't seem to have an official unsigned type so
4337 * don't advertise it yet as I'm not sure how we handle it.
4338 * We might need to add some clamping in the shader engine to
4340 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4341 pCaps
->DeclTypes
= WINED3DDTCAPS_UBYTE4
|
4342 WINED3DDTCAPS_UBYTE4N
|
4343 WINED3DDTCAPS_SHORT2N
|
4344 WINED3DDTCAPS_SHORT4N
;
4345 if (gl_info
->supported
[ARB_HALF_FLOAT_VERTEX
])
4347 pCaps
->DeclTypes
|= WINED3DDTCAPS_FLOAT16_2
|
4348 WINED3DDTCAPS_FLOAT16_4
;
4351 pCaps
->DeclTypes
= 0;
4353 /* Set DirectDraw helper Caps */
4354 ckey_caps
= WINEDDCKEYCAPS_DESTBLT
|
4355 WINEDDCKEYCAPS_SRCBLT
;
4356 fx_caps
= WINEDDFXCAPS_BLTALPHA
|
4357 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT
|
4358 WINEDDFXCAPS_BLTMIRRORUPDOWN
|
4359 WINEDDFXCAPS_BLTROTATION90
|
4360 WINEDDFXCAPS_BLTSHRINKX
|
4361 WINEDDFXCAPS_BLTSHRINKXN
|
4362 WINEDDFXCAPS_BLTSHRINKY
|
4363 WINEDDFXCAPS_BLTSHRINKXN
|
4364 WINEDDFXCAPS_BLTSTRETCHX
|
4365 WINEDDFXCAPS_BLTSTRETCHXN
|
4366 WINEDDFXCAPS_BLTSTRETCHY
|
4367 WINEDDFXCAPS_BLTSTRETCHYN
;
4368 blit_caps
= WINEDDCAPS_BLT
|
4369 WINEDDCAPS_BLTCOLORFILL
|
4370 WINEDDCAPS_BLTDEPTHFILL
|
4371 WINEDDCAPS_BLTSTRETCH
|
4372 WINEDDCAPS_CANBLTSYSMEM
|
4373 WINEDDCAPS_CANCLIP
|
4374 WINEDDCAPS_CANCLIPSTRETCHED
|
4375 WINEDDCAPS_COLORKEY
|
4376 WINEDDCAPS_COLORKEYHWASSIST
|
4377 WINEDDCAPS_ALIGNBOUNDARYSRC
;
4379 /* Fill the ddraw caps structure */
4380 pCaps
->DirectDrawCaps
.Caps
= WINEDDCAPS_GDI
|
4381 WINEDDCAPS_PALETTE
|
4383 pCaps
->DirectDrawCaps
.Caps2
= WINEDDCAPS2_CERTIFIED
|
4384 WINEDDCAPS2_NOPAGELOCKREQUIRED
|
4385 WINEDDCAPS2_PRIMARYGAMMA
|
4386 WINEDDCAPS2_WIDESURFACES
|
4387 WINEDDCAPS2_CANRENDERWINDOWED
;
4388 pCaps
->DirectDrawCaps
.SVBCaps
= blit_caps
;
4389 pCaps
->DirectDrawCaps
.SVBCKeyCaps
= ckey_caps
;
4390 pCaps
->DirectDrawCaps
.SVBFXCaps
= fx_caps
;
4391 pCaps
->DirectDrawCaps
.VSBCaps
= blit_caps
;
4392 pCaps
->DirectDrawCaps
.VSBCKeyCaps
= ckey_caps
;
4393 pCaps
->DirectDrawCaps
.VSBFXCaps
= fx_caps
;
4394 pCaps
->DirectDrawCaps
.SSBCaps
= blit_caps
;
4395 pCaps
->DirectDrawCaps
.SSBCKeyCaps
= ckey_caps
;
4396 pCaps
->DirectDrawCaps
.SSBFXCaps
= fx_caps
;
4398 pCaps
->DirectDrawCaps
.ddsCaps
= WINEDDSCAPS_ALPHA
|
4399 WINEDDSCAPS_BACKBUFFER
|
4401 WINEDDSCAPS_FRONTBUFFER
|
4402 WINEDDSCAPS_OFFSCREENPLAIN
|
4403 WINEDDSCAPS_PALETTE
|
4404 WINEDDSCAPS_PRIMARYSURFACE
|
4405 WINEDDSCAPS_SYSTEMMEMORY
|
4406 WINEDDSCAPS_VIDEOMEMORY
|
4407 WINEDDSCAPS_VISIBLE
;
4408 pCaps
->DirectDrawCaps
.StrideAlign
= DDRAW_PITCH_ALIGNMENT
;
4410 /* Set D3D caps if OpenGL is available. */
4411 if (adapter
->opengl
)
4413 pCaps
->DirectDrawCaps
.ddsCaps
|=WINEDDSCAPS_3DDEVICE
|
4414 WINEDDSCAPS_MIPMAP
|
4415 WINEDDSCAPS_TEXTURE
|
4416 WINEDDSCAPS_ZBUFFER
;
4417 pCaps
->DirectDrawCaps
.Caps
|= WINEDDCAPS_3D
;
4423 static HRESULT WINAPI
IWineD3DImpl_CreateDevice(IWineD3D
*iface
, UINT adapter_idx
,
4424 WINED3DDEVTYPE device_type
, HWND focus_window
, DWORD flags
, IUnknown
*parent
,
4425 IWineD3DDeviceParent
*device_parent
, IWineD3DDevice
**device
)
4427 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
4428 IWineD3DDeviceImpl
*object
;
4431 TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x.\n"
4432 "parent %p, device_parent %p, device %p.\n",
4433 iface
, adapter_idx
, device_type
, focus_window
, flags
,
4434 parent
, device_parent
, device
);
4436 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4437 * number and create a device without a 3D adapter for 2D only operation. */
4438 if (IWineD3D_GetAdapterCount(iface
) && adapter_idx
>= IWineD3D_GetAdapterCount(iface
))
4440 return WINED3DERR_INVALIDCALL
;
4443 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
4446 ERR("Failed to allocate device memory.\n");
4447 return E_OUTOFMEMORY
;
4450 hr
= device_init(object
, This
, adapter_idx
, device_type
, focus_window
, flags
, parent
, device_parent
);
4453 WARN("Failed to initialize device, hr %#x.\n", hr
);
4454 HeapFree(GetProcessHeap(), 0, object
);
4458 TRACE("Created device %p.\n", object
);
4459 *device
= (IWineD3DDevice
*)object
;
4461 IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent
, *device
);
4466 static HRESULT WINAPI
IWineD3DImpl_GetParent(IWineD3D
*iface
, IUnknown
**pParent
) {
4467 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
4468 IUnknown_AddRef(This
->parent
);
4469 *pParent
= This
->parent
;
4473 static void WINE_GLAPI
invalid_func(const void *data
)
4475 ERR("Invalid vertex attribute function called\n");
4479 static void WINE_GLAPI
invalid_texcoord_func(GLenum unit
, const void *data
)
4481 ERR("Invalid texcoord function called\n");
4485 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4486 * the extension detection and are used in drawStridedSlow
4488 static void WINE_GLAPI
position_d3dcolor(const void *data
)
4490 DWORD pos
= *((const DWORD
*)data
);
4492 FIXME("Add a test for fixed function position from d3dcolor type\n");
4493 glVertex4s(D3DCOLOR_B_R(pos
),
4499 static void WINE_GLAPI
position_float4(const void *data
)
4501 const GLfloat
*pos
= data
;
4503 if (pos
[3] != 0.0f
&& pos
[3] != 1.0f
)
4505 float w
= 1.0f
/ pos
[3];
4507 glVertex4f(pos
[0] * w
, pos
[1] * w
, pos
[2] * w
, w
);
4515 static void WINE_GLAPI
diffuse_d3dcolor(const void *data
)
4517 DWORD diffuseColor
= *((const DWORD
*)data
);
4519 glColor4ub(D3DCOLOR_B_R(diffuseColor
),
4520 D3DCOLOR_B_G(diffuseColor
),
4521 D3DCOLOR_B_B(diffuseColor
),
4522 D3DCOLOR_B_A(diffuseColor
));
4525 static void WINE_GLAPI
specular_d3dcolor(const void *data
)
4527 DWORD specularColor
= *((const DWORD
*)data
);
4528 GLbyte d
[] = {D3DCOLOR_B_R(specularColor
),
4529 D3DCOLOR_B_G(specularColor
),
4530 D3DCOLOR_B_B(specularColor
)};
4532 specular_func_3ubv(d
);
4535 static void WINE_GLAPI
warn_no_specular_func(const void *data
)
4537 WARN("GL_EXT_secondary_color not supported\n");
4540 static void fillGLAttribFuncs(const struct wined3d_gl_info
*gl_info
)
4542 position_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4543 position_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4544 position_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)glVertex3fv
;
4545 position_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = position_float4
;
4546 position_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = position_d3dcolor
;
4547 position_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4548 position_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4549 position_funcs
[WINED3D_FFP_EMIT_SHORT4
] = (glAttribFunc
)glVertex2sv
;
4550 position_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_func
;
4551 position_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4552 position_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_func
;
4553 position_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4554 position_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_func
;
4555 position_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4556 position_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4557 position_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4558 position_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4560 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4561 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4562 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)glColor3fv
;
4563 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = (glAttribFunc
)glColor4fv
;
4564 diffuse_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = diffuse_d3dcolor
;
4565 diffuse_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4566 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4567 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT4
] = invalid_func
;
4568 diffuse_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = (glAttribFunc
)glColor4ubv
;
4569 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4570 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = (glAttribFunc
)glColor4sv
;
4571 diffuse_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4572 diffuse_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = (glAttribFunc
)glColor4usv
;
4573 diffuse_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4574 diffuse_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4575 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4576 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4578 /* No 4 component entry points here */
4579 specular_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4580 specular_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4581 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4583 specular_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)GL_EXTCALL(glSecondaryColor3fvEXT
);
4587 specular_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = warn_no_specular_func
;
4589 specular_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = invalid_func
;
4590 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4592 specular_func_3ubv
= (glAttribFunc
)GL_EXTCALL(glSecondaryColor3ubvEXT
);
4593 specular_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = specular_d3dcolor
;
4597 specular_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = warn_no_specular_func
;
4599 specular_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4600 specular_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4601 specular_funcs
[WINED3D_FFP_EMIT_SHORT4
] = invalid_func
;
4602 specular_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_func
;
4603 specular_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4604 specular_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_func
;
4605 specular_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4606 specular_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_func
;
4607 specular_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4608 specular_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4609 specular_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4610 specular_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4612 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4613 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4615 normal_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4616 normal_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4617 normal_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)glNormal3fv
;
4618 normal_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = (glAttribFunc
)glNormal3fv
; /* Just ignore the 4th value */
4619 normal_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = invalid_func
;
4620 normal_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4621 normal_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4622 normal_funcs
[WINED3D_FFP_EMIT_SHORT4
] = invalid_func
;
4623 normal_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_func
;
4624 normal_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4625 normal_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_func
;
4626 normal_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4627 normal_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_func
;
4628 normal_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4629 normal_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4630 normal_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4631 normal_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4633 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord1fvARB
);
4634 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2fvARB
);
4635 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord3fvARB
);
4636 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4fvARB
);
4637 multi_texcoord_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = invalid_texcoord_func
;
4638 multi_texcoord_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_texcoord_func
;
4639 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2svARB
);
4640 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4svARB
);
4641 multi_texcoord_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_texcoord_func
;
4642 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_texcoord_func
;
4643 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_texcoord_func
;
4644 multi_texcoord_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_texcoord_func
;
4645 multi_texcoord_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_texcoord_func
;
4646 multi_texcoord_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_texcoord_func
;
4647 multi_texcoord_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_texcoord_func
;
4648 if (gl_info
->supported
[NV_HALF_FLOAT
])
4650 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
4651 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2hvNV
);
4652 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4hvNV
);
4654 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_texcoord_func
;
4655 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_texcoord_func
;
4659 BOOL
InitAdapters(IWineD3DImpl
*This
)
4661 static HMODULE mod_gl
;
4663 int ps_selected_mode
, vs_selected_mode
;
4665 /* No need to hold any lock. The calling library makes sure only one thread calls
4666 * wined3d simultaneously
4669 TRACE("Initializing adapters\n");
4672 #ifdef USE_WIN32_OPENGL
4673 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
4674 mod_gl
= LoadLibraryA("opengl32.dll");
4676 ERR("Can't load opengl32.dll!\n");
4680 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
4681 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
4682 mod_gl
= GetModuleHandleA("gdi32.dll");
4686 /* Load WGL core functions from opengl32.dll */
4687 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
4691 if(!pwglGetProcAddress
) {
4692 ERR("Unable to load wglGetProcAddress!\n");
4696 /* Dynamically load all GL core functions */
4700 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
4701 * otherwise because we have to use winex11.drv's override
4703 #ifdef USE_WIN32_OPENGL
4704 wglFinish
= (void*)GetProcAddress(mod_gl
, "glFinish");
4705 wglFlush
= (void*)GetProcAddress(mod_gl
, "glFlush");
4707 wglFinish
= (void*)pwglGetProcAddress("wglFinish");
4708 wglFlush
= (void*)pwglGetProcAddress("wglFlush");
4711 glEnableWINE
= glEnable
;
4712 glDisableWINE
= glDisable
;
4714 /* For now only one default adapter */
4716 struct wined3d_adapter
*adapter
= &This
->adapters
[0];
4717 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
4718 struct wined3d_fake_gl_ctx fake_gl_ctx
= {0};
4722 WineD3D_PixelFormat
*cfgs
;
4723 DISPLAY_DEVICEW DisplayDevice
;
4726 TRACE("Initializing default adapter\n");
4727 adapter
->ordinal
= 0;
4728 adapter
->monitorPoint
.x
= -1;
4729 adapter
->monitorPoint
.y
= -1;
4731 if (!AllocateLocallyUniqueId(&adapter
->luid
))
4733 DWORD err
= GetLastError();
4734 ERR("Failed to set adapter LUID (%#x).\n", err
);
4737 TRACE("Allocated LUID %08x:%08x for adapter.\n",
4738 adapter
->luid
.HighPart
, adapter
->luid
.LowPart
);
4740 if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx
))
4742 ERR("Failed to get a gl context for default adapter\n");
4746 ret
= IWineD3DImpl_FillGLCaps(adapter
);
4748 ERR("Failed to initialize gl caps for default adapter\n");
4749 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4752 ret
= initPixelFormats(&adapter
->gl_info
, adapter
->driver_info
.vendor
);
4754 ERR("Failed to init gl formats\n");
4755 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4759 hdc
= fake_gl_ctx
.dc
;
4761 /* Use the VideoRamSize registry setting when set */
4762 if(wined3d_settings
.emulated_textureram
)
4763 adapter
->TextureRam
= wined3d_settings
.emulated_textureram
;
4765 adapter
->TextureRam
= adapter
->gl_info
.vidmem
;
4766 adapter
->UsedTextureRam
= 0;
4767 TRACE("Emulating %dMB of texture ram\n", adapter
->TextureRam
/(1024*1024));
4769 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
4770 DisplayDevice
.cb
= sizeof(DisplayDevice
);
4771 EnumDisplayDevicesW(NULL
, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice
, 0);
4772 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice
.DeviceName
));
4773 strcpyW(adapter
->DeviceName
, DisplayDevice
.DeviceName
);
4775 if (gl_info
->supported
[WGL_ARB_PIXEL_FORMAT
])
4782 attribute
= WGL_NUMBER_PIXEL_FORMATS_ARB
;
4783 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, 0, 0, 1, &attribute
, &adapter
->nCfgs
));
4785 adapter
->cfgs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, adapter
->nCfgs
*sizeof(WineD3D_PixelFormat
));
4786 cfgs
= adapter
->cfgs
;
4787 attribs
[nAttribs
++] = WGL_RED_BITS_ARB
;
4788 attribs
[nAttribs
++] = WGL_GREEN_BITS_ARB
;
4789 attribs
[nAttribs
++] = WGL_BLUE_BITS_ARB
;
4790 attribs
[nAttribs
++] = WGL_ALPHA_BITS_ARB
;
4791 attribs
[nAttribs
++] = WGL_COLOR_BITS_ARB
;
4792 attribs
[nAttribs
++] = WGL_DEPTH_BITS_ARB
;
4793 attribs
[nAttribs
++] = WGL_STENCIL_BITS_ARB
;
4794 attribs
[nAttribs
++] = WGL_DRAW_TO_WINDOW_ARB
;
4795 attribs
[nAttribs
++] = WGL_PIXEL_TYPE_ARB
;
4796 attribs
[nAttribs
++] = WGL_DOUBLE_BUFFER_ARB
;
4797 attribs
[nAttribs
++] = WGL_AUX_BUFFERS_ARB
;
4799 for (iPixelFormat
=1; iPixelFormat
<= adapter
->nCfgs
; ++iPixelFormat
)
4801 res
= GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, nAttribs
, attribs
, values
));
4806 /* Cache the pixel format */
4807 cfgs
->iPixelFormat
= iPixelFormat
;
4808 cfgs
->redSize
= values
[0];
4809 cfgs
->greenSize
= values
[1];
4810 cfgs
->blueSize
= values
[2];
4811 cfgs
->alphaSize
= values
[3];
4812 cfgs
->colorSize
= values
[4];
4813 cfgs
->depthSize
= values
[5];
4814 cfgs
->stencilSize
= values
[6];
4815 cfgs
->windowDrawable
= values
[7];
4816 cfgs
->iPixelType
= values
[8];
4817 cfgs
->doubleBuffer
= values
[9];
4818 cfgs
->auxBuffers
= values
[10];
4820 cfgs
->pbufferDrawable
= FALSE
;
4821 /* Check for pbuffer support when it is around as
4822 * wglGetPixelFormatAttribiv fails for unknown attributes. */
4823 if (gl_info
->supported
[WGL_ARB_PBUFFER
])
4825 int attrib
= WGL_DRAW_TO_PBUFFER_ARB
;
4827 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, 1, &attrib
, &value
)))
4828 cfgs
->pbufferDrawable
= value
;
4831 cfgs
->numSamples
= 0;
4832 /* Check multisample support */
4833 if (gl_info
->supported
[ARB_MULTISAMPLE
])
4835 int attrib
[2] = {WGL_SAMPLE_BUFFERS_ARB
, WGL_SAMPLES_ARB
};
4837 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, 2, attrib
, value
))) {
4838 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
4839 * value[1] = number of multi sample buffers*/
4841 cfgs
->numSamples
= value
[1];
4845 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, depth=%d, stencil=%d, samples=%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
->numSamples
, cfgs
->windowDrawable
, cfgs
->pbufferDrawable
);
4851 int nCfgs
= DescribePixelFormat(hdc
, 0, 0, 0);
4852 adapter
->cfgs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, nCfgs
*sizeof(WineD3D_PixelFormat
));
4853 adapter
->nCfgs
= 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
4855 cfgs
= adapter
->cfgs
;
4856 for(iPixelFormat
=1; iPixelFormat
<=nCfgs
; iPixelFormat
++)
4858 PIXELFORMATDESCRIPTOR ppfd
;
4860 res
= DescribePixelFormat(hdc
, iPixelFormat
, sizeof(PIXELFORMATDESCRIPTOR
), &ppfd
);
4864 /* We only want HW acceleration using an OpenGL ICD driver.
4865 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
4866 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
4868 if(ppfd
.dwFlags
& (PFD_GENERIC_FORMAT
| PFD_GENERIC_ACCELERATED
))
4870 TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat
);
4874 cfgs
->iPixelFormat
= iPixelFormat
;
4875 cfgs
->redSize
= ppfd
.cRedBits
;
4876 cfgs
->greenSize
= ppfd
.cGreenBits
;
4877 cfgs
->blueSize
= ppfd
.cBlueBits
;
4878 cfgs
->alphaSize
= ppfd
.cAlphaBits
;
4879 cfgs
->colorSize
= ppfd
.cColorBits
;
4880 cfgs
->depthSize
= ppfd
.cDepthBits
;
4881 cfgs
->stencilSize
= ppfd
.cStencilBits
;
4882 cfgs
->pbufferDrawable
= 0;
4883 cfgs
->windowDrawable
= (ppfd
.dwFlags
& PFD_DRAW_TO_WINDOW
) ? 1 : 0;
4884 cfgs
->iPixelType
= (ppfd
.iPixelType
== PFD_TYPE_RGBA
) ? WGL_TYPE_RGBA_ARB
: WGL_TYPE_COLORINDEX_ARB
;
4885 cfgs
->doubleBuffer
= (ppfd
.dwFlags
& PFD_DOUBLEBUFFER
) ? 1 : 0;
4886 cfgs
->auxBuffers
= ppfd
.cAuxBuffers
;
4887 cfgs
->numSamples
= 0;
4889 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
);
4894 /* 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 */
4897 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
4899 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4900 HeapFree(GetProcessHeap(), 0, adapter
->cfgs
);
4905 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
4906 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
4907 * but just fake it using D24(X8?) which is fine. D3D also allows that.
4908 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
4909 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
4910 * driver is allowed to consume more bits EXCEPT for stencil bits.
4912 * Mark an adapter with this broken stencil behavior.
4914 adapter
->brokenStencil
= TRUE
;
4915 for (i
= 0, cfgs
= adapter
->cfgs
; i
< adapter
->nCfgs
; ++i
)
4917 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
4918 if(cfgs
[i
].depthSize
&& !cfgs
[i
].stencilSize
) {
4919 adapter
->brokenStencil
= FALSE
;
4924 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4926 select_shader_mode(&adapter
->gl_info
, &ps_selected_mode
, &vs_selected_mode
);
4927 fillGLAttribFuncs(&adapter
->gl_info
);
4928 adapter
->opengl
= TRUE
;
4930 This
->adapter_count
= 1;
4931 TRACE("%u adapters successfully initialized\n", This
->adapter_count
);
4936 /* Initialize an adapter for ddraw-only memory counting */
4937 memset(This
->adapters
, 0, sizeof(This
->adapters
));
4938 This
->adapters
[0].ordinal
= 0;
4939 This
->adapters
[0].opengl
= FALSE
;
4940 This
->adapters
[0].monitorPoint
.x
= -1;
4941 This
->adapters
[0].monitorPoint
.y
= -1;
4943 This
->adapters
[0].driver_info
.name
= "Display";
4944 This
->adapters
[0].driver_info
.description
= "WineD3D DirectDraw Emulation";
4945 if(wined3d_settings
.emulated_textureram
) {
4946 This
->adapters
[0].TextureRam
= wined3d_settings
.emulated_textureram
;
4948 This
->adapters
[0].TextureRam
= 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
4951 initPixelFormatsNoGL(&This
->adapters
[0].gl_info
);
4953 This
->adapter_count
= 1;
4957 /**********************************************************
4958 * IWineD3D VTbl follows
4959 **********************************************************/
4961 const IWineD3DVtbl IWineD3D_Vtbl
=
4964 IWineD3DImpl_QueryInterface
,
4965 IWineD3DImpl_AddRef
,
4966 IWineD3DImpl_Release
,
4968 IWineD3DImpl_GetParent
,
4969 IWineD3DImpl_GetAdapterCount
,
4970 IWineD3DImpl_RegisterSoftwareDevice
,
4971 IWineD3DImpl_GetAdapterMonitor
,
4972 IWineD3DImpl_GetAdapterModeCount
,
4973 IWineD3DImpl_EnumAdapterModes
,
4974 IWineD3DImpl_GetAdapterDisplayMode
,
4975 IWineD3DImpl_GetAdapterIdentifier
,
4976 IWineD3DImpl_CheckDeviceMultiSampleType
,
4977 IWineD3DImpl_CheckDepthStencilMatch
,
4978 IWineD3DImpl_CheckDeviceType
,
4979 IWineD3DImpl_CheckDeviceFormat
,
4980 IWineD3DImpl_CheckDeviceFormatConversion
,
4981 IWineD3DImpl_GetDeviceCaps
,
4982 IWineD3DImpl_CreateDevice
4985 static void STDMETHODCALLTYPE
wined3d_null_wined3d_object_destroyed(void *parent
) {}
4987 const struct wined3d_parent_ops wined3d_null_parent_ops
=
4989 wined3d_null_wined3d_object_destroyed
,