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", EXT_TEXTURE_LOD
, 0 },
128 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS
, 0 },
129 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB
, 0 },
130 {"GL_EXT_texture_swizzle", EXT_TEXTURE_SWIZZLE
, 0 },
131 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA
, 0 },
132 {"GL_EXT_vertex_shader", EXT_VERTEX_SHADER
, 0 },
135 {"GL_NV_depth_clamp", NV_DEPTH_CLAMP
, 0 },
136 {"GL_NV_fence", NV_FENCE
, 0 },
137 {"GL_NV_fog_distance", NV_FOG_DISTANCE
, 0 },
138 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM
, 0 },
139 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2
, 0 },
140 {"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION
, 0 },
141 {"GL_NV_half_float", NV_HALF_FLOAT
, 0 },
142 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT
, 0 },
143 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS
, 0 },
144 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2
, 0 },
145 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION
, 0 },
146 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4
, 0 },
147 {"GL_NV_texture_shader", NV_TEXTURE_SHADER
, 0 },
148 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2
, 0 },
149 {"GL_NV_texture_shader3", NV_TEXTURE_SHADER3
, 0 },
150 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM
, 0 },
151 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1
, 0 },
152 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2
, 0 },
153 {"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION
, 0 },
154 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3
, 0 },
157 {"GL_SGIS_generate_mipmap", SGIS_GENERATE_MIPMAP
, 0 },
160 /**********************************************************
161 * Utility functions follow
162 **********************************************************/
164 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
, WINED3DSURFTYPE SurfaceType
);
166 const struct min_lookup minMipLookup
[] =
168 /* NONE POINT LINEAR */
169 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* NONE */
170 {{GL_NEAREST
, GL_NEAREST_MIPMAP_NEAREST
, GL_NEAREST_MIPMAP_LINEAR
}}, /* POINT*/
171 {{GL_LINEAR
, GL_LINEAR_MIPMAP_NEAREST
, GL_LINEAR_MIPMAP_LINEAR
}}, /* LINEAR */
174 const struct min_lookup minMipLookup_noFilter
[] =
176 /* NONE POINT LINEAR */
177 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* NONE */
178 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* POINT */
179 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* LINEAR */
182 const struct min_lookup minMipLookup_noMip
[] =
184 /* NONE POINT LINEAR */
185 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* NONE */
186 {{GL_NEAREST
, GL_NEAREST
, GL_NEAREST
}}, /* POINT */
187 {{GL_LINEAR
, GL_LINEAR
, GL_LINEAR
}}, /* LINEAR */
190 const GLenum magLookup
[] =
192 /* NONE POINT LINEAR */
193 GL_NEAREST
, GL_NEAREST
, GL_LINEAR
,
196 const GLenum magLookup_noFilter
[] =
198 /* NONE POINT LINEAR */
199 GL_NEAREST
, GL_NEAREST
, GL_NEAREST
,
202 /* drawStridedSlow attributes */
203 glAttribFunc position_funcs
[WINED3D_FFP_EMIT_COUNT
];
204 glAttribFunc diffuse_funcs
[WINED3D_FFP_EMIT_COUNT
];
205 glAttribFunc specular_func_3ubv
;
206 glAttribFunc specular_funcs
[WINED3D_FFP_EMIT_COUNT
];
207 glAttribFunc normal_funcs
[WINED3D_FFP_EMIT_COUNT
];
208 glMultiTexCoordFunc multi_texcoord_funcs
[WINED3D_FFP_EMIT_COUNT
];
211 * Note: GL seems to trap if GetDeviceCaps is called before any HWND's created,
212 * i.e., there is no GL Context - Get a default rendering context to enable the
213 * function query some info from GL.
216 struct wined3d_fake_gl_ctx
222 HGLRC restore_gl_ctx
;
225 static void WineD3D_ReleaseFakeGLContext(struct wined3d_fake_gl_ctx
*ctx
)
227 TRACE_(d3d_caps
)("Destroying fake GL context.\n");
229 if (!pwglMakeCurrent(NULL
, NULL
))
231 ERR_(d3d_caps
)("Failed to disable fake GL context.\n");
234 if (!pwglDeleteContext(ctx
->gl_ctx
))
236 DWORD err
= GetLastError();
237 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx
->gl_ctx
, err
);
240 ReleaseDC(ctx
->wnd
, ctx
->dc
);
241 DestroyWindow(ctx
->wnd
);
243 if (ctx
->restore_gl_ctx
&& !pwglMakeCurrent(ctx
->restore_dc
, ctx
->restore_gl_ctx
))
245 ERR_(d3d_caps
)("Failed to restore previous GL context.\n");
249 static BOOL
WineD3D_CreateFakeGLContext(struct wined3d_fake_gl_ctx
*ctx
)
251 PIXELFORMATDESCRIPTOR pfd
;
254 TRACE("getting context...\n");
256 ctx
->restore_dc
= pwglGetCurrentDC();
257 ctx
->restore_gl_ctx
= pwglGetCurrentContext();
259 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
260 ctx
->wnd
= CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME
, "WineD3D fake window",
261 WS_OVERLAPPEDWINDOW
, 10, 10, 10, 10, NULL
, NULL
, NULL
, NULL
);
264 ERR_(d3d_caps
)("Failed to create a window.\n");
268 ctx
->dc
= GetDC(ctx
->wnd
);
271 ERR_(d3d_caps
)("Failed to get a DC.\n");
275 /* PixelFormat selection */
276 ZeroMemory(&pfd
, sizeof(pfd
));
277 pfd
.nSize
= sizeof(pfd
);
279 pfd
.dwFlags
= PFD_SUPPORT_OPENGL
| PFD_DOUBLEBUFFER
| PFD_DRAW_TO_WINDOW
; /* PFD_GENERIC_ACCELERATED */
280 pfd
.iPixelType
= PFD_TYPE_RGBA
;
282 pfd
.iLayerType
= PFD_MAIN_PLANE
;
284 iPixelFormat
= ChoosePixelFormat(ctx
->dc
, &pfd
);
287 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
288 ERR_(d3d_caps
)("Can't find a suitable iPixelFormat.\n");
291 DescribePixelFormat(ctx
->dc
, iPixelFormat
, sizeof(pfd
), &pfd
);
292 SetPixelFormat(ctx
->dc
, iPixelFormat
, &pfd
);
294 /* Create a GL context. */
295 ctx
->gl_ctx
= pwglCreateContext(ctx
->dc
);
298 WARN_(d3d_caps
)("Error creating default context for capabilities initialization.\n");
302 /* Make it the current GL context. */
303 if (!context_set_current(NULL
))
305 ERR_(d3d_caps
)("Failed to clear current D3D context.\n");
308 if (!pwglMakeCurrent(ctx
->dc
, ctx
->gl_ctx
))
310 ERR_(d3d_caps
)("Failed to make fake GL context current.\n");
317 if (ctx
->gl_ctx
) pwglDeleteContext(ctx
->gl_ctx
);
319 if (ctx
->dc
) ReleaseDC(ctx
->wnd
, ctx
->dc
);
321 if (ctx
->wnd
) DestroyWindow(ctx
->wnd
);
323 if (ctx
->restore_gl_ctx
&& !pwglMakeCurrent(ctx
->restore_dc
, ctx
->restore_gl_ctx
))
325 ERR_(d3d_caps
)("Failed to restore previous GL context.\n");
331 /* Adjust the amount of used texture memory */
332 long WineD3DAdapterChangeGLRam(IWineD3DDeviceImpl
*D3DDevice
, long glram
)
334 struct wined3d_adapter
*adapter
= D3DDevice
->adapter
;
336 adapter
->UsedTextureRam
+= glram
;
337 TRACE("Adjusted gl ram by %ld to %d\n", glram
, adapter
->UsedTextureRam
);
338 return adapter
->UsedTextureRam
;
341 static void wined3d_adapter_cleanup(struct wined3d_adapter
*adapter
)
343 HeapFree(GetProcessHeap(), 0, adapter
->gl_info
.gl_formats
);
344 HeapFree(GetProcessHeap(), 0, adapter
->cfgs
);
347 /**********************************************************
348 * IUnknown parts follows
349 **********************************************************/
351 static HRESULT WINAPI
IWineD3DImpl_QueryInterface(IWineD3D
*iface
,REFIID riid
,LPVOID
*ppobj
)
353 IWineD3DDeviceImpl
*This
= (IWineD3DDeviceImpl
*)iface
;
355 TRACE("(%p)->(%s,%p)\n",This
,debugstr_guid(riid
),ppobj
);
356 if (IsEqualGUID(riid
, &IID_IUnknown
)
357 || IsEqualGUID(riid
, &IID_IWineD3DBase
)
358 || IsEqualGUID(riid
, &IID_IWineD3DDevice
)) {
359 IUnknown_AddRef(iface
);
364 return E_NOINTERFACE
;
367 static ULONG WINAPI
IWineD3DImpl_AddRef(IWineD3D
*iface
) {
368 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
369 ULONG refCount
= InterlockedIncrement(&This
->ref
);
371 TRACE("(%p) : AddRef increasing from %d\n", This
, refCount
- 1);
375 static ULONG WINAPI
IWineD3DImpl_Release(IWineD3D
*iface
) {
376 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
378 TRACE("(%p) : Releasing from %d\n", This
, This
->ref
);
379 ref
= InterlockedDecrement(&This
->ref
);
383 for (i
= 0; i
< This
->adapter_count
; ++i
)
385 wined3d_adapter_cleanup(&This
->adapters
[i
]);
387 HeapFree(GetProcessHeap(), 0, This
);
393 /**********************************************************
394 * IWineD3D parts follows
395 **********************************************************/
397 /* GL locking is done by the caller */
398 static inline BOOL
test_arb_vs_offset_limit(const struct wined3d_gl_info
*gl_info
)
402 const char *testcode
=
404 "PARAM C[66] = { program.env[0..65] };\n"
406 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
407 "ARL A0.x, zero.x;\n"
408 "MOV result.position, C[A0.x + 65];\n"
412 GL_EXTCALL(glGenProgramsARB(1, &prog
));
414 ERR("Failed to create an ARB offset limit test program\n");
416 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, prog
));
417 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
,
418 strlen(testcode
), testcode
));
419 if(glGetError() != 0) {
420 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
421 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB
)));
423 } else TRACE("OpenGL implementation allows offsets > 63\n");
425 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, 0));
426 GL_EXTCALL(glDeleteProgramsARB(1, &prog
));
427 checkGLcall("ARB vp offset limit test cleanup");
432 static DWORD
ver_for_ext(GL_SupportedExt ext
)
435 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
) {
436 if(EXTENSION_MAP
[i
].extension
== ext
) {
437 return EXTENSION_MAP
[i
].version
;
443 static BOOL
match_ati_r300_to_500(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
444 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
446 if (vendor
!= VENDOR_ATI
) return FALSE
;
447 if (device
== CARD_ATI_RADEON_9500
) return TRUE
;
448 if (device
== CARD_ATI_RADEON_X700
) return TRUE
;
449 if (device
== CARD_ATI_RADEON_X1600
) return TRUE
;
453 static BOOL
match_geforce5(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
454 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
456 if (vendor
== VENDOR_NVIDIA
)
458 if (device
== CARD_NVIDIA_GEFORCEFX_5800
|| device
== CARD_NVIDIA_GEFORCEFX_5600
)
466 static BOOL
match_apple(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
467 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
469 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
470 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
471 * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
473 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
474 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
475 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
476 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
477 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
478 * the chance that other implementations support them is rather small since Win32 QuickTime uses
479 * DirectDraw, not OpenGL. */
480 if (gl_info
->supported
[APPLE_FENCE
]
481 && gl_info
->supported
[APPLE_CLIENT_STORAGE
]
482 && gl_info
->supported
[APPLE_FLUSH_RENDER
]
483 && gl_info
->supported
[APPLE_YCBCR_422
])
493 /* Context activation is done by the caller. */
494 static void test_pbo_functionality(struct wined3d_gl_info
*gl_info
)
496 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
497 * but glTexSubImage from a PBO fails miserably, with the first line repeated over
498 * all the texture. This function detects this bug by its symptom and disables PBOs
501 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
502 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
503 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
504 * read back is compared to the original. If they are equal PBOs are assumed to work,
505 * otherwise the PBO extension is disabled. */
507 static const unsigned int pattern
[] =
509 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
510 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
511 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
512 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
514 unsigned int check
[sizeof(pattern
) / sizeof(pattern
[0])];
516 /* No PBO -> No point in testing them. */
517 if (!gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
]) return;
521 while (glGetError());
522 glGenTextures(1, &texture
);
523 glBindTexture(GL_TEXTURE_2D
, texture
);
525 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAX_LEVEL
, 0);
526 glTexImage2D(GL_TEXTURE_2D
, 0, GL_RGBA8
, 4, 4, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, 0);
527 checkGLcall("Specifying the PBO test texture");
529 GL_EXTCALL(glGenBuffersARB(1, &pbo
));
530 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, pbo
));
531 GL_EXTCALL(glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB
, sizeof(pattern
), pattern
, GL_STREAM_DRAW_ARB
));
532 checkGLcall("Specifying the PBO test pbo");
534 glTexSubImage2D(GL_TEXTURE_2D
, 0, 0, 0, 4, 4, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, NULL
);
535 checkGLcall("Loading the PBO test texture");
537 GL_EXTCALL(glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB
, 0));
538 wglFinish(); /* just to be sure */
540 memset(check
, 0, sizeof(check
));
541 glGetTexImage(GL_TEXTURE_2D
, 0, GL_BGRA
, GL_UNSIGNED_INT_8_8_8_8_REV
, check
);
542 checkGLcall("Reading back the PBO test texture");
544 glDeleteTextures(1, &texture
);
545 GL_EXTCALL(glDeleteBuffersARB(1, &pbo
));
546 checkGLcall("PBO test cleanup");
550 if (memcmp(check
, pattern
, sizeof(check
)))
552 WARN_(d3d_caps
)("PBO test failed, read back data doesn't match original.\n");
553 WARN_(d3d_caps
)("Disabling PBOs. This may result in slower performance.\n");
554 gl_info
->supported
[ARB_PIXEL_BUFFER_OBJECT
] = FALSE
;
558 TRACE_(d3d_caps
)("PBO test successful.\n");
562 static BOOL
match_apple_intel(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
563 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
565 return vendor
== VENDOR_INTEL
&& match_apple(gl_info
, gl_renderer
, vendor
, device
);
568 static BOOL
match_apple_nonr500ati(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
569 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
571 if (!match_apple(gl_info
, gl_renderer
, vendor
, device
)) return FALSE
;
572 if (vendor
!= VENDOR_ATI
) return FALSE
;
573 if (device
== CARD_ATI_RADEON_X1600
) return FALSE
;
577 static BOOL
match_fglrx(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
578 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
580 if (vendor
!= VENDOR_ATI
) return FALSE
;
581 if (match_apple(gl_info
, gl_renderer
, vendor
, device
)) return FALSE
;
582 if (strstr(gl_renderer
, "DRI")) return FALSE
; /* Filter out Mesa DRI drivers. */
586 static BOOL
match_dx10_capable(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
587 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
589 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports
590 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card.
591 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44
592 * varyings and we subtract one in dx9 shaders its not going to hurt us because the dx9 limit is
595 * dx10 cards usually have 64 varyings */
596 return gl_info
->limits
.glsl_varyings
> 44;
599 /* A GL context is provided by the caller */
600 static BOOL
match_allows_spec_alpha(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
601 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
606 if (!gl_info
->supported
[EXT_SECONDARY_COLOR
]) return FALSE
;
610 GL_EXTCALL(glSecondaryColorPointerEXT
)(4, GL_UNSIGNED_BYTE
, 4, data
);
611 error
= glGetError();
614 if(error
== GL_NO_ERROR
)
616 TRACE("GL Implementation accepts 4 component specular color pointers\n");
621 TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
622 debug_glerror(error
));
627 static BOOL
match_apple_nvts(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
628 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
630 if (!match_apple(gl_info
, gl_renderer
, vendor
, device
)) return FALSE
;
631 return gl_info
->supported
[NV_TEXTURE_SHADER
];
634 /* A GL context is provided by the caller */
635 static BOOL
match_broken_nv_clip(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
636 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
641 const char *testcode
=
643 "OPTION NV_vertex_program2;\n"
644 "MOV result.clip[0], 0.0;\n"
645 "MOV result.position, 0.0;\n"
648 if (!gl_info
->supported
[NV_VERTEX_PROGRAM2_OPTION
]) return FALSE
;
653 GL_EXTCALL(glGenProgramsARB(1, &prog
));
656 ERR("Failed to create the NVvp clip test program\n");
660 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, prog
));
661 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB
, GL_PROGRAM_FORMAT_ASCII_ARB
,
662 strlen(testcode
), testcode
));
663 glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB
, &pos
);
666 WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
667 TRACE("error: %s\n", debugstr_a((const char *)glGetString(GL_PROGRAM_ERROR_STRING_ARB
)));
671 else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
673 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB
, 0));
674 GL_EXTCALL(glDeleteProgramsARB(1, &prog
));
675 checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
681 static void quirk_arb_constants(struct wined3d_gl_info
*gl_info
)
683 TRACE_(d3d_caps
)("Using ARB vs constant limit(=%u) for GLSL.\n", gl_info
->limits
.arb_vs_native_constants
);
684 gl_info
->limits
.glsl_vs_float_constants
= gl_info
->limits
.arb_vs_native_constants
;
685 TRACE_(d3d_caps
)("Using ARB ps constant limit(=%u) for GLSL.\n", gl_info
->limits
.arb_ps_native_constants
);
686 gl_info
->limits
.glsl_ps_float_constants
= gl_info
->limits
.arb_ps_native_constants
;
689 static void quirk_apple_glsl_constants(struct wined3d_gl_info
*gl_info
)
691 quirk_arb_constants(gl_info
);
692 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms.
693 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should
694 * allow 48 different offsets or other helper immediate values. */
695 TRACE_(d3d_caps
)("Reserving 12 GLSL constants for compiler private use.\n");
696 gl_info
->reserved_glsl_constants
= max(gl_info
->reserved_glsl_constants
, 12);
699 /* fglrx crashes with a very bad kernel panic if GL_POINT_SPRITE_ARB is set to GL_COORD_REPLACE_ARB
700 * on more than one texture unit. This means that the d3d9 visual point size test will cause a
701 * kernel panic on any machine running fglrx 9.3(latest that supports r300 to r500 cards). This
702 * quirk only enables point sprites on the first texture unit. This keeps point sprites working in
703 * most games, but avoids the crash
705 * A more sophisticated way would be to find all units that need texture coordinates and enable
706 * point sprites for one if only one is found, and software emulate point sprites in drawStridedSlow
707 * if more than one unit needs texture coordinates(This requires software ffp and vertex shaders though)
709 * Note that disabling the extension entirely does not gain predictability because there is no point
710 * sprite capability flag in d3d, so the potential rendering bugs are the same if we disable the extension. */
711 static void quirk_one_point_sprite(struct wined3d_gl_info
*gl_info
)
713 if (gl_info
->supported
[ARB_POINT_SPRITE
])
715 TRACE("Limiting point sprites to one texture unit.\n");
716 gl_info
->limits
.point_sprite_units
= 1;
720 static void quirk_ati_dx9(struct wined3d_gl_info
*gl_info
)
722 quirk_arb_constants(gl_info
);
724 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although
725 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
726 * If real NP2 textures are used, the driver falls back to software. We could just remove the
727 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconventient
728 * due to the non-normalized texture coordinates. Thus set an internal extension flag,
729 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures
730 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits.
732 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which
733 * has this extension promoted to core. The extension loading code sets this extension supported
734 * due to that, so this code works on fglrx as well. */
735 if(gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
])
737 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
738 gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] = FALSE
;
739 gl_info
->supported
[WINE_NORMALIZED_TEXRECT
] = TRUE
;
742 /* fglrx has the same structural issues as the one described in quirk_apple_glsl_constants, although
743 * it is generally more efficient. Reserve just 8 constants. */
744 TRACE_(d3d_caps
)("Reserving 8 GLSL constants for compiler private use.\n");
745 gl_info
->reserved_glsl_constants
= max(gl_info
->reserved_glsl_constants
, 8);
748 static void quirk_no_np2(struct wined3d_gl_info
*gl_info
)
750 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but
751 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string.
752 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying
753 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the
754 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used.
755 * We therefore completely remove ARB_tex_npot from the list of supported extensions.
757 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot,
758 * triggering the software fallback. There is not much we can do here apart from disabling the
759 * software-emulated extension and reenable ARB_tex_rect (which was previously disabled
760 * in IWineD3DImpl_FillGLCaps).
761 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer
762 * post-processing effects in the game "Max Payne 2").
763 * The behaviour can be verified through a simple test app attached in bugreport #14724. */
764 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
765 gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
] = FALSE
;
766 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = TRUE
;
769 static void quirk_texcoord_w(struct wined3d_gl_info
*gl_info
)
771 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems
772 * with fixed function fragment processing. Ideally this flag should be detected with a test shader
773 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones)
774 * do not like vertex shaders in feedback mode and return an error, even though it should be valid
775 * according to the spec.
777 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This
778 * makes the shader slower and eats instruction slots which should be available to the d3d app.
780 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist
781 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If
782 * this workaround is activated on cards that do not need it, it won't break things, just affect
783 * performance negatively. */
784 TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
785 gl_info
->quirks
|= WINED3D_QUIRK_SET_TEXCOORD_W
;
788 static void quirk_clip_varying(struct wined3d_gl_info
*gl_info
)
790 gl_info
->quirks
|= WINED3D_QUIRK_GLSL_CLIP_VARYING
;
793 static void quirk_allows_specular_alpha(struct wined3d_gl_info
*gl_info
)
795 gl_info
->quirks
|= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA
;
798 static void quirk_apple_nvts(struct wined3d_gl_info
*gl_info
)
800 gl_info
->supported
[NV_TEXTURE_SHADER
] = FALSE
;
801 gl_info
->supported
[NV_TEXTURE_SHADER2
] = FALSE
;
802 gl_info
->supported
[NV_TEXTURE_SHADER3
] = FALSE
;
805 static void quirk_disable_nvvp_clip(struct wined3d_gl_info
*gl_info
)
807 gl_info
->quirks
|= WINED3D_QUIRK_NV_CLIP_BROKEN
;
812 BOOL (*match
)(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
813 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
);
814 void (*apply
)(struct wined3d_gl_info
*gl_info
);
815 const char *description
;
818 static const struct driver_quirk quirk_table
[] =
821 match_ati_r300_to_500
,
823 "ATI GLSL constant and normalized texrect quirk"
825 /* MacOS advertises more GLSL vertex shader uniforms than supported by the hardware, and if more are
826 * used it falls back to software. While the compiler can detect if the shader uses all declared
827 * uniforms, the optimization fails if the shader uses relative addressing. So any GLSL shader
828 * using relative addressing falls back to software.
830 * ARB vp gives the correct amount of uniforms, so use it instead of GLSL. */
833 quirk_apple_glsl_constants
,
834 "Apple GLSL uniform override"
839 "Geforce 5 NP2 disable"
844 "Init texcoord .w for Apple Intel GPU driver"
847 match_apple_nonr500ati
,
849 "Init texcoord .w for Apple ATI >= r600 GPU driver"
853 quirk_one_point_sprite
,
854 "Fglrx point sprite crash workaround"
859 "Reserved varying for gl_ClipPos"
862 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most
863 * GL implementations accept it. The Mac GL is the only implementation known to
866 * If we can pass 4 component specular colors, do it, because (a) we don't have
867 * to screw around with the data, and (b) the D3D fixed function vertex pipeline
868 * passes specular alpha to the pixel shader if any is used. Otherwise the
869 * specular alpha is used to pass the fog coordinate, which we pass to opengl
870 * via GL_EXT_fog_coord.
872 match_allows_spec_alpha
,
873 quirk_allows_specular_alpha
,
874 "Allow specular alpha quirk"
877 /* The pixel formats provided by GL_NV_texture_shader are broken on OSX
882 "Apple NV_texture_shader disable"
885 match_broken_nv_clip
,
886 quirk_disable_nvvp_clip
,
887 "Apple NV_vertex_program clip bug quirk"
891 /* Certain applications (Steam) complain if we report an outdated driver version. In general,
892 * reporting a driver version is moot because we are not the Windows driver, and we have different
893 * bugs, features, etc.
895 * The driver version has the form "x.y.z.w".
897 * "x" is the Windows version the driver is meant for:
904 * "y" is the Direct3D level the driver supports:
911 * "z" is unknown, possibly vendor specific.
913 * "w" is the vendor specific driver version.
915 struct driver_version_information
917 WORD vendor
; /* reported PCI card vendor ID */
918 WORD card
; /* reported PCI card device ID */
919 const char *description
; /* Description of the card e.g. NVIDIA RIVA TNT */
920 WORD d3d_level
; /* driver hiword to report */
921 WORD lopart_hi
, lopart_lo
; /* driver loword to report */
924 static const struct driver_version_information driver_version_table
[] =
926 /* Nvidia drivers. Geforce6 and newer cards are supported by the current driver (180.x)
927 * 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
928 * Geforce2MX/3/4 up to 96.x - driver uses numbering 9.6.8.9 for 96.89
929 * TNT/Geforce1/2 up to 71.x - driver uses numbering 7.1.8.6 for 71.86
931 * All version numbers used below are from the Linux nvidia drivers. */
932 {VENDOR_NVIDIA
, CARD_NVIDIA_RIVA_TNT
, "NVIDIA RIVA TNT", 1, 8, 6 },
933 {VENDOR_NVIDIA
, CARD_NVIDIA_RIVA_TNT2
, "NVIDIA RIVA TNT2/TNT2 Pro", 1, 8, 6 },
934 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE
, "NVIDIA GeForce 256", 1, 8, 6 },
935 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE2_MX
, "NVIDIA GeForce2 MX/MX 400", 6, 4, 3 },
936 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE2
, "NVIDIA GeForce2 GTS/GeForce2 Pro", 1, 8, 6 },
937 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE3
, "NVIDIA GeForce3", 6, 10, 9371 },
938 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE4_MX
, "NVIDIA GeForce4 MX 460", 6, 10, 9371 },
939 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE4_TI4200
, "NVIDIA GeForce4 Ti 4200", 6, 10, 9371 },
940 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5200
, "NVIDIA GeForce FX 5200", 15, 11, 7516 },
941 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5600
, "NVIDIA GeForce FX 5600", 15, 11, 7516 },
942 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCEFX_5800
, "NVIDIA GeForce FX 5800", 15, 11, 7516 },
943 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6200
, "NVIDIA GeForce 6200", 15, 11, 8618 },
944 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6600GT
, "NVIDIA GeForce 6600 GT", 15, 11, 8618 },
945 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_6800
, "NVIDIA GeForce 6800", 15, 11, 8618 },
946 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7300
, "NVIDIA GeForce Go 7300", 15, 11, 8585 },
947 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7400
, "NVIDIA GeForce Go 7400", 15, 11, 8585 },
948 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7600
, "NVIDIA GeForce 7600 GT", 15, 11, 8618 },
949 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_7800GT
, "NVIDIA GeForce 7800 GT", 15, 11, 8618 },
950 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8300GS
, "NVIDIA GeForce 8300 GS", 15, 11, 8618 },
951 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600GT
, "NVIDIA GeForce 8600 GT", 15, 11, 8618 },
952 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8600MGT
, "NVIDIA GeForce 8600M GT", 15, 11, 8585 },
953 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_8800GTS
, "NVIDIA GeForce 8800 GTS", 15, 11, 8618 },
954 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9200
, "NVIDIA GeForce 9200", 15, 11, 8618 },
955 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9400GT
, "NVIDIA GeForce 9400 GT", 15, 11, 8618 },
956 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9500GT
, "NVIDIA GeForce 9500 GT", 15, 11, 8618 },
957 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9600GT
, "NVIDIA GeForce 9600 GT", 15, 11, 8618 },
958 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_9800GT
, "NVIDIA GeForce 9800 GT", 15, 11, 8618 },
959 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GTX260
, "NVIDIA GeForce GTX 260", 15, 11, 8618 },
960 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GTX275
, "NVIDIA GeForce GTX 275", 15, 11, 8618 },
961 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GTX280
, "NVIDIA GeForce GTX 280", 15, 11, 8618 },
962 {VENDOR_NVIDIA
, CARD_NVIDIA_GEFORCE_GT240
, "NVIDIA GeForce GT 240", 15, 11, 8618 },
964 /* ATI cards. The driver versions are somewhat similar, but not quite the same. Let's hardcode. */
965 {VENDOR_ATI
, CARD_ATI_RADEON_9500
, "ATI Radeon 9500", 14, 10, 6764 },
966 {VENDOR_ATI
, CARD_ATI_RADEON_X700
, "ATI Radeon X700 SE", 14, 10, 6764 },
967 {VENDOR_ATI
, CARD_ATI_RADEON_X1600
, "ATI Radeon X1600 Series", 14, 10, 6764 },
968 {VENDOR_ATI
, CARD_ATI_RADEON_HD2300
, "ATI Mobility Radeon HD 2300", 14, 10, 6764 },
969 {VENDOR_ATI
, CARD_ATI_RADEON_HD2600
, "ATI Mobility Radeon HD 2600", 14, 10, 6764 },
970 {VENDOR_ATI
, CARD_ATI_RADEON_HD2900
, "ATI Radeon HD 2900 XT", 14, 10, 6764 },
971 {VENDOR_ATI
, CARD_ATI_RADEON_HD4350
, "ATI Radeon HD 4350", 14, 10, 6764 },
972 {VENDOR_ATI
, CARD_ATI_RADEON_HD4600
, "ATI Radeon HD 4600 Series", 14, 10, 6764 },
973 {VENDOR_ATI
, CARD_ATI_RADEON_HD4700
, "ATI Radeon HD 4700 Series", 14, 10, 6764 },
974 {VENDOR_ATI
, CARD_ATI_RADEON_HD4800
, "ATI Radeon HD 4800 Series", 14, 10, 6764 },
975 {VENDOR_ATI
, CARD_ATI_RADEON_HD5700
, "ATI Radeon HD 5700 Series", 14, 10, 8681 },
976 {VENDOR_ATI
, CARD_ATI_RADEON_HD5800
, "ATI Radeon HD 5800 Series", 14, 10, 8681 },
978 /* TODO: Add information about legacy ATI hardware, Intel and other cards. */
981 static void init_driver_info(struct wined3d_driver_info
*driver_info
,
982 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
984 OSVERSIONINFOW os_version
;
985 WORD driver_os_version
;
988 if (wined3d_settings
.pci_vendor_id
!= PCI_VENDOR_NONE
)
990 TRACE_(d3d_caps
)("Overriding PCI vendor ID with: %04x\n", wined3d_settings
.pci_vendor_id
);
991 vendor
= wined3d_settings
.pci_vendor_id
;
993 driver_info
->vendor
= vendor
;
995 if (wined3d_settings
.pci_device_id
!= PCI_DEVICE_NONE
)
997 TRACE_(d3d_caps
)("Overriding PCI device ID with: %04x\n", wined3d_settings
.pci_device_id
);
998 device
= wined3d_settings
.pci_device_id
;
1000 driver_info
->device
= device
;
1005 driver_info
->name
= "ati2dvag.dll";
1009 driver_info
->name
= "nv4_disp.dll";
1013 FIXME_(d3d_caps
)("Unhandled vendor %04x.\n", vendor
);
1014 driver_info
->name
= "Display";
1018 memset(&os_version
, 0, sizeof(os_version
));
1019 os_version
.dwOSVersionInfoSize
= sizeof(os_version
);
1020 if (!GetVersionExW(&os_version
))
1022 ERR("Failed to get OS version, reporting 2000/XP.\n");
1023 driver_os_version
= 6;
1027 TRACE("OS version %u.%u.\n", os_version
.dwMajorVersion
, os_version
.dwMinorVersion
);
1028 switch (os_version
.dwMajorVersion
)
1031 driver_os_version
= 4;
1035 driver_os_version
= 6;
1039 if (os_version
.dwMinorVersion
== 0)
1041 driver_os_version
= 7;
1045 if (os_version
.dwMinorVersion
> 1)
1047 FIXME("Unhandled OS version %u.%u, reporting Win 7.\n",
1048 os_version
.dwMajorVersion
, os_version
.dwMinorVersion
);
1050 driver_os_version
= 8;
1055 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n",
1056 os_version
.dwMajorVersion
, os_version
.dwMinorVersion
);
1057 driver_os_version
= 6;
1062 driver_info
->description
= "Direct3D HAL";
1063 driver_info
->version_high
= MAKEDWORD_VERSION(driver_os_version
, 15);
1064 driver_info
->version_low
= MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */
1066 for (i
= 0; i
< (sizeof(driver_version_table
) / sizeof(driver_version_table
[0])); ++i
)
1068 if (vendor
== driver_version_table
[i
].vendor
&& device
== driver_version_table
[i
].card
)
1070 TRACE_(d3d_caps
)("Found card %04x:%04x in driver DB.\n", vendor
, device
);
1072 driver_info
->description
= driver_version_table
[i
].description
;
1073 driver_info
->version_high
= MAKEDWORD_VERSION(driver_os_version
, driver_version_table
[i
].d3d_level
);
1074 driver_info
->version_low
= MAKEDWORD_VERSION(driver_version_table
[i
].lopart_hi
,
1075 driver_version_table
[i
].lopart_lo
);
1080 TRACE_(d3d_caps
)("Reporting (fake) driver version 0x%08x-0x%08x.\n",
1081 driver_info
->version_high
, driver_info
->version_low
);
1084 /* Context activation is done by the caller. */
1085 static void fixup_extensions(struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
1086 enum wined3d_pci_vendor vendor
, enum wined3d_pci_device device
)
1090 for (i
= 0; i
< (sizeof(quirk_table
) / sizeof(*quirk_table
)); ++i
)
1092 if (!quirk_table
[i
].match(gl_info
, gl_renderer
, vendor
, device
)) continue;
1093 TRACE_(d3d_caps
)("Applying driver quirk \"%s\".\n", quirk_table
[i
].description
);
1094 quirk_table
[i
].apply(gl_info
);
1097 /* Find out if PBOs work as they are supposed to. */
1098 test_pbo_functionality(gl_info
);
1101 static DWORD
wined3d_parse_gl_version(const char *gl_version
)
1103 const char *ptr
= gl_version
;
1107 if (major
<= 0) ERR_(d3d_caps
)("Invalid opengl major version: %d.\n", major
);
1109 while (isdigit(*ptr
)) ++ptr
;
1110 if (*ptr
++ != '.') ERR_(d3d_caps
)("Invalid opengl version string: %s.\n", debugstr_a(gl_version
));
1114 TRACE_(d3d_caps
)("Found OpenGL version: %d.%d.\n", major
, minor
);
1116 return MAKEDWORD_VERSION(major
, minor
);
1119 static enum wined3d_pci_vendor
wined3d_guess_vendor(const char *gl_vendor
, const char *gl_renderer
)
1121 if (strstr(gl_vendor
, "NVIDIA"))
1122 return VENDOR_NVIDIA
;
1124 if (strstr(gl_vendor
, "ATI"))
1127 if (strstr(gl_vendor
, "Intel(R)")
1128 || strstr(gl_renderer
, "Intel(R)")
1129 || strstr(gl_vendor
, "Intel Inc."))
1130 return VENDOR_INTEL
;
1132 if (strstr(gl_vendor
, "Mesa")
1133 || strstr(gl_vendor
, "Advanced Micro Devices, Inc.")
1134 || strstr(gl_vendor
, "DRI R300 Project")
1135 || strstr(gl_vendor
, "Tungsten Graphics, Inc")
1136 || strstr(gl_vendor
, "VMware, Inc."))
1139 FIXME_(d3d_caps
)("Received unrecognized GL_VENDOR %s. Returning VENDOR_WINE.\n", debugstr_a(gl_vendor
));
1144 static enum wined3d_pci_device
wined3d_guess_card(const struct wined3d_gl_info
*gl_info
, const char *gl_renderer
,
1145 enum wined3d_pci_vendor
*vendor
, unsigned int *vidmem
)
1147 /* Below is a list of Nvidia and ATI GPUs. Both vendors have dozens of
1148 * different GPUs with roughly the same features. In most cases GPUs from a
1149 * certain family differ in clockspeeds, the amount of video memory and the
1150 * number of shader pipelines.
1152 * A Direct3D device object contains the PCI id (vendor + device) of the
1153 * videocard which is used for rendering. Various applications use this
1154 * information to get a rough estimation of the features of the card and
1155 * some might use it for enabling 3d effects only on certain types of
1156 * videocards. In some cases games might even use it to work around bugs
1157 * which happen on certain videocards/driver combinations. The problem is
1158 * that OpenGL only exposes a rendering string containing the name of the
1159 * videocard and not the PCI id.
1161 * Various games depend on the PCI id, so somehow we need to provide one.
1162 * A simple option is to parse the renderer string and translate this to
1163 * the right PCI id. This is a lot of work because there are more than 200
1164 * GPUs just for Nvidia. Various cards share the same renderer string, so
1165 * the amount of code might be 'small' but there are quite a number of
1166 * exceptions which would make this a pain to maintain. Another way would
1167 * be to query the PCI id from the operating system (assuming this is the
1168 * videocard which is used for rendering which is not always the case).
1169 * This would work but it is not very portable. Second it would not work
1170 * well in, let's say, a remote X situation in which the amount of 3d
1171 * features which can be used is limited.
1173 * As said most games only use the PCI id to get an indication of the
1174 * capabilities of the card. It doesn't really matter if the given id is
1175 * the correct one if we return the id of a card with similar 3d features.
1177 * The code below checks the OpenGL capabilities of a videocard and matches
1178 * that to a certain level of Direct3D functionality. Once a card passes
1179 * the Direct3D9 check, we know that the card (in case of Nvidia) is at
1180 * least a GeforceFX. To give a better estimate we do a basic check on the
1181 * renderer string but if that won't pass we return a default card. This
1182 * way is better than maintaining a full card database as even without a
1183 * full database we can return a card with similar features. Second the
1184 * size of the database can be made quite small because when you know what
1185 * type of 3d functionality a card has, you know to which GPU family the
1186 * GPU must belong. Because of this you only have to check a small part of
1187 * the renderer string to distinguishes between different models from that
1190 * The code also selects a default amount of video memory which we will
1191 * use for an estimation of the amount of free texture memory. In case of
1192 * real D3D the amount of texture memory includes video memory and system
1193 * memory (to be specific AGP memory or in case of PCIE TurboCache /
1194 * HyperMemory). We don't know how much system memory can be addressed by
1195 * the system but we can make a reasonable estimation about the amount of
1196 * video memory. If the value is slightly wrong it doesn't matter as we
1197 * didn't include AGP-like memory which makes the amount of addressable
1198 * memory higher and second OpenGL isn't that critical it moves to system
1199 * memory behind our backs if really needed. Note that the amount of video
1200 * memory can be overruled using a registry setting. */
1205 /* Both the GeforceFX, 6xxx and 7xxx series support D3D9. The last two types have more
1206 * shader capabilities, so we use the shader capabilities to distinguish between FX and 6xxx/7xxx.
1208 if (WINE_D3D9_CAPABLE(gl_info
) && gl_info
->supported
[NV_VERTEX_PROGRAM3
])
1210 /* Geforce 200 - highend */
1211 if (strstr(gl_renderer
, "GTX 280")
1212 || strstr(gl_renderer
, "GTX 285")
1213 || strstr(gl_renderer
, "GTX 295"))
1216 return CARD_NVIDIA_GEFORCE_GTX280
;
1219 /* Geforce 200 - midend high */
1220 if (strstr(gl_renderer
, "GTX 275"))
1223 return CARD_NVIDIA_GEFORCE_GTX275
;
1226 /* Geforce 200 - midend */
1227 if (strstr(gl_renderer
, "GTX 260"))
1230 return CARD_NVIDIA_GEFORCE_GTX260
;
1232 /* Geforce 200 - midend */
1233 if (strstr(gl_renderer
, "GT 240"))
1236 return CARD_NVIDIA_GEFORCE_GT240
;
1239 /* Geforce9 - highend / Geforce 200 - midend (GTS 150/250 are based on the same core) */
1240 if (strstr(gl_renderer
, "9800")
1241 || strstr(gl_renderer
, "GTS 150")
1242 || strstr(gl_renderer
, "GTS 250"))
1245 return CARD_NVIDIA_GEFORCE_9800GT
;
1248 /* Geforce9 - midend */
1249 if (strstr(gl_renderer
, "9600"))
1251 *vidmem
= 384; /* The 9600GSO has 384MB, the 9600GT has 512-1024MB */
1252 return CARD_NVIDIA_GEFORCE_9600GT
;
1255 /* Geforce9 - midend low / Geforce 200 - low */
1256 if (strstr(gl_renderer
, "9500")
1257 || strstr(gl_renderer
, "GT 120")
1258 || strstr(gl_renderer
, "GT 130"))
1260 *vidmem
= 256; /* The 9500GT has 256-1024MB */
1261 return CARD_NVIDIA_GEFORCE_9500GT
;
1264 /* Geforce9 - lowend */
1265 if (strstr(gl_renderer
, "9400"))
1267 *vidmem
= 256; /* The 9400GT has 256-1024MB */
1268 return CARD_NVIDIA_GEFORCE_9400GT
;
1271 /* Geforce9 - lowend low */
1272 if (strstr(gl_renderer
, "9100")
1273 || strstr(gl_renderer
, "9200")
1274 || strstr(gl_renderer
, "9300")
1275 || strstr(gl_renderer
, "G 100"))
1277 *vidmem
= 256; /* The 9100-9300 cards have 256MB */
1278 return CARD_NVIDIA_GEFORCE_9200
;
1281 /* Geforce8 - highend */
1282 if (strstr(gl_renderer
, "8800"))
1284 *vidmem
= 320; /* The 8800GTS uses 320MB, a 8800GTX can have 768MB */
1285 return CARD_NVIDIA_GEFORCE_8800GTS
;
1288 /* Geforce8 - midend mobile */
1289 if (strstr(gl_renderer
, "8600 M"))
1292 return CARD_NVIDIA_GEFORCE_8600MGT
;
1295 /* Geforce8 - midend */
1296 if (strstr(gl_renderer
, "8600")
1297 || strstr(gl_renderer
, "8700"))
1300 return CARD_NVIDIA_GEFORCE_8600GT
;
1303 /* Geforce8 - lowend */
1304 if (strstr(gl_renderer
, "8100")
1305 || strstr(gl_renderer
, "8200")
1306 || strstr(gl_renderer
, "8300")
1307 || strstr(gl_renderer
, "8400")
1308 || strstr(gl_renderer
, "8500"))
1310 *vidmem
= 128; /* 128-256MB for a 8300, 256-512MB for a 8400 */
1311 return CARD_NVIDIA_GEFORCE_8300GS
;
1314 /* Geforce7 - highend */
1315 if (strstr(gl_renderer
, "7800")
1316 || strstr(gl_renderer
, "7900")
1317 || strstr(gl_renderer
, "7950")
1318 || strstr(gl_renderer
, "Quadro FX 4")
1319 || strstr(gl_renderer
, "Quadro FX 5"))
1321 *vidmem
= 256; /* A 7800GT uses 256MB while highend 7900 cards can use 512MB */
1322 return CARD_NVIDIA_GEFORCE_7800GT
;
1325 /* Geforce7 midend */
1326 if (strstr(gl_renderer
, "7600")
1327 || strstr(gl_renderer
, "7700"))
1329 *vidmem
= 256; /* The 7600 uses 256-512MB */
1330 return CARD_NVIDIA_GEFORCE_7600
;
1333 /* Geforce7 lower medium */
1334 if (strstr(gl_renderer
, "7400"))
1336 *vidmem
= 256; /* The 7400 uses 256-512MB */
1337 return CARD_NVIDIA_GEFORCE_7400
;
1340 /* Geforce7 lowend */
1341 if (strstr(gl_renderer
, "7300"))
1343 *vidmem
= 256; /* Mac Pros with this card have 256 MB */
1344 return CARD_NVIDIA_GEFORCE_7300
;
1347 /* Geforce6 highend */
1348 if (strstr(gl_renderer
, "6800"))
1350 *vidmem
= 128; /* The 6800 uses 128-256MB, the 7600 uses 256-512MB */
1351 return CARD_NVIDIA_GEFORCE_6800
;
1354 /* Geforce6 - midend */
1355 if (strstr(gl_renderer
, "6600")
1356 || strstr(gl_renderer
, "6610")
1357 || strstr(gl_renderer
, "6700"))
1359 *vidmem
= 128; /* A 6600GT has 128-256MB */
1360 return CARD_NVIDIA_GEFORCE_6600GT
;
1363 /* Geforce6/7 lowend */
1365 return CARD_NVIDIA_GEFORCE_6200
; /* Geforce 6100/6150/6200/7300/7400/7500 */
1368 if (WINE_D3D9_CAPABLE(gl_info
))
1370 /* GeforceFX - highend */
1371 if (strstr(gl_renderer
, "5800")
1372 || strstr(gl_renderer
, "5900")
1373 || strstr(gl_renderer
, "5950")
1374 || strstr(gl_renderer
, "Quadro FX"))
1376 *vidmem
= 256; /* 5800-5900 cards use 256MB */
1377 return CARD_NVIDIA_GEFORCEFX_5800
;
1380 /* GeforceFX - midend */
1381 if (strstr(gl_renderer
, "5600")
1382 || strstr(gl_renderer
, "5650")
1383 || strstr(gl_renderer
, "5700")
1384 || strstr(gl_renderer
, "5750"))
1386 *vidmem
= 128; /* A 5600 uses 128-256MB */
1387 return CARD_NVIDIA_GEFORCEFX_5600
;
1390 /* GeforceFX - lowend */
1391 *vidmem
= 64; /* Normal FX5200 cards use 64-256MB; laptop (non-standard) can have less */
1392 return CARD_NVIDIA_GEFORCEFX_5200
; /* GeforceFX 5100/5200/5250/5300/5500 */
1395 if (WINE_D3D8_CAPABLE(gl_info
))
1397 if (strstr(gl_renderer
, "GeForce4 Ti") || strstr(gl_renderer
, "Quadro4"))
1399 *vidmem
= 64; /* Geforce4 Ti cards have 64-128MB */
1400 return CARD_NVIDIA_GEFORCE4_TI4200
; /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800, Quadro4 */
1403 *vidmem
= 64; /* Geforce3 cards have 64-128MB */
1404 return CARD_NVIDIA_GEFORCE3
; /* Geforce3 standard/Ti200/Ti500, Quadro DCC */
1407 if (WINE_D3D7_CAPABLE(gl_info
))
1409 if (strstr(gl_renderer
, "GeForce4 MX"))
1411 /* Most Geforce4MX GPUs have at least 64MB of memory, some
1412 * early models had 32MB but most have 64MB or even 128MB. */
1414 return CARD_NVIDIA_GEFORCE4_MX
; /* MX420/MX440/MX460/MX4000 */
1417 if (strstr(gl_renderer
, "GeForce2 MX") || strstr(gl_renderer
, "Quadro2 MXR"))
1419 *vidmem
= 32; /* Geforce2MX GPUs have 32-64MB of video memory */
1420 return CARD_NVIDIA_GEFORCE2_MX
; /* Geforce2 standard/MX100/MX200/MX400, Quadro2 MXR */
1423 if (strstr(gl_renderer
, "GeForce2") || strstr(gl_renderer
, "Quadro2"))
1425 *vidmem
= 32; /* Geforce2 GPUs have 32-64MB of video memory */
1426 return CARD_NVIDIA_GEFORCE2
; /* Geforce2 GTS/Pro/Ti/Ultra, Quadro2 */
1429 /* Most Geforce1 cards have 32MB, there are also some rare 16
1430 * and 64MB (Dell) models. */
1432 return CARD_NVIDIA_GEFORCE
; /* Geforce 256/DDR, Quadro */
1435 if (strstr(gl_renderer
, "TNT2"))
1437 *vidmem
= 32; /* Most TNT2 boards have 32MB, though there are 16MB boards too */
1438 return CARD_NVIDIA_RIVA_TNT2
; /* Riva TNT2 standard/M64/Pro/Ultra */
1441 *vidmem
= 16; /* Most TNT boards have 16MB, some rare models have 8MB */
1442 return CARD_NVIDIA_RIVA_TNT
; /* Riva TNT, Vanta */
1445 /* See http://developer.amd.com/drivers/pc_vendor_id/Pages/default.aspx
1447 * Beware: renderer string do not match exact card model,
1448 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */
1449 if (WINE_D3D9_CAPABLE(gl_info
))
1451 /* Radeon EG CYPRESS XT / PRO HD5800 - highend */
1452 if (strstr(gl_renderer
, "HD 5800") /* Radeon EG CYPRESS HD58xx generic renderer string */
1453 || strstr(gl_renderer
, "HD 5850") /* Radeon EG CYPRESS XT */
1454 || strstr(gl_renderer
, "HD 5870")) /* Radeon EG CYPRESS PRO */
1456 *vidmem
= 1024; /* note: HD58xx cards use 1024MB */
1457 return CARD_ATI_RADEON_HD5800
;
1460 /* Radeon EG JUNIPER XT / LE HD5700 - midend */
1461 if (strstr(gl_renderer
, "HD 5700") /* Radeon EG JUNIPER HD57xx generic renderer string */
1462 || strstr(gl_renderer
, "HD 5750") /* Radeon EG JUNIPER LE */
1463 || strstr(gl_renderer
, "HD 5770")) /* Radeon EG JUNIPER XT */
1465 *vidmem
= 512; /* note: HD5770 cards use 1024MB and HD5750 cards use 512MB or 1024MB */
1466 return CARD_ATI_RADEON_HD5700
;
1469 /* Radeon R7xx HD4800 - highend */
1470 if (strstr(gl_renderer
, "HD 4800") /* Radeon RV7xx HD48xx generic renderer string */
1471 || strstr(gl_renderer
, "HD 4830") /* Radeon RV770 */
1472 || strstr(gl_renderer
, "HD 4850") /* Radeon RV770 */
1473 || strstr(gl_renderer
, "HD 4870") /* Radeon RV770 */
1474 || strstr(gl_renderer
, "HD 4890")) /* Radeon RV790 */
1476 *vidmem
= 512; /* note: HD4890 cards use 1024MB */
1477 return CARD_ATI_RADEON_HD4800
;
1480 /* Radeon R740 HD4700 - midend */
1481 if (strstr(gl_renderer
, "HD 4700") /* Radeon RV770 */
1482 || strstr(gl_renderer
, "HD 4770")) /* Radeon RV740 */
1485 return CARD_ATI_RADEON_HD4700
;
1488 /* Radeon R730 HD4600 - midend */
1489 if (strstr(gl_renderer
, "HD 4600") /* Radeon RV730 */
1490 || strstr(gl_renderer
, "HD 4650") /* Radeon RV730 */
1491 || strstr(gl_renderer
, "HD 4670")) /* Radeon RV730 */
1494 return CARD_ATI_RADEON_HD4600
;
1497 /* Radeon R710 HD4500/HD4350 - lowend */
1498 if (strstr(gl_renderer
, "HD 4350") /* Radeon RV710 */
1499 || strstr(gl_renderer
, "HD 4550")) /* Radeon RV710 */
1502 return CARD_ATI_RADEON_HD4350
;
1505 /* Radeon R6xx HD2900/HD3800 - highend */
1506 if (strstr(gl_renderer
, "HD 2900")
1507 || strstr(gl_renderer
, "HD 3870")
1508 || strstr(gl_renderer
, "HD 3850"))
1510 *vidmem
= 512; /* HD2900/HD3800 uses 256-1024MB */
1511 return CARD_ATI_RADEON_HD2900
;
1514 /* Radeon R6xx HD2600/HD3600 - midend; HD3830 is China-only midend */
1515 if (strstr(gl_renderer
, "HD 2600")
1516 || strstr(gl_renderer
, "HD 3830")
1517 || strstr(gl_renderer
, "HD 3690")
1518 || strstr(gl_renderer
, "HD 3650"))
1520 *vidmem
= 256; /* HD2600/HD3600 uses 256-512MB */
1521 return CARD_ATI_RADEON_HD2600
;
1524 /* Radeon R6xx HD2300/HD2400/HD3400 - lowend */
1525 if (strstr(gl_renderer
, "HD 2300")
1526 || strstr(gl_renderer
, "HD 2400")
1527 || strstr(gl_renderer
, "HD 3470")
1528 || strstr(gl_renderer
, "HD 3450")
1529 || strstr(gl_renderer
, "HD 3430")
1530 || strstr(gl_renderer
, "HD 3400"))
1532 *vidmem
= 128; /* HD2300 uses at least 128MB, HD2400 uses 256MB */
1533 return CARD_ATI_RADEON_HD2300
;
1536 /* Radeon R6xx/R7xx integrated */
1537 if (strstr(gl_renderer
, "HD 3100")
1538 || strstr(gl_renderer
, "HD 3200")
1539 || strstr(gl_renderer
, "HD 3300"))
1541 *vidmem
= 128; /* 128MB */
1542 return CARD_ATI_RADEON_HD3200
;
1546 if (strstr(gl_renderer
, "X1600")
1547 || strstr(gl_renderer
, "X1650")
1548 || strstr(gl_renderer
, "X1800")
1549 || strstr(gl_renderer
, "X1900")
1550 || strstr(gl_renderer
, "X1950"))
1552 *vidmem
= 128; /* X1600 uses 128-256MB, >=X1800 uses 256MB */
1553 return CARD_ATI_RADEON_X1600
;
1556 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300 (lowend R5xx) */
1557 if (strstr(gl_renderer
, "X700")
1558 || strstr(gl_renderer
, "X800")
1559 || strstr(gl_renderer
, "X850")
1560 || strstr(gl_renderer
, "X1300")
1561 || strstr(gl_renderer
, "X1400")
1562 || strstr(gl_renderer
, "X1450")
1563 || strstr(gl_renderer
, "X1550"))
1565 *vidmem
= 128; /* x700/x8*0 use 128-256MB, >=x1300 128-512MB */
1566 return CARD_ATI_RADEON_X700
;
1569 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400MHz */
1570 if (strstr(gl_renderer
, "Radeon Xpress"))
1572 *vidmem
= 64; /* Shared RAM, BIOS configurable, 64-256M */
1573 return CARD_ATI_RADEON_XPRESS_200M
;
1577 *vidmem
= 64; /* Radeon 9500 uses 64MB, higher models use up to 256MB */
1578 return CARD_ATI_RADEON_9500
; /* Radeon 9500/9550/9600/9700/9800/X300/X550/X600 */
1581 if (WINE_D3D8_CAPABLE(gl_info
))
1583 *vidmem
= 64; /* 8500/9000 cards use mostly 64MB, though there are 32MB and 128MB models */
1584 return CARD_ATI_RADEON_8500
; /* Radeon 8500/9000/9100/9200/9300 */
1587 if (WINE_D3D7_CAPABLE(gl_info
))
1589 *vidmem
= 32; /* There are models with up to 64MB */
1590 return CARD_ATI_RADEON_7200
; /* Radeon 7000/7100/7200/7500 */
1593 *vidmem
= 16; /* There are 16-32MB models */
1594 return CARD_ATI_RAGE_128PRO
;
1597 if (strstr(gl_renderer
, "X3100"))
1599 /* MacOS calls the card GMA X3100, Google findings also suggest the name GM965 */
1601 return CARD_INTEL_X3100
;
1604 if (strstr(gl_renderer
, "GMA 950") || strstr(gl_renderer
, "945GM"))
1606 /* MacOS calls the card GMA 950, but everywhere else the PCI ID is named 945GM */
1608 return CARD_INTEL_I945GM
;
1611 if (strstr(gl_renderer
, "915GM")) return CARD_INTEL_I915GM
;
1612 if (strstr(gl_renderer
, "915G")) return CARD_INTEL_I915G
;
1613 if (strstr(gl_renderer
, "865G")) return CARD_INTEL_I865G
;
1614 if (strstr(gl_renderer
, "855G")) return CARD_INTEL_I855G
;
1615 if (strstr(gl_renderer
, "830G")) return CARD_INTEL_I830G
;
1616 return CARD_INTEL_I915G
;
1621 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. The choice
1622 * for Nvidia was because the hardware and drivers they make are of good quality. This makes
1623 * them a good generic choice. */
1624 *vendor
= VENDOR_NVIDIA
;
1625 if (WINE_D3D9_CAPABLE(gl_info
)) return CARD_NVIDIA_GEFORCEFX_5600
;
1626 if (WINE_D3D8_CAPABLE(gl_info
)) return CARD_NVIDIA_GEFORCE3
;
1627 if (WINE_D3D7_CAPABLE(gl_info
)) return CARD_NVIDIA_GEFORCE
;
1628 if (WINE_D3D6_CAPABLE(gl_info
)) return CARD_NVIDIA_RIVA_TNT
;
1629 return CARD_NVIDIA_RIVA_128
;
1633 /* Context activation is done by the caller. */
1634 static BOOL
IWineD3DImpl_FillGLCaps(struct wined3d_driver_info
*driver_info
, struct wined3d_gl_info
*gl_info
)
1636 const char *GL_Extensions
= NULL
;
1637 const char *WGL_Extensions
= NULL
;
1638 const char *gl_string
= NULL
;
1639 enum wined3d_pci_vendor vendor
;
1640 enum wined3d_pci_device device
;
1642 GLfloat gl_floatv
[2];
1645 unsigned int vidmem
=0;
1650 TRACE_(d3d_caps
)("(%p)\n", gl_info
);
1654 gl_string
= (const char *)glGetString(GL_RENDERER
);
1655 TRACE_(d3d_caps
)("GL_RENDERER: %s.\n", debugstr_a(gl_string
));
1659 ERR_(d3d_caps
)("Received a NULL GL_RENDERER.\n");
1663 len
= strlen(gl_string
) + 1;
1664 gl_renderer
= HeapAlloc(GetProcessHeap(), 0, len
);
1668 ERR_(d3d_caps
)("Failed to allocate gl_renderer memory.\n");
1671 memcpy(gl_renderer
, gl_string
, len
);
1673 gl_string
= (const char *)glGetString(GL_VENDOR
);
1674 TRACE_(d3d_caps
)("GL_VENDOR: %s.\n", debugstr_a(gl_string
));
1678 ERR_(d3d_caps
)("Received a NULL GL_VENDOR.\n");
1679 HeapFree(GetProcessHeap(), 0, gl_renderer
);
1682 vendor
= wined3d_guess_vendor(gl_string
, gl_renderer
);
1683 TRACE_(d3d_caps
)("found GL_VENDOR (%s)->(0x%04x)\n", debugstr_a(gl_string
), vendor
);
1685 /* Parse the GL_VERSION field into major and minor information */
1686 gl_string
= (const char *)glGetString(GL_VERSION
);
1687 TRACE_(d3d_caps
)("GL_VERSION: %s.\n", debugstr_a(gl_string
));
1691 ERR_(d3d_caps
)("Received a NULL GL_VERSION.\n");
1692 HeapFree(GetProcessHeap(), 0, gl_renderer
);
1695 gl_version
= wined3d_parse_gl_version(gl_string
);
1698 * Initialize openGL extension related variables
1699 * with Default values
1701 memset(gl_info
->supported
, 0, sizeof(gl_info
->supported
));
1702 gl_info
->limits
.buffers
= 1;
1703 gl_info
->limits
.textures
= 1;
1704 gl_info
->limits
.texture_stages
= 1;
1705 gl_info
->limits
.fragment_samplers
= 1;
1706 gl_info
->limits
.vertex_samplers
= 0;
1707 gl_info
->limits
.combined_samplers
= gl_info
->limits
.fragment_samplers
+ gl_info
->limits
.vertex_samplers
;
1708 gl_info
->limits
.sampler_stages
= 1;
1709 gl_info
->limits
.glsl_vs_float_constants
= 0;
1710 gl_info
->limits
.glsl_ps_float_constants
= 0;
1711 gl_info
->limits
.arb_vs_float_constants
= 0;
1712 gl_info
->limits
.arb_vs_native_constants
= 0;
1713 gl_info
->limits
.arb_vs_instructions
= 0;
1714 gl_info
->limits
.arb_vs_temps
= 0;
1715 gl_info
->limits
.arb_ps_float_constants
= 0;
1716 gl_info
->limits
.arb_ps_local_constants
= 0;
1717 gl_info
->limits
.arb_ps_instructions
= 0;
1718 gl_info
->limits
.arb_ps_temps
= 0;
1720 /* Retrieve opengl defaults */
1721 glGetIntegerv(GL_MAX_CLIP_PLANES
, &gl_max
);
1722 gl_info
->limits
.clipplanes
= min(WINED3DMAXUSERCLIPPLANES
, gl_max
);
1723 TRACE_(d3d_caps
)("ClipPlanes support - num Planes=%d\n", gl_max
);
1725 glGetIntegerv(GL_MAX_LIGHTS
, &gl_max
);
1726 gl_info
->limits
.lights
= gl_max
;
1727 TRACE_(d3d_caps
)("Lights support - max lights=%d\n", gl_max
);
1729 glGetIntegerv(GL_MAX_TEXTURE_SIZE
, &gl_max
);
1730 gl_info
->limits
.texture_size
= gl_max
;
1731 TRACE_(d3d_caps
)("Maximum texture size support - max texture size=%d\n", gl_max
);
1733 glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE
, gl_floatv
);
1734 gl_info
->limits
.pointsize_min
= gl_floatv
[0];
1735 gl_info
->limits
.pointsize_max
= gl_floatv
[1];
1736 TRACE_(d3d_caps
)("Maximum point size support - max point size=%f\n", gl_floatv
[1]);
1738 /* Parse the gl supported features, in theory enabling parts of our code appropriately. */
1739 GL_Extensions
= (const char *)glGetString(GL_EXTENSIONS
);
1743 ERR_(d3d_caps
)("Received a NULL GL_EXTENSIONS.\n");
1744 HeapFree(GetProcessHeap(), 0, gl_renderer
);
1750 TRACE_(d3d_caps
)("GL_Extensions reported:\n");
1752 gl_info
->supported
[WINED3D_GL_EXT_NONE
] = TRUE
;
1754 while (*GL_Extensions
)
1757 char current_ext
[256];
1759 while (isspace(*GL_Extensions
)) ++GL_Extensions
;
1760 start
= GL_Extensions
;
1761 while (!isspace(*GL_Extensions
) && *GL_Extensions
) ++GL_Extensions
;
1763 len
= GL_Extensions
- start
;
1764 if (!len
|| len
>= sizeof(current_ext
)) continue;
1766 memcpy(current_ext
, start
, len
);
1767 current_ext
[len
] = '\0';
1768 TRACE_(d3d_caps
)("- %s\n", debugstr_a(current_ext
));
1770 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
)
1772 if (!strcmp(current_ext
, EXTENSION_MAP
[i
].extension_string
))
1774 TRACE_(d3d_caps
)(" FOUND: %s support.\n", EXTENSION_MAP
[i
].extension_string
);
1775 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
1781 /* Now work out what GL support this card really has */
1782 #define USE_GL_FUNC(type, pfn, ext, replace) \
1784 DWORD ver = ver_for_ext(ext); \
1785 if (gl_info->supported[ext]) gl_info->pfn = (type)pwglGetProcAddress(#pfn); \
1786 else if (ver && ver <= gl_version) gl_info->pfn = (type)pwglGetProcAddress(#replace); \
1787 else gl_info->pfn = NULL; \
1792 #define USE_GL_FUNC(type, pfn, ext, replace) gl_info->pfn = (type)pwglGetProcAddress(#pfn);
1798 /* Now mark all the extensions supported which are included in the opengl core version. Do this *after*
1799 * loading the functions, otherwise the code above will load the extension entry points instead of the
1800 * core functions, which may not work. */
1801 for (i
= 0; i
< (sizeof(EXTENSION_MAP
) / sizeof(*EXTENSION_MAP
)); ++i
)
1803 if (!gl_info
->supported
[EXTENSION_MAP
[i
].extension
]
1804 && EXTENSION_MAP
[i
].version
<= gl_version
&& EXTENSION_MAP
[i
].version
)
1806 TRACE_(d3d_caps
)(" GL CORE: %s support.\n", EXTENSION_MAP
[i
].extension_string
);
1807 gl_info
->supported
[EXTENSION_MAP
[i
].extension
] = TRUE
;
1811 if (gl_info
->supported
[APPLE_FENCE
])
1813 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
1814 * The apple extension interacts with some other apple exts. Disable the NV
1815 * extension if the apple one is support to prevent confusion in other parts
1817 gl_info
->supported
[NV_FENCE
] = FALSE
;
1819 if (gl_info
->supported
[APPLE_FLOAT_PIXELS
])
1821 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
1823 * The enums are the same:
1824 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881A
1825 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881B
1826 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814
1827 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815
1828 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140B
1830 if (!gl_info
->supported
[ARB_TEXTURE_FLOAT
])
1832 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_texture_float support(from GL_APPLE_float_pixels.\n");
1833 gl_info
->supported
[ARB_TEXTURE_FLOAT
] = TRUE
;
1835 if (!gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
])
1837 TRACE_(d3d_caps
)(" IMPLIED: GL_ARB_half_float_pixel support(from GL_APPLE_float_pixels.\n");
1838 gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
] = TRUE
;
1841 if (gl_info
->supported
[ARB_MAP_BUFFER_RANGE
])
1843 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
1844 * functionality. Prefer the ARB extension */
1845 gl_info
->supported
[APPLE_FLUSH_BUFFER_RANGE
] = FALSE
;
1847 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
1849 TRACE_(d3d_caps
)(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
1850 gl_info
->supported
[NV_TEXGEN_REFLECTION
] = TRUE
;
1852 if (!gl_info
->supported
[ARB_DEPTH_CLAMP
] && gl_info
->supported
[NV_DEPTH_CLAMP
])
1854 TRACE_(d3d_caps
)(" IMPLIED: ARB_depth_clamp support (by NV_depth_clamp).\n");
1855 gl_info
->supported
[ARB_DEPTH_CLAMP
] = TRUE
;
1857 if (!gl_info
->supported
[ARB_VERTEX_ARRAY_BGRA
] && gl_info
->supported
[EXT_VERTEX_ARRAY_BGRA
])
1859 TRACE_(d3d_caps
)(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n");
1860 gl_info
->supported
[ARB_VERTEX_ARRAY_BGRA
] = TRUE
;
1862 if (gl_info
->supported
[NV_TEXTURE_SHADER2
])
1864 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
1866 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
1867 * are supported. The nv extensions provide the same functionality as the
1868 * ATI one, and a bit more(signed pixelformats). */
1869 gl_info
->supported
[ATI_FRAGMENT_SHADER
] = FALSE
;
1872 if (gl_info
->supported
[ARB_DRAW_BUFFERS
])
1874 glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB
, &gl_max
);
1875 gl_info
->limits
.buffers
= gl_max
;
1876 TRACE_(d3d_caps
)("Max draw buffers: %u.\n", gl_max
);
1878 if (gl_info
->supported
[ARB_MULTITEXTURE
])
1880 glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB
, &gl_max
);
1881 gl_info
->limits
.textures
= min(MAX_TEXTURES
, gl_max
);
1882 TRACE_(d3d_caps
)("Max textures: %d.\n", gl_info
->limits
.textures
);
1884 if (gl_info
->supported
[NV_REGISTER_COMBINERS
])
1887 glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV
, &tmp
);
1888 gl_info
->limits
.texture_stages
= min(MAX_TEXTURES
, tmp
);
1892 gl_info
->limits
.texture_stages
= min(MAX_TEXTURES
, gl_max
);
1894 TRACE_(d3d_caps
)("Max texture stages: %d.\n", gl_info
->limits
.texture_stages
);
1896 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
])
1899 glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
1900 gl_info
->limits
.fragment_samplers
= min(MAX_FRAGMENT_SAMPLERS
, tmp
);
1904 gl_info
->limits
.fragment_samplers
= max(gl_info
->limits
.fragment_samplers
, gl_max
);
1906 TRACE_(d3d_caps
)("Max fragment samplers: %d.\n", gl_info
->limits
.fragment_samplers
);
1908 if (gl_info
->supported
[ARB_VERTEX_SHADER
])
1911 glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
1912 gl_info
->limits
.vertex_samplers
= tmp
;
1913 glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB
, &tmp
);
1914 gl_info
->limits
.combined_samplers
= tmp
;
1916 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup
1917 * is known at shader link time. In a vertex shader + pixel shader combination this isn't
1918 * an issue because then the sampler setup only depends on the two shaders. If a pixel
1919 * shader is used with fixed function vertex processing we're fine too because fixed function
1920 * vertex processing doesn't use any samplers. If fixed function fragment processing is
1921 * used we have to make sure that all vertex sampler setups are valid together with all
1922 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES
1923 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards).
1924 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and
1925 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have
1926 * a fixed function pipeline anymore.
1928 * So this is just a check to check that our assumption holds true. If not, write a warning
1929 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */
1930 if (gl_info
->limits
.vertex_samplers
&& gl_info
->limits
.combined_samplers
< 12
1931 && MAX_TEXTURES
+ gl_info
->limits
.vertex_samplers
> gl_info
->limits
.combined_samplers
)
1933 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
1934 gl_info
->limits
.vertex_samplers
, gl_info
->limits
.combined_samplers
);
1935 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n");
1936 if (gl_info
->limits
.combined_samplers
> MAX_TEXTURES
)
1937 gl_info
->limits
.vertex_samplers
= gl_info
->limits
.combined_samplers
- MAX_TEXTURES
;
1939 gl_info
->limits
.vertex_samplers
= 0;
1944 gl_info
->limits
.combined_samplers
= gl_info
->limits
.fragment_samplers
;
1946 TRACE_(d3d_caps
)("Max vertex samplers: %u.\n", gl_info
->limits
.vertex_samplers
);
1947 TRACE_(d3d_caps
)("Max combined samplers: %u.\n", gl_info
->limits
.combined_samplers
);
1949 if (gl_info
->supported
[ARB_VERTEX_BLEND
])
1951 glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB
, &gl_max
);
1952 gl_info
->limits
.blends
= gl_max
;
1953 TRACE_(d3d_caps
)("Max blends: %u.\n", gl_info
->limits
.blends
);
1955 if (gl_info
->supported
[EXT_TEXTURE3D
])
1957 glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT
, &gl_max
);
1958 gl_info
->limits
.texture3d_size
= gl_max
;
1959 TRACE_(d3d_caps
)("Max texture3D size: %d.\n", gl_info
->limits
.texture3d_size
);
1961 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
1963 glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT
, &gl_max
);
1964 gl_info
->limits
.anisotropy
= gl_max
;
1965 TRACE_(d3d_caps
)("Max anisotropy: %d.\n", gl_info
->limits
.anisotropy
);
1967 if (gl_info
->supported
[ARB_FRAGMENT_PROGRAM
])
1969 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
1970 gl_info
->limits
.arb_ps_float_constants
= gl_max
;
1971 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info
->limits
.arb_ps_float_constants
);
1972 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
, &gl_max
));
1973 gl_info
->limits
.arb_ps_native_constants
= gl_max
;
1974 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
1975 gl_info
->limits
.arb_ps_native_constants
);
1976 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
1977 gl_info
->limits
.arb_ps_temps
= gl_max
;
1978 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info
->limits
.arb_ps_temps
);
1979 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
1980 gl_info
->limits
.arb_ps_instructions
= gl_max
;
1981 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info
->limits
.arb_ps_instructions
);
1982 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB
, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB
, &gl_max
));
1983 gl_info
->limits
.arb_ps_local_constants
= gl_max
;
1984 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info
->limits
.arb_ps_instructions
);
1986 if (gl_info
->supported
[ARB_VERTEX_PROGRAM
])
1988 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB
, &gl_max
));
1989 gl_info
->limits
.arb_vs_float_constants
= gl_max
;
1990 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info
->limits
.arb_vs_float_constants
);
1991 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB
, &gl_max
));
1992 gl_info
->limits
.arb_vs_native_constants
= gl_max
;
1993 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
1994 gl_info
->limits
.arb_vs_native_constants
);
1995 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB
, &gl_max
));
1996 gl_info
->limits
.arb_vs_temps
= gl_max
;
1997 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info
->limits
.arb_vs_temps
);
1998 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB
, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB
, &gl_max
));
1999 gl_info
->limits
.arb_vs_instructions
= gl_max
;
2000 TRACE_(d3d_caps
)("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info
->limits
.arb_vs_instructions
);
2002 if (test_arb_vs_offset_limit(gl_info
)) gl_info
->quirks
|= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT
;
2004 if (gl_info
->supported
[ARB_VERTEX_SHADER
])
2006 glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB
, &gl_max
);
2007 gl_info
->limits
.glsl_vs_float_constants
= gl_max
/ 4;
2008 TRACE_(d3d_caps
)("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info
->limits
.glsl_vs_float_constants
);
2010 if (gl_info
->supported
[ARB_FRAGMENT_SHADER
])
2012 glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB
, &gl_max
);
2013 gl_info
->limits
.glsl_ps_float_constants
= gl_max
/ 4;
2014 TRACE_(d3d_caps
)("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info
->limits
.glsl_ps_float_constants
);
2015 glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB
, &gl_max
);
2016 gl_info
->limits
.glsl_varyings
= gl_max
;
2017 TRACE_(d3d_caps
)("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max
, gl_max
/ 4);
2019 if (gl_info
->supported
[ARB_SHADING_LANGUAGE_100
])
2021 const char *str
= (const char *)glGetString(GL_SHADING_LANGUAGE_VERSION_ARB
);
2022 TRACE_(d3d_caps
)("GLSL version string: %s.\n", debugstr_a(str
));
2024 if (gl_info
->supported
[NV_LIGHT_MAX_EXPONENT
])
2026 glGetFloatv(GL_MAX_SHININESS_NV
, &gl_info
->limits
.shininess
);
2030 gl_info
->limits
.shininess
= 128.0f
;
2032 if (gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
])
2034 /* If we have full NP2 texture support, disable
2035 * GL_ARB_texture_rectangle because we will never use it.
2036 * This saves a few redundant glDisable calls. */
2037 gl_info
->supported
[ARB_TEXTURE_RECTANGLE
] = FALSE
;
2039 if (gl_info
->supported
[ATI_FRAGMENT_SHADER
])
2041 /* Disable NV_register_combiners and fragment shader if this is supported.
2042 * generally the NV extensions are preferred over the ATI ones, and this
2043 * extension is disabled if register_combiners and texture_shader2 are both
2044 * supported. So we reach this place only if we have incomplete NV dxlevel 8
2045 * fragment processing support. */
2046 gl_info
->supported
[NV_REGISTER_COMBINERS
] = FALSE
;
2047 gl_info
->supported
[NV_REGISTER_COMBINERS2
] = FALSE
;
2048 gl_info
->supported
[NV_TEXTURE_SHADER
] = FALSE
;
2049 gl_info
->supported
[NV_TEXTURE_SHADER2
] = FALSE
;
2050 gl_info
->supported
[NV_TEXTURE_SHADER3
] = FALSE
;
2052 if (gl_info
->supported
[NV_HALF_FLOAT
])
2054 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
2055 gl_info
->supported
[ARB_HALF_FLOAT_VERTEX
] = TRUE
;
2057 if (gl_info
->supported
[ARB_POINT_SPRITE
])
2059 gl_info
->limits
.point_sprite_units
= gl_info
->limits
.textures
;
2063 gl_info
->limits
.point_sprite_units
= 0;
2065 checkGLcall("extension detection");
2069 /* In some cases the number of texture stages can be larger than the number
2070 * of samplers. The GF4 for example can use only 2 samplers (no fragment
2071 * shaders), but 8 texture stages (register combiners). */
2072 gl_info
->limits
.sampler_stages
= max(gl_info
->limits
.fragment_samplers
, gl_info
->limits
.texture_stages
);
2074 if (gl_info
->supported
[ARB_FRAMEBUFFER_OBJECT
])
2076 gl_info
->fbo_ops
.glIsRenderbuffer
= gl_info
->glIsRenderbuffer
;
2077 gl_info
->fbo_ops
.glBindRenderbuffer
= gl_info
->glBindRenderbuffer
;
2078 gl_info
->fbo_ops
.glDeleteRenderbuffers
= gl_info
->glDeleteRenderbuffers
;
2079 gl_info
->fbo_ops
.glGenRenderbuffers
= gl_info
->glGenRenderbuffers
;
2080 gl_info
->fbo_ops
.glRenderbufferStorage
= gl_info
->glRenderbufferStorage
;
2081 gl_info
->fbo_ops
.glRenderbufferStorageMultisample
= gl_info
->glRenderbufferStorageMultisample
;
2082 gl_info
->fbo_ops
.glGetRenderbufferParameteriv
= gl_info
->glGetRenderbufferParameteriv
;
2083 gl_info
->fbo_ops
.glIsFramebuffer
= gl_info
->glIsFramebuffer
;
2084 gl_info
->fbo_ops
.glBindFramebuffer
= gl_info
->glBindFramebuffer
;
2085 gl_info
->fbo_ops
.glDeleteFramebuffers
= gl_info
->glDeleteFramebuffers
;
2086 gl_info
->fbo_ops
.glGenFramebuffers
= gl_info
->glGenFramebuffers
;
2087 gl_info
->fbo_ops
.glCheckFramebufferStatus
= gl_info
->glCheckFramebufferStatus
;
2088 gl_info
->fbo_ops
.glFramebufferTexture1D
= gl_info
->glFramebufferTexture1D
;
2089 gl_info
->fbo_ops
.glFramebufferTexture2D
= gl_info
->glFramebufferTexture2D
;
2090 gl_info
->fbo_ops
.glFramebufferTexture3D
= gl_info
->glFramebufferTexture3D
;
2091 gl_info
->fbo_ops
.glFramebufferRenderbuffer
= gl_info
->glFramebufferRenderbuffer
;
2092 gl_info
->fbo_ops
.glGetFramebufferAttachmentParameteriv
= gl_info
->glGetFramebufferAttachmentParameteriv
;
2093 gl_info
->fbo_ops
.glBlitFramebuffer
= gl_info
->glBlitFramebuffer
;
2094 gl_info
->fbo_ops
.glGenerateMipmap
= gl_info
->glGenerateMipmap
;
2098 if (gl_info
->supported
[EXT_FRAMEBUFFER_OBJECT
])
2100 gl_info
->fbo_ops
.glIsRenderbuffer
= gl_info
->glIsRenderbufferEXT
;
2101 gl_info
->fbo_ops
.glBindRenderbuffer
= gl_info
->glBindRenderbufferEXT
;
2102 gl_info
->fbo_ops
.glDeleteRenderbuffers
= gl_info
->glDeleteRenderbuffersEXT
;
2103 gl_info
->fbo_ops
.glGenRenderbuffers
= gl_info
->glGenRenderbuffersEXT
;
2104 gl_info
->fbo_ops
.glRenderbufferStorage
= gl_info
->glRenderbufferStorageEXT
;
2105 gl_info
->fbo_ops
.glGetRenderbufferParameteriv
= gl_info
->glGetRenderbufferParameterivEXT
;
2106 gl_info
->fbo_ops
.glIsFramebuffer
= gl_info
->glIsFramebufferEXT
;
2107 gl_info
->fbo_ops
.glBindFramebuffer
= gl_info
->glBindFramebufferEXT
;
2108 gl_info
->fbo_ops
.glDeleteFramebuffers
= gl_info
->glDeleteFramebuffersEXT
;
2109 gl_info
->fbo_ops
.glGenFramebuffers
= gl_info
->glGenFramebuffersEXT
;
2110 gl_info
->fbo_ops
.glCheckFramebufferStatus
= gl_info
->glCheckFramebufferStatusEXT
;
2111 gl_info
->fbo_ops
.glFramebufferTexture1D
= gl_info
->glFramebufferTexture1DEXT
;
2112 gl_info
->fbo_ops
.glFramebufferTexture2D
= gl_info
->glFramebufferTexture2DEXT
;
2113 gl_info
->fbo_ops
.glFramebufferTexture3D
= gl_info
->glFramebufferTexture3DEXT
;
2114 gl_info
->fbo_ops
.glFramebufferRenderbuffer
= gl_info
->glFramebufferRenderbufferEXT
;
2115 gl_info
->fbo_ops
.glGetFramebufferAttachmentParameteriv
= gl_info
->glGetFramebufferAttachmentParameterivEXT
;
2116 gl_info
->fbo_ops
.glGenerateMipmap
= gl_info
->glGenerateMipmapEXT
;
2118 else if (wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
)
2120 WARN_(d3d_caps
)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
2121 wined3d_settings
.offscreen_rendering_mode
= ORM_BACKBUFFER
;
2123 if (gl_info
->supported
[EXT_FRAMEBUFFER_BLIT
])
2125 gl_info
->fbo_ops
.glBlitFramebuffer
= gl_info
->glBlitFramebufferEXT
;
2127 if (gl_info
->supported
[EXT_FRAMEBUFFER_MULTISAMPLE
])
2129 gl_info
->fbo_ops
.glRenderbufferStorageMultisample
= gl_info
->glRenderbufferStorageMultisampleEXT
;
2133 /* MRTs are currently only supported when FBOs are used. */
2134 if (wined3d_settings
.offscreen_rendering_mode
!= ORM_FBO
)
2136 gl_info
->limits
.buffers
= 1;
2139 device
= wined3d_guess_card(gl_info
, gl_renderer
, &vendor
, &vidmem
);
2140 TRACE_(d3d_caps
)("FOUND (fake) card: 0x%x (vendor id), 0x%x (device id)\n", vendor
, device
);
2142 /* If we have an estimate use it, else default to 64MB; */
2144 gl_info
->vidmem
= vidmem
*1024*1024; /* convert from MBs to bytes */
2146 gl_info
->vidmem
= WINE_DEFAULT_VIDMEM
;
2148 gl_info
->wrap_lookup
[WINED3DTADDRESS_WRAP
- WINED3DTADDRESS_WRAP
] = GL_REPEAT
;
2149 gl_info
->wrap_lookup
[WINED3DTADDRESS_MIRROR
- WINED3DTADDRESS_WRAP
] =
2150 gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
] ? GL_MIRRORED_REPEAT_ARB
: GL_REPEAT
;
2151 gl_info
->wrap_lookup
[WINED3DTADDRESS_CLAMP
- WINED3DTADDRESS_WRAP
] = GL_CLAMP_TO_EDGE
;
2152 gl_info
->wrap_lookup
[WINED3DTADDRESS_BORDER
- WINED3DTADDRESS_WRAP
] =
2153 gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
] ? GL_CLAMP_TO_BORDER_ARB
: GL_REPEAT
;
2154 gl_info
->wrap_lookup
[WINED3DTADDRESS_MIRRORONCE
- WINED3DTADDRESS_WRAP
] =
2155 gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
] ? GL_MIRROR_CLAMP_TO_EDGE_ATI
: GL_REPEAT
;
2157 /* Make sure there's an active HDC else the WGL extensions will fail */
2158 hdc
= pwglGetCurrentDC();
2160 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox */
2161 if(GL_EXTCALL(wglGetExtensionsStringARB
))
2162 WGL_Extensions
= GL_EXTCALL(wglGetExtensionsStringARB(hdc
));
2164 if (NULL
== WGL_Extensions
) {
2165 ERR(" WGL_Extensions returns NULL\n");
2167 TRACE_(d3d_caps
)("WGL_Extensions reported:\n");
2168 while (*WGL_Extensions
!= 0x00) {
2172 while (isspace(*WGL_Extensions
)) WGL_Extensions
++;
2173 Start
= WGL_Extensions
;
2174 while (!isspace(*WGL_Extensions
) && *WGL_Extensions
!= 0x00) {
2178 len
= WGL_Extensions
- Start
;
2179 if (len
== 0 || len
>= sizeof(ThisExtn
))
2182 memcpy(ThisExtn
, Start
, len
);
2183 ThisExtn
[len
] = '\0';
2184 TRACE_(d3d_caps
)("- %s\n", debugstr_a(ThisExtn
));
2186 if (!strcmp(ThisExtn
, "WGL_ARB_pbuffer")) {
2187 gl_info
->supported
[WGL_ARB_PBUFFER
] = TRUE
;
2188 TRACE_(d3d_caps
)("FOUND: WGL_ARB_pbuffer support\n");
2190 if (!strcmp(ThisExtn
, "WGL_ARB_pixel_format")) {
2191 gl_info
->supported
[WGL_ARB_PIXEL_FORMAT
] = TRUE
;
2192 TRACE_(d3d_caps
)("FOUND: WGL_ARB_pixel_format support\n");
2194 if (!strcmp(ThisExtn
, "WGL_WINE_pixel_format_passthrough")) {
2195 gl_info
->supported
[WGL_WINE_PIXEL_FORMAT_PASSTHROUGH
] = TRUE
;
2196 TRACE_(d3d_caps
)("FOUND: WGL_WINE_pixel_format_passthrough support\n");
2202 fixup_extensions(gl_info
, gl_renderer
, vendor
, device
);
2203 init_driver_info(driver_info
, vendor
, device
);
2204 add_gl_compat_wrappers(gl_info
);
2206 HeapFree(GetProcessHeap(), 0, gl_renderer
);
2210 /**********************************************************
2211 * IWineD3D implementation follows
2212 **********************************************************/
2214 static UINT WINAPI
IWineD3DImpl_GetAdapterCount (IWineD3D
*iface
) {
2215 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2217 TRACE_(d3d_caps
)("(%p): Reporting %u adapters\n", This
, This
->adapter_count
);
2219 return This
->adapter_count
;
2222 static HRESULT WINAPI
IWineD3DImpl_RegisterSoftwareDevice(IWineD3D
*iface
, void *init_function
)
2224 FIXME("iface %p, init_function %p stub!\n", iface
, init_function
);
2229 static HMONITOR WINAPI
IWineD3DImpl_GetAdapterMonitor(IWineD3D
*iface
, UINT Adapter
) {
2230 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2232 TRACE_(d3d_caps
)("(%p)->(%d)\n", This
, Adapter
);
2234 if (Adapter
>= IWineD3DImpl_GetAdapterCount(iface
)) {
2238 return MonitorFromPoint(This
->adapters
[Adapter
].monitorPoint
, MONITOR_DEFAULTTOPRIMARY
);
2241 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes
2242 of the same bpp but different resolutions */
2244 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2245 static UINT WINAPI
IWineD3DImpl_GetAdapterModeCount(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
) {
2246 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2247 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Format: %s)\n", This
, Adapter
, debug_d3dformat(Format
));
2249 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2253 /* TODO: Store modes per adapter and read it from the adapter structure */
2254 if (Adapter
== 0) { /* Display */
2255 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(Format
, &This
->adapters
[Adapter
].gl_info
);
2256 UINT format_bits
= format_desc
->byte_count
* CHAR_BIT
;
2261 memset(&mode
, 0, sizeof(mode
));
2262 mode
.dmSize
= sizeof(mode
);
2264 while (EnumDisplaySettingsExW(NULL
, j
, &mode
, 0))
2268 if (Format
== WINED3DFMT_UNKNOWN
)
2270 /* This is for D3D8, do not enumerate P8 here */
2271 if (mode
.dmBitsPerPel
== 32 || mode
.dmBitsPerPel
== 16) ++i
;
2273 else if (mode
.dmBitsPerPel
== format_bits
)
2279 TRACE_(d3d_caps
)("(%p}->(Adapter: %d) => %d (out of %d)\n", This
, Adapter
, i
, j
);
2282 FIXME_(d3d_caps
)("Adapter not primary display\n");
2287 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */
2288 static HRESULT WINAPI
IWineD3DImpl_EnumAdapterModes(IWineD3D
*iface
, UINT Adapter
, WINED3DFORMAT Format
, UINT Mode
, WINED3DDISPLAYMODE
* pMode
) {
2289 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2290 TRACE_(d3d_caps
)("(%p}->(Adapter:%d, mode:%d, pMode:%p, format:%s)\n", This
, Adapter
, Mode
, pMode
, debug_d3dformat(Format
));
2292 /* Validate the parameters as much as possible */
2293 if (NULL
== pMode
||
2294 Adapter
>= IWineD3DImpl_GetAdapterCount(iface
) ||
2295 Mode
>= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, Format
)) {
2296 return WINED3DERR_INVALIDCALL
;
2299 /* TODO: Store modes per adapter and read it from the adapter structure */
2302 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(Format
, &This
->adapters
[Adapter
].gl_info
);
2303 UINT format_bits
= format_desc
->byte_count
* CHAR_BIT
;
2309 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
2310 DevModeW
.dmSize
= sizeof(DevModeW
);
2312 /* If we are filtering to a specific format (D3D9), then need to skip
2313 all unrelated modes, but if mode is irrelevant (D3D8), then we can
2314 just count through the ones with valid bit depths */
2315 while ((i
<=Mode
) && EnumDisplaySettingsExW(NULL
, j
++, &DevModeW
, 0))
2317 if (Format
== WINED3DFMT_UNKNOWN
)
2319 /* This is for D3D8, do not enumerate P8 here */
2320 if (DevModeW
.dmBitsPerPel
== 32 || DevModeW
.dmBitsPerPel
== 16) ++i
;
2322 else if (DevModeW
.dmBitsPerPel
== format_bits
)
2329 TRACE_(d3d_caps
)("No modes found for format (%x - %s)\n", Format
, debug_d3dformat(Format
));
2330 return WINED3DERR_INVALIDCALL
;
2334 /* Now get the display mode via the calculated index */
2335 if (EnumDisplaySettingsExW(NULL
, ModeIdx
, &DevModeW
, 0)) {
2336 pMode
->Width
= DevModeW
.dmPelsWidth
;
2337 pMode
->Height
= DevModeW
.dmPelsHeight
;
2338 pMode
->RefreshRate
= DEFAULT_REFRESH_RATE
;
2339 if (DevModeW
.dmFields
& DM_DISPLAYFREQUENCY
)
2340 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
2342 if (Format
== WINED3DFMT_UNKNOWN
) {
2343 pMode
->Format
= pixelformat_for_depth(DevModeW
.dmBitsPerPel
);
2345 pMode
->Format
= Format
;
2348 TRACE_(d3d_caps
)("Requested mode out of range %d\n", Mode
);
2349 return WINED3DERR_INVALIDCALL
;
2352 TRACE_(d3d_caps
)("W %d H %d rr %d fmt (%x - %s) bpp %u\n", pMode
->Width
, pMode
->Height
,
2353 pMode
->RefreshRate
, pMode
->Format
, debug_d3dformat(pMode
->Format
),
2354 DevModeW
.dmBitsPerPel
);
2359 FIXME_(d3d_caps
)("Adapter not primary display\n");
2365 static HRESULT WINAPI
IWineD3DImpl_GetAdapterDisplayMode(IWineD3D
*iface
, UINT Adapter
, WINED3DDISPLAYMODE
*pMode
)
2367 TRACE("iface %p, adapter_idx %u, display_mode %p.\n", iface
, Adapter
, pMode
);
2369 if (NULL
== pMode
||
2370 Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2371 return WINED3DERR_INVALIDCALL
;
2374 if (Adapter
== 0) { /* Display */
2378 ZeroMemory(&DevModeW
, sizeof(DevModeW
));
2379 DevModeW
.dmSize
= sizeof(DevModeW
);
2381 EnumDisplaySettingsExW(NULL
, ENUM_CURRENT_SETTINGS
, &DevModeW
, 0);
2382 pMode
->Width
= DevModeW
.dmPelsWidth
;
2383 pMode
->Height
= DevModeW
.dmPelsHeight
;
2384 bpp
= DevModeW
.dmBitsPerPel
;
2385 pMode
->RefreshRate
= DEFAULT_REFRESH_RATE
;
2386 if (DevModeW
.dmFields
&DM_DISPLAYFREQUENCY
)
2388 pMode
->RefreshRate
= DevModeW
.dmDisplayFrequency
;
2391 pMode
->Format
= pixelformat_for_depth(bpp
);
2393 FIXME_(d3d_caps
)("Adapter not primary display\n");
2396 TRACE_(d3d_caps
)("returning w:%d, h:%d, ref:%d, fmt:%s\n", pMode
->Width
,
2397 pMode
->Height
, pMode
->RefreshRate
, debug_d3dformat(pMode
->Format
));
2401 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER,
2402 and fields being inserted in the middle, a new structure is used in place */
2403 static HRESULT WINAPI
IWineD3DImpl_GetAdapterIdentifier(IWineD3D
*iface
, UINT Adapter
, DWORD Flags
,
2404 WINED3DADAPTER_IDENTIFIER
* pIdentifier
) {
2405 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2406 struct wined3d_adapter
*adapter
;
2409 TRACE_(d3d_caps
)("(%p}->(Adapter: %d, Flags: %x, pId=%p)\n", This
, Adapter
, Flags
, pIdentifier
);
2411 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2412 return WINED3DERR_INVALIDCALL
;
2415 adapter
= &This
->adapters
[Adapter
];
2417 /* Return the information requested */
2418 TRACE_(d3d_caps
)("device/Vendor Name and Version detection using FillGLCaps\n");
2420 if (pIdentifier
->driver_size
)
2422 const char *name
= adapter
->driver_info
.name
;
2423 len
= min(strlen(name
), pIdentifier
->driver_size
- 1);
2424 memcpy(pIdentifier
->driver
, name
, len
);
2425 pIdentifier
->driver
[len
] = '\0';
2428 if (pIdentifier
->description_size
)
2430 const char *description
= adapter
->driver_info
.description
;
2431 len
= min(strlen(description
), pIdentifier
->description_size
- 1);
2432 memcpy(pIdentifier
->description
, description
, len
);
2433 pIdentifier
->description
[len
] = '\0';
2436 /* Note that d3d8 doesn't supply a device name. */
2437 if (pIdentifier
->device_name_size
)
2439 static const char *device_name
= "\\\\.\\DISPLAY1"; /* FIXME: May depend on desktop? */
2441 len
= strlen(device_name
);
2442 if (len
>= pIdentifier
->device_name_size
)
2444 ERR("Device name size too small.\n");
2445 return WINED3DERR_INVALIDCALL
;
2448 memcpy(pIdentifier
->device_name
, device_name
, len
);
2449 pIdentifier
->device_name
[len
] = '\0';
2452 pIdentifier
->driver_version
.u
.HighPart
= adapter
->driver_info
.version_high
;
2453 pIdentifier
->driver_version
.u
.LowPart
= adapter
->driver_info
.version_low
;
2454 pIdentifier
->vendor_id
= adapter
->driver_info
.vendor
;
2455 pIdentifier
->device_id
= adapter
->driver_info
.device
;
2456 pIdentifier
->subsystem_id
= 0;
2457 pIdentifier
->revision
= 0;
2458 memcpy(&pIdentifier
->device_identifier
, &IID_D3DDEVICE_D3DUID
, sizeof(pIdentifier
->device_identifier
));
2459 pIdentifier
->whql_level
= (Flags
& WINED3DENUM_NO_WHQL_LEVEL
) ? 0 : 1;
2460 memcpy(&pIdentifier
->adapter_luid
, &adapter
->luid
, sizeof(pIdentifier
->adapter_luid
));
2461 pIdentifier
->video_memory
= adapter
->TextureRam
;
2466 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(const struct wined3d_gl_info
*gl_info
,
2467 const WineD3D_PixelFormat
*cfg
, const struct GlPixelFormatDesc
*format_desc
)
2469 short redSize
, greenSize
, blueSize
, alphaSize
, colorBits
;
2474 if(cfg
->iPixelType
== WGL_TYPE_RGBA_ARB
) { /* Integer RGBA formats */
2475 if (!getColorBits(format_desc
, &redSize
, &greenSize
, &blueSize
, &alphaSize
, &colorBits
))
2477 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc
->format
));
2481 if(cfg
->redSize
< redSize
)
2484 if(cfg
->greenSize
< greenSize
)
2487 if(cfg
->blueSize
< blueSize
)
2490 if(cfg
->alphaSize
< alphaSize
)
2494 } else if(cfg
->iPixelType
== WGL_TYPE_RGBA_FLOAT_ARB
) { /* Float RGBA formats; TODO: WGL_NV_float_buffer */
2495 if (format_desc
->format
== WINED3DFMT_R16_FLOAT
)
2496 return (cfg
->redSize
== 16 && cfg
->greenSize
== 0 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2497 if (format_desc
->format
== WINED3DFMT_R16G16_FLOAT
)
2498 return (cfg
->redSize
== 16 && cfg
->greenSize
== 16 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2499 if (format_desc
->format
== WINED3DFMT_R16G16B16A16_FLOAT
)
2500 return (cfg
->redSize
== 16 && cfg
->greenSize
== 16 && cfg
->blueSize
== 16 && cfg
->alphaSize
== 16);
2501 if (format_desc
->format
== WINED3DFMT_R32_FLOAT
)
2502 return (cfg
->redSize
== 32 && cfg
->greenSize
== 0 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2503 if (format_desc
->format
== WINED3DFMT_R32G32_FLOAT
)
2504 return (cfg
->redSize
== 32 && cfg
->greenSize
== 32 && cfg
->blueSize
== 0 && cfg
->alphaSize
== 0);
2505 if (format_desc
->format
== WINED3DFMT_R32G32B32A32_FLOAT
)
2506 return (cfg
->redSize
== 32 && cfg
->greenSize
== 32 && cfg
->blueSize
== 32 && cfg
->alphaSize
== 32);
2508 /* Probably a color index mode */
2515 static BOOL
IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(const struct wined3d_gl_info
*gl_info
,
2516 const WineD3D_PixelFormat
*cfg
, const struct GlPixelFormatDesc
*format_desc
)
2518 short depthSize
, stencilSize
;
2519 BOOL lockable
= FALSE
;
2524 if (!getDepthStencilBits(format_desc
, &depthSize
, &stencilSize
))
2526 ERR("Unable to check compatibility for Format=%s\n", debug_d3dformat(format_desc
->format
));
2530 if ((format_desc
->format
== WINED3DFMT_D16_LOCKABLE
) || (format_desc
->format
== WINED3DFMT_D32_FLOAT
))
2533 /* On some modern cards like the Geforce8/9 GLX doesn't offer some dephthstencil formats which D3D9 reports.
2534 * We can safely report 'compatible' formats (e.g. D24 can be used for D16) as long as we aren't dealing with
2535 * a lockable format. This also helps D3D <= 7 as they expect D16 which isn't offered without this on Geforce8 cards. */
2536 if(!(cfg
->depthSize
== depthSize
|| (!lockable
&& cfg
->depthSize
> depthSize
)))
2539 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also need a format without stencil, so
2540 * allow more stencil bits than requested. */
2541 if(cfg
->stencilSize
< stencilSize
)
2547 static HRESULT WINAPI
IWineD3DImpl_CheckDepthStencilMatch(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2548 WINED3DFORMAT AdapterFormat
,
2549 WINED3DFORMAT RenderTargetFormat
,
2550 WINED3DFORMAT DepthStencilFormat
) {
2551 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2553 const WineD3D_PixelFormat
*cfgs
;
2554 const struct wined3d_adapter
*adapter
;
2555 const struct GlPixelFormatDesc
*rt_format_desc
;
2556 const struct GlPixelFormatDesc
*ds_format_desc
;
2559 WARN_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%x,%s), AdptFmt:(%x,%s), RendrTgtFmt:(%x,%s), DepthStencilFmt:(%x,%s))\n",
2561 DeviceType
, debug_d3ddevicetype(DeviceType
),
2562 AdapterFormat
, debug_d3dformat(AdapterFormat
),
2563 RenderTargetFormat
, debug_d3dformat(RenderTargetFormat
),
2564 DepthStencilFormat
, debug_d3dformat(DepthStencilFormat
));
2566 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2567 TRACE("(%p) Failed: Atapter (%u) higher than supported adapters (%u) returning WINED3DERR_INVALIDCALL\n", This
, Adapter
, IWineD3D_GetAdapterCount(iface
));
2568 return WINED3DERR_INVALIDCALL
;
2571 adapter
= &This
->adapters
[Adapter
];
2572 rt_format_desc
= getFormatDescEntry(RenderTargetFormat
, &adapter
->gl_info
);
2573 ds_format_desc
= getFormatDescEntry(DepthStencilFormat
, &adapter
->gl_info
);
2574 cfgs
= adapter
->cfgs
;
2575 nCfgs
= adapter
->nCfgs
;
2576 for (it
= 0; it
< nCfgs
; ++it
) {
2577 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
, &cfgs
[it
], rt_format_desc
))
2579 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, &cfgs
[it
], ds_format_desc
))
2581 TRACE_(d3d_caps
)("(%p) : Formats matched\n", This
);
2586 WARN_(d3d_caps
)("unsupported format pair: %s and %s\n", debug_d3dformat(RenderTargetFormat
), debug_d3dformat(DepthStencilFormat
));
2588 return WINED3DERR_NOTAVAILABLE
;
2591 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceMultiSampleType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2592 WINED3DFORMAT SurfaceFormat
, BOOL Windowed
, WINED3DMULTISAMPLE_TYPE MultiSampleType
, DWORD
*pQualityLevels
)
2594 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
2595 const struct GlPixelFormatDesc
*glDesc
;
2596 const struct wined3d_adapter
*adapter
;
2598 TRACE_(d3d_caps
)("(%p)-> (Adptr:%d, DevType:(%x,%s), SurfFmt:(%x,%s), Win?%d, MultiSamp:%x, pQual:%p)\n",
2601 DeviceType
, debug_d3ddevicetype(DeviceType
),
2602 SurfaceFormat
, debug_d3dformat(SurfaceFormat
),
2607 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2608 return WINED3DERR_INVALIDCALL
;
2611 /* TODO: handle Windowed, add more quality levels */
2613 if (WINED3DMULTISAMPLE_NONE
== MultiSampleType
) {
2614 if(pQualityLevels
) *pQualityLevels
= 1;
2618 /* By default multisampling is disabled right now as it causes issues
2619 * on some Nvidia driver versions and it doesn't work well in combination
2621 if(!wined3d_settings
.allow_multisampling
)
2622 return WINED3DERR_NOTAVAILABLE
;
2624 adapter
= &This
->adapters
[Adapter
];
2625 glDesc
= getFormatDescEntry(SurfaceFormat
, &adapter
->gl_info
);
2626 if (!glDesc
) return WINED3DERR_INVALIDCALL
;
2628 if(glDesc
->Flags
& (WINED3DFMT_FLAG_DEPTH
| WINED3DFMT_FLAG_STENCIL
)) {
2630 const WineD3D_PixelFormat
*cfgs
;
2632 cfgs
= adapter
->cfgs
;
2633 nCfgs
= adapter
->nCfgs
;
2634 for(i
=0; i
<nCfgs
; i
++) {
2635 if(cfgs
[i
].numSamples
!= MultiSampleType
)
2638 if (!IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, &cfgs
[i
], glDesc
))
2641 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs
[i
].iPixelFormat
, MultiSampleType
, debug_d3dformat(SurfaceFormat
));
2644 *pQualityLevels
= 1; /* Guess at a value! */
2648 else if(glDesc
->Flags
& WINED3DFMT_FLAG_RENDERTARGET
) {
2649 short redSize
, greenSize
, blueSize
, alphaSize
, colorBits
;
2651 const WineD3D_PixelFormat
*cfgs
;
2653 if (!getColorBits(glDesc
, &redSize
, &greenSize
, &blueSize
, &alphaSize
, &colorBits
))
2655 ERR("Unable to color bits for format %#x, can't check multisampling capability!\n", SurfaceFormat
);
2656 return WINED3DERR_NOTAVAILABLE
;
2659 cfgs
= adapter
->cfgs
;
2660 nCfgs
= adapter
->nCfgs
;
2661 for(i
=0; i
<nCfgs
; i
++) {
2662 if(cfgs
[i
].numSamples
!= MultiSampleType
)
2664 if(cfgs
[i
].redSize
!= redSize
)
2666 if(cfgs
[i
].greenSize
!= greenSize
)
2668 if(cfgs
[i
].blueSize
!= blueSize
)
2670 if(cfgs
[i
].alphaSize
!= alphaSize
)
2673 TRACE("Found iPixelFormat=%d to support MultiSampleType=%d for format %s\n", cfgs
[i
].iPixelFormat
, MultiSampleType
, debug_d3dformat(SurfaceFormat
));
2676 *pQualityLevels
= 1; /* Guess at a value! */
2680 return WINED3DERR_NOTAVAILABLE
;
2683 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceType(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
2684 WINED3DFORMAT DisplayFormat
, WINED3DFORMAT BackBufferFormat
, BOOL Windowed
)
2686 HRESULT hr
= WINED3DERR_NOTAVAILABLE
;
2689 TRACE("iface %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n",
2690 iface
, Adapter
, debug_d3ddevicetype(DeviceType
), debug_d3dformat(DisplayFormat
),
2691 debug_d3dformat(BackBufferFormat
), Windowed
);
2693 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
2694 WARN_(d3d_caps
)("Adapter >= IWineD3D_GetAdapterCount(iface), returning WINED3DERR_INVALIDCALL\n");
2695 return WINED3DERR_INVALIDCALL
;
2698 /* The task of this function is to check whether a certain display / backbuffer format
2699 * combination is available on the given adapter. In fullscreen mode microsoft specified
2700 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer
2701 * and display format should match exactly.
2702 * In windowed mode format conversion can occur and this depends on the driver. When format
2703 * conversion is done, this function should nevertheless fail and applications need to use
2704 * CheckDeviceFormatConversion.
2705 * At the moment we assume that fullscreen and windowed have the same capabilities */
2707 /* There are only 4 display formats */
2708 if (!(DisplayFormat
== WINED3DFMT_B5G6R5_UNORM
2709 || DisplayFormat
== WINED3DFMT_B5G5R5X1_UNORM
2710 || DisplayFormat
== WINED3DFMT_B8G8R8X8_UNORM
2711 || DisplayFormat
== WINED3DFMT_B10G10R10A2_UNORM
))
2713 TRACE_(d3d_caps
)("Format %s unsupported as display format\n", debug_d3dformat(DisplayFormat
));
2714 return WINED3DERR_NOTAVAILABLE
;
2717 /* If the requested DisplayFormat is not available, don't continue */
2718 nmodes
= IWineD3DImpl_GetAdapterModeCount(iface
, Adapter
, DisplayFormat
);
2720 TRACE_(d3d_caps
)("No available modes for display format %s\n", debug_d3dformat(DisplayFormat
));
2721 return WINED3DERR_NOTAVAILABLE
;
2724 /* Windowed mode allows you to specify WINED3DFMT_UNKNOWN for the backbufferformat, it means 'reuse' the display format for the backbuffer */
2725 if(!Windowed
&& BackBufferFormat
== WINED3DFMT_UNKNOWN
) {
2726 TRACE_(d3d_caps
)("BackBufferFormat WINED3FMT_UNKNOWN not available in Windowed mode\n");
2727 return WINED3DERR_NOTAVAILABLE
;
2730 /* In FULLSCREEN mode R5G6B5 can only be mixed with backbuffer format R5G6B5 */
2731 if (DisplayFormat
== WINED3DFMT_B5G6R5_UNORM
&& BackBufferFormat
!= WINED3DFMT_B5G6R5_UNORM
)
2733 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2734 return WINED3DERR_NOTAVAILABLE
;
2737 /* In FULLSCREEN mode X1R5G5B5 can only be mixed with backbuffer format *1R5G5B5 */
2738 if (DisplayFormat
== WINED3DFMT_B5G5R5X1_UNORM
2739 && !(BackBufferFormat
== WINED3DFMT_B5G5R5X1_UNORM
|| BackBufferFormat
== WINED3DFMT_B5G5R5A1_UNORM
))
2741 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2742 return WINED3DERR_NOTAVAILABLE
;
2745 /* In FULLSCREEN mode X8R8G8B8 can only be mixed with backbuffer format *8R8G8B8 */
2746 if (DisplayFormat
== WINED3DFMT_B8G8R8X8_UNORM
2747 && !(BackBufferFormat
== WINED3DFMT_B8G8R8X8_UNORM
|| BackBufferFormat
== WINED3DFMT_B8G8R8A8_UNORM
))
2749 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2750 return WINED3DERR_NOTAVAILABLE
;
2753 /* A2R10G10B10 is only allowed in fullscreen mode and it can only be mixed with backbuffer format A2R10G10B10 */
2754 if (DisplayFormat
== WINED3DFMT_B10G10R10A2_UNORM
2755 && (BackBufferFormat
!= WINED3DFMT_B10G10R10A2_UNORM
|| Windowed
))
2757 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2758 return WINED3DERR_NOTAVAILABLE
;
2761 /* Use CheckDeviceFormat to see if the BackBufferFormat is usable with the given DisplayFormat */
2762 hr
= IWineD3DImpl_CheckDeviceFormat(iface
, Adapter
, DeviceType
, DisplayFormat
, WINED3DUSAGE_RENDERTARGET
, WINED3DRTYPE_SURFACE
, BackBufferFormat
, SURFACE_OPENGL
);
2764 TRACE_(d3d_caps
)("Unsupported display/backbuffer format combination %s/%s\n", debug_d3dformat(DisplayFormat
), debug_d3dformat(BackBufferFormat
));
2770 /* Check if we support bumpmapping for a format */
2771 static BOOL
CheckBumpMapCapability(struct wined3d_adapter
*adapter
,
2772 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2774 const struct fragment_pipeline
*fp
;
2776 switch(format_desc
->format
)
2778 case WINED3DFMT_R8G8_SNORM
:
2779 case WINED3DFMT_R16G16_SNORM
:
2780 case WINED3DFMT_R5G5_SNORM_L6_UNORM
:
2781 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM
:
2782 case WINED3DFMT_R8G8B8A8_SNORM
:
2783 /* Ask the fixed function pipeline implementation if it can deal
2784 * with the conversion. If we've got a GL extension giving native
2785 * support this will be an identity conversion. */
2786 fp
= select_fragment_implementation(adapter
, DeviceType
);
2787 if (fp
->color_fixup_supported(format_desc
->color_fixup
))
2789 TRACE_(d3d_caps
)("[OK]\n");
2792 TRACE_(d3d_caps
)("[FAILED]\n");
2796 TRACE_(d3d_caps
)("[FAILED]\n");
2801 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */
2802 static BOOL
CheckDepthStencilCapability(struct wined3d_adapter
*adapter
,
2803 const struct GlPixelFormatDesc
*display_format_desc
, const struct GlPixelFormatDesc
*ds_format_desc
)
2807 /* Only allow depth/stencil formats */
2808 if (!(ds_format_desc
->depth_size
|| ds_format_desc
->stencil_size
)) return FALSE
;
2810 /* Walk through all WGL pixel formats to find a match */
2811 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2813 WineD3D_PixelFormat
*cfg
= &adapter
->cfgs
[it
];
2814 if (IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
, cfg
, display_format_desc
))
2816 if (IWineD3DImpl_IsPixelFormatCompatibleWithDepthFmt(&adapter
->gl_info
, cfg
, ds_format_desc
))
2826 static BOOL
CheckFilterCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2828 /* The flags entry of a format contains the filtering capability */
2829 if (format_desc
->Flags
& WINED3DFMT_FLAG_FILTERING
) return TRUE
;
2834 /* Check the render target capabilities of a format */
2835 static BOOL
CheckRenderTargetCapability(struct wined3d_adapter
*adapter
,
2836 const struct GlPixelFormatDesc
*adapter_format_desc
, const struct GlPixelFormatDesc
*check_format_desc
)
2838 /* Filter out non-RT formats */
2839 if (!(check_format_desc
->Flags
& WINED3DFMT_FLAG_RENDERTARGET
)) return FALSE
;
2841 if(wined3d_settings
.offscreen_rendering_mode
== ORM_BACKBUFFER
) {
2842 WineD3D_PixelFormat
*cfgs
= adapter
->cfgs
;
2844 short AdapterRed
, AdapterGreen
, AdapterBlue
, AdapterAlpha
, AdapterTotalSize
;
2845 short CheckRed
, CheckGreen
, CheckBlue
, CheckAlpha
, CheckTotalSize
;
2847 getColorBits(adapter_format_desc
, &AdapterRed
, &AdapterGreen
, &AdapterBlue
, &AdapterAlpha
, &AdapterTotalSize
);
2848 getColorBits(check_format_desc
, &CheckRed
, &CheckGreen
, &CheckBlue
, &CheckAlpha
, &CheckTotalSize
);
2850 /* In backbuffer mode the front and backbuffer share the same WGL pixelformat.
2851 * The format must match in RGB, alpha is allowed to be different. (Only the backbuffer can have alpha) */
2852 if(!((AdapterRed
== CheckRed
) && (AdapterGreen
== CheckGreen
) && (AdapterBlue
== CheckBlue
))) {
2853 TRACE_(d3d_caps
)("[FAILED]\n");
2857 /* Check if there is a WGL pixel format matching the requirements, the format should also be window
2858 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
2859 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2861 if (cfgs
[it
].windowDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
,
2862 &cfgs
[it
], check_format_desc
))
2864 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
2865 cfgs
[it
].iPixelFormat
, debug_d3dformat(check_format_desc
->format
));
2869 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_PBUFFER
) {
2870 /* We can probably use this function in FBO mode too on some drivers to get some basic indication of the capabilities. */
2871 WineD3D_PixelFormat
*cfgs
= adapter
->cfgs
;
2874 /* Check if there is a WGL pixel format matching the requirements, the pixel format should also be usable with pbuffers */
2875 for (it
= 0; it
< adapter
->nCfgs
; ++it
)
2877 if (cfgs
[it
].pbufferDrawable
&& IWineD3DImpl_IsPixelFormatCompatibleWithRenderFmt(&adapter
->gl_info
,
2878 &cfgs
[it
], check_format_desc
))
2880 TRACE_(d3d_caps
)("iPixelFormat=%d is compatible with CheckFormat=%s\n",
2881 cfgs
[it
].iPixelFormat
, debug_d3dformat(check_format_desc
->format
));
2885 } else if(wined3d_settings
.offscreen_rendering_mode
== ORM_FBO
){
2886 /* For now return TRUE for FBOs until we have some proper checks.
2887 * Note that this function will only be called when the format is around for texturing. */
2893 static BOOL
CheckSrgbReadCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2895 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
2897 /* Check for supported sRGB formats (Texture loading and framebuffer) */
2898 if (!gl_info
->supported
[EXT_TEXTURE_SRGB
])
2900 TRACE_(d3d_caps
)("[FAILED] GL_EXT_texture_sRGB not supported\n");
2904 switch (format_desc
->format
)
2906 case WINED3DFMT_B8G8R8A8_UNORM
:
2907 case WINED3DFMT_B8G8R8X8_UNORM
:
2908 case WINED3DFMT_B4G4R4A4_UNORM
:
2909 case WINED3DFMT_L8_UNORM
:
2910 case WINED3DFMT_L8A8_UNORM
:
2911 case WINED3DFMT_DXT1
:
2912 case WINED3DFMT_DXT2
:
2913 case WINED3DFMT_DXT3
:
2914 case WINED3DFMT_DXT4
:
2915 case WINED3DFMT_DXT5
:
2916 TRACE_(d3d_caps
)("[OK]\n");
2920 TRACE_(d3d_caps
)("[FAILED] Gamma texture format %s not supported.\n", debug_d3dformat(format_desc
->format
));
2926 static BOOL
CheckSrgbWriteCapability(struct wined3d_adapter
*adapter
,
2927 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2929 /* Only offer SRGB writing on X8R8G8B8/A8R8G8B8 when we use ARB or GLSL shaders as we are
2930 * doing the color fixup in shaders.
2931 * Note Windows drivers (at least on the Geforce 8800) also offer this on R5G6B5. */
2932 if ((format_desc
->format
== WINED3DFMT_B8G8R8X8_UNORM
) || (format_desc
->format
== WINED3DFMT_B8G8R8A8_UNORM
))
2934 int vs_selected_mode
;
2935 int ps_selected_mode
;
2936 select_shader_mode(&adapter
->gl_info
, &ps_selected_mode
, &vs_selected_mode
);
2938 if((ps_selected_mode
== SHADER_ARB
) || (ps_selected_mode
== SHADER_GLSL
)) {
2939 TRACE_(d3d_caps
)("[OK]\n");
2944 TRACE_(d3d_caps
)("[FAILED] - no SRGB writing support on format=%s\n", debug_d3dformat(format_desc
->format
));
2948 /* Check if a format support blending in combination with pixel shaders */
2949 static BOOL
CheckPostPixelShaderBlendingCapability(struct wined3d_adapter
*adapter
,
2950 const struct GlPixelFormatDesc
*format_desc
)
2952 /* The flags entry of a format contains the post pixel shader blending capability */
2953 if (format_desc
->Flags
& WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING
) return TRUE
;
2958 static BOOL
CheckWrapAndMipCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
2960 /* OpenGL supports mipmapping on all formats basically. Wrapping is unsupported,
2961 * but we have to report mipmapping so we cannot reject this flag. Tests show that
2962 * windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to show
2963 * that wrapping is supported. The lack of filtering will sort out the mipmapping
2964 * capability anyway.
2966 * For now lets report this on all formats, but in the future we may want to
2967 * restrict it to some should games need that
2972 /* Check if a texture format is supported on the given adapter */
2973 static BOOL
CheckTextureCapability(struct wined3d_adapter
*adapter
,
2974 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*format_desc
)
2976 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
2977 const shader_backend_t
*shader_backend
;
2978 const struct fragment_pipeline
*fp
;
2980 switch (format_desc
->format
)
2983 * supported: RGB(A) formats
2985 case WINED3DFMT_B8G8R8_UNORM
: /* Enable for dx7, blacklisted for 8 and 9 above */
2986 case WINED3DFMT_B8G8R8A8_UNORM
:
2987 case WINED3DFMT_B8G8R8X8_UNORM
:
2988 case WINED3DFMT_B5G6R5_UNORM
:
2989 case WINED3DFMT_B5G5R5X1_UNORM
:
2990 case WINED3DFMT_B5G5R5A1_UNORM
:
2991 case WINED3DFMT_B4G4R4A4_UNORM
:
2992 case WINED3DFMT_A8_UNORM
:
2993 case WINED3DFMT_B4G4R4X4_UNORM
:
2994 case WINED3DFMT_R8G8B8A8_UNORM
:
2995 case WINED3DFMT_R8G8B8X8_UNORM
:
2996 case WINED3DFMT_B10G10R10A2_UNORM
:
2997 case WINED3DFMT_R10G10B10A2_UNORM
:
2998 case WINED3DFMT_R16G16_UNORM
:
2999 TRACE_(d3d_caps
)("[OK]\n");
3002 case WINED3DFMT_B2G3R3_UNORM
:
3003 TRACE_(d3d_caps
)("[FAILED] - Not supported on Windows\n");
3007 * supported: Palettized
3009 case WINED3DFMT_P8_UINT
:
3010 TRACE_(d3d_caps
)("[OK]\n");
3012 /* No Windows driver offers WINED3DFMT_P8_UINT_A8_UNORM, so don't offer it either */
3013 case WINED3DFMT_P8_UINT_A8_UNORM
:
3017 * Supported: (Alpha)-Luminance
3019 case WINED3DFMT_L8_UNORM
:
3020 case WINED3DFMT_L8A8_UNORM
:
3021 case WINED3DFMT_L16_UNORM
:
3022 TRACE_(d3d_caps
)("[OK]\n");
3025 /* Not supported on Windows, thus disabled */
3026 case WINED3DFMT_L4A4_UNORM
:
3027 TRACE_(d3d_caps
)("[FAILED] - not supported on windows\n");
3031 * Supported: Depth/Stencil formats
3033 case WINED3DFMT_D16_LOCKABLE
:
3034 case WINED3DFMT_D16_UNORM
:
3035 case WINED3DFMT_S1_UINT_D15_UNORM
:
3036 case WINED3DFMT_X8D24_UNORM
:
3037 case WINED3DFMT_S4X4_UINT_D24_UNORM
:
3038 case WINED3DFMT_D24_UNORM_S8_UINT
:
3039 case WINED3DFMT_S8_UINT_D24_FLOAT
:
3040 case WINED3DFMT_D32_UNORM
:
3041 case WINED3DFMT_D32_FLOAT
:
3045 * Not supported everywhere(depends on GL_ATI_envmap_bumpmap or
3046 * GL_NV_texture_shader). Emulated by shaders
3048 case WINED3DFMT_R8G8_SNORM
:
3049 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM
:
3050 case WINED3DFMT_R5G5_SNORM_L6_UNORM
:
3051 case WINED3DFMT_R8G8B8A8_SNORM
:
3052 case WINED3DFMT_R16G16_SNORM
:
3053 /* Ask the shader backend if it can deal with the conversion. If
3054 * we've got a GL extension giving native support this will be an
3055 * identity conversion. */
3056 shader_backend
= select_shader_backend(adapter
, DeviceType
);
3057 if (shader_backend
->shader_color_fixup_supported(format_desc
->color_fixup
))
3059 TRACE_(d3d_caps
)("[OK]\n");
3062 TRACE_(d3d_caps
)("[FAILED]\n");
3065 case WINED3DFMT_DXT1
:
3066 case WINED3DFMT_DXT2
:
3067 case WINED3DFMT_DXT3
:
3068 case WINED3DFMT_DXT4
:
3069 case WINED3DFMT_DXT5
:
3070 if (gl_info
->supported
[EXT_TEXTURE_COMPRESSION_S3TC
])
3072 TRACE_(d3d_caps
)("[OK]\n");
3075 TRACE_(d3d_caps
)("[FAILED]\n");
3080 * Odd formats - not supported
3082 case WINED3DFMT_VERTEXDATA
:
3083 case WINED3DFMT_R16_UINT
:
3084 case WINED3DFMT_R32_UINT
:
3085 case WINED3DFMT_R16G16B16A16_SNORM
:
3086 case WINED3DFMT_R10G10B10_SNORM_A2_UNORM
:
3087 case WINED3DFMT_R10G11B11_SNORM
:
3088 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
3092 * WINED3DFMT_R8G8_SNORM_Cx: Not supported right now
3094 case WINED3DFMT_R8G8_SNORM_Cx
:
3095 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
3099 case WINED3DFMT_UYVY
:
3100 case WINED3DFMT_YUY2
:
3101 if (gl_info
->supported
[APPLE_YCBCR_422
])
3103 TRACE_(d3d_caps
)("[OK]\n");
3106 TRACE_(d3d_caps
)("[FAILED]\n");
3108 case WINED3DFMT_YV12
:
3109 TRACE_(d3d_caps
)("[FAILED]\n");
3113 case WINED3DFMT_R16G16B16A16_UNORM
:
3114 case WINED3DFMT_B2G3R3A8_UNORM
:
3115 TRACE_(d3d_caps
)("[FAILED]\n"); /* Enable when implemented */
3118 /* Floating point formats */
3119 case WINED3DFMT_R16_FLOAT
:
3120 case WINED3DFMT_R16G16_FLOAT
:
3121 case WINED3DFMT_R16G16B16A16_FLOAT
:
3122 if (gl_info
->supported
[ARB_TEXTURE_FLOAT
] && gl_info
->supported
[ARB_HALF_FLOAT_PIXEL
])
3124 TRACE_(d3d_caps
)("[OK]\n");
3127 TRACE_(d3d_caps
)("[FAILED]\n");
3130 case WINED3DFMT_R32_FLOAT
:
3131 case WINED3DFMT_R32G32_FLOAT
:
3132 case WINED3DFMT_R32G32B32A32_FLOAT
:
3133 if (gl_info
->supported
[ARB_TEXTURE_FLOAT
])
3135 TRACE_(d3d_caps
)("[OK]\n");
3138 TRACE_(d3d_caps
)("[FAILED]\n");
3141 /* ATI instancing hack: Although ATI cards do not support Shader Model 3.0, they support
3142 * instancing. To query if the card supports instancing CheckDeviceFormat with the special format
3143 * MAKEFOURCC('I','N','S','T') is used. Should a (broken) app check for this provide a proper return value.
3144 * We can do instancing with all shader versions, but we need vertex shaders.
3146 * Additionally applications have to set the D3DRS_POINTSIZE render state to MAKEFOURCC('I','N','S','T') once
3147 * to enable instancing. WineD3D doesn't need that and just ignores it.
3149 * With Shader Model 3.0 capable cards Instancing 'just works' in Windows.
3151 case WINED3DFMT_INST
:
3152 TRACE("ATI Instancing check hack\n");
3153 if (gl_info
->supported
[ARB_VERTEX_PROGRAM
] || gl_info
->supported
[ARB_VERTEX_SHADER
])
3155 TRACE_(d3d_caps
)("[OK]\n");
3158 TRACE_(d3d_caps
)("[FAILED]\n");
3161 /* Some weird FOURCC formats */
3162 case WINED3DFMT_R8G8_B8G8
:
3163 case WINED3DFMT_G8R8_G8B8
:
3164 case WINED3DFMT_MULTI2_ARGB8
:
3165 TRACE_(d3d_caps
)("[FAILED]\n");
3168 /* Vendor specific formats */
3169 case WINED3DFMT_ATI2N
:
3170 if (gl_info
->supported
[ATI_TEXTURE_COMPRESSION_3DC
]
3171 || gl_info
->supported
[EXT_TEXTURE_COMPRESSION_RGTC
])
3173 shader_backend
= select_shader_backend(adapter
, DeviceType
);
3174 fp
= select_fragment_implementation(adapter
, DeviceType
);
3175 if (shader_backend
->shader_color_fixup_supported(format_desc
->color_fixup
)
3176 && fp
->color_fixup_supported(format_desc
->color_fixup
))
3178 TRACE_(d3d_caps
)("[OK]\n");
3182 TRACE_(d3d_caps
)("[OK]\n");
3185 TRACE_(d3d_caps
)("[FAILED]\n");
3188 case WINED3DFMT_NVHU
:
3189 case WINED3DFMT_NVHS
:
3190 /* These formats seem to be similar to the HILO formats in GL_NV_texture_shader. NVHU
3191 * is said to be GL_UNSIGNED_HILO16, NVHS GL_SIGNED_HILO16. Rumours say that d3d computes
3192 * a 3rd channel similarly to D3DFMT_CxV8U8(So NVHS could be called D3DFMT_CxV16U16).
3193 * ATI refused to support formats which can easilly be emulated with pixel shaders, so
3194 * Applications have to deal with not having NVHS and NVHU.
3196 TRACE_(d3d_caps
)("[FAILED]\n");
3199 case WINED3DFMT_UNKNOWN
:
3203 ERR("Unhandled format=%s\n", debug_d3dformat(format_desc
->format
));
3209 static BOOL
CheckSurfaceCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*adapter_format_desc
,
3210 WINED3DDEVTYPE DeviceType
, const struct GlPixelFormatDesc
*check_format_desc
, WINED3DSURFTYPE SurfaceType
)
3212 const struct blit_shader
*blitter
;
3214 if(SurfaceType
== SURFACE_GDI
) {
3215 switch(check_format_desc
->format
)
3217 case WINED3DFMT_B8G8R8_UNORM
:
3218 case WINED3DFMT_B8G8R8A8_UNORM
:
3219 case WINED3DFMT_B8G8R8X8_UNORM
:
3220 case WINED3DFMT_B5G6R5_UNORM
:
3221 case WINED3DFMT_B5G5R5X1_UNORM
:
3222 case WINED3DFMT_B5G5R5A1_UNORM
:
3223 case WINED3DFMT_B4G4R4A4_UNORM
:
3224 case WINED3DFMT_B2G3R3_UNORM
:
3225 case WINED3DFMT_A8_UNORM
:
3226 case WINED3DFMT_B2G3R3A8_UNORM
:
3227 case WINED3DFMT_B4G4R4X4_UNORM
:
3228 case WINED3DFMT_R10G10B10A2_UNORM
:
3229 case WINED3DFMT_R8G8B8A8_UNORM
:
3230 case WINED3DFMT_R8G8B8X8_UNORM
:
3231 case WINED3DFMT_R16G16_UNORM
:
3232 case WINED3DFMT_B10G10R10A2_UNORM
:
3233 case WINED3DFMT_R16G16B16A16_UNORM
:
3234 case WINED3DFMT_P8_UINT
:
3235 TRACE_(d3d_caps
)("[OK]\n");
3238 TRACE_(d3d_caps
)("[FAILED] - not available on GDI surfaces\n");
3243 /* All format that are supported for textures are supported for surfaces as well */
3244 if (CheckTextureCapability(adapter
, DeviceType
, check_format_desc
)) return TRUE
;
3245 /* All depth stencil formats are supported on surfaces */
3246 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, check_format_desc
)) return TRUE
;
3248 /* If opengl can't process the format natively, the blitter may be able to convert it */
3249 blitter
= select_blit_implementation(adapter
, DeviceType
);
3250 if (blitter
->color_fixup_supported(check_format_desc
->color_fixup
))
3252 TRACE_(d3d_caps
)("[OK]\n");
3256 /* Reject other formats */
3257 TRACE_(d3d_caps
)("[FAILED]\n");
3261 static BOOL
CheckVertexTextureCapability(struct wined3d_adapter
*adapter
, const struct GlPixelFormatDesc
*format_desc
)
3263 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
3265 if (!gl_info
->limits
.vertex_samplers
)
3267 TRACE_(d3d_caps
)("[FAILED]\n");
3271 switch (format_desc
->format
)
3273 case WINED3DFMT_R32G32B32A32_FLOAT
:
3274 if (!gl_info
->supported
[ARB_TEXTURE_FLOAT
])
3276 TRACE_(d3d_caps
)("[FAILED]\n");
3279 TRACE_(d3d_caps
)("[OK]\n");
3283 TRACE_(d3d_caps
)("[FAILED]\n");
3289 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormat(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
,
3290 WINED3DFORMAT AdapterFormat
, DWORD Usage
, WINED3DRESOURCETYPE RType
, WINED3DFORMAT CheckFormat
,
3291 WINED3DSURFTYPE SurfaceType
)
3293 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3294 struct wined3d_adapter
*adapter
= &This
->adapters
[Adapter
];
3295 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
3296 const struct GlPixelFormatDesc
*format_desc
= getFormatDescEntry(CheckFormat
, gl_info
);
3297 const struct GlPixelFormatDesc
*adapter_format_desc
= getFormatDescEntry(AdapterFormat
, gl_info
);
3298 DWORD UsageCaps
= 0;
3300 TRACE_(d3d_caps
)("(%p)-> (STUB) (Adptr:%d, DevType:(%u,%s), AdptFmt:(%u,%s), Use:(%u,%s,%s), ResTyp:(%x,%s), CheckFmt:(%u,%s))\n",
3303 DeviceType
, debug_d3ddevicetype(DeviceType
),
3304 AdapterFormat
, debug_d3dformat(AdapterFormat
),
3305 Usage
, debug_d3dusage(Usage
), debug_d3dusagequery(Usage
),
3306 RType
, debug_d3dresourcetype(RType
),
3307 CheckFormat
, debug_d3dformat(CheckFormat
));
3309 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
3310 return WINED3DERR_INVALIDCALL
;
3313 if(RType
== WINED3DRTYPE_CUBETEXTURE
) {
3315 if(SurfaceType
!= SURFACE_OPENGL
) {
3316 TRACE("[FAILED]\n");
3317 return WINED3DERR_NOTAVAILABLE
;
3320 /* Cubetexture allows:
3321 * - D3DUSAGE_AUTOGENMIPMAP
3322 * - D3DUSAGE_DEPTHSTENCIL
3323 * - D3DUSAGE_DYNAMIC
3324 * - D3DUSAGE_NONSECURE (d3d9ex)
3325 * - D3DUSAGE_RENDERTARGET
3326 * - D3DUSAGE_SOFTWAREPROCESSING
3327 * - D3DUSAGE_QUERY_WRAPANDMIP
3329 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
3331 /* Check if the texture format is around */
3332 if (CheckTextureCapability(adapter
, DeviceType
, format_desc
))
3334 if(Usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
3335 /* Check for automatic mipmap generation support */
3336 if (gl_info
->supported
[SGIS_GENERATE_MIPMAP
])
3338 UsageCaps
|= WINED3DUSAGE_AUTOGENMIPMAP
;
3340 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
3341 TRACE_(d3d_caps
)("[FAILED] - No autogenmipmap support, but continuing\n");
3345 /* Always report dynamic locking */
3346 if(Usage
& WINED3DUSAGE_DYNAMIC
)
3347 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
3349 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
3350 if(CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
3352 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
3354 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
3355 return WINED3DERR_NOTAVAILABLE
;
3359 /* Always report software processing */
3360 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
3361 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
3363 /* Check QUERY_FILTER support */
3364 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
3365 if (CheckFilterCapability(adapter
, format_desc
))
3367 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
3369 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
3370 return WINED3DERR_NOTAVAILABLE
;
3374 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3375 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3376 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3378 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3380 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3381 return WINED3DERR_NOTAVAILABLE
;
3385 /* Check QUERY_SRGBREAD support */
3386 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
3387 if (CheckSrgbReadCapability(adapter
, format_desc
))
3389 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
3391 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
3392 return WINED3DERR_NOTAVAILABLE
;
3396 /* Check QUERY_SRGBWRITE support */
3397 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
3398 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
3400 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
3402 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
3403 return WINED3DERR_NOTAVAILABLE
;
3407 /* Check QUERY_VERTEXTEXTURE support */
3408 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
3409 if (CheckVertexTextureCapability(adapter
, format_desc
))
3411 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
3413 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
3414 return WINED3DERR_NOTAVAILABLE
;
3418 /* Check QUERY_WRAPANDMIP support */
3419 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
3420 if (CheckWrapAndMipCapability(adapter
, format_desc
))
3422 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
3424 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
3425 return WINED3DERR_NOTAVAILABLE
;
3429 TRACE_(d3d_caps
)("[FAILED] - Cube texture format not supported\n");
3430 return WINED3DERR_NOTAVAILABLE
;
3433 TRACE_(d3d_caps
)("[FAILED] - No cube texture support\n");
3434 return WINED3DERR_NOTAVAILABLE
;
3436 } else if(RType
== WINED3DRTYPE_SURFACE
) {
3438 * - D3DUSAGE_DEPTHSTENCIL
3439 * - D3DUSAGE_NONSECURE (d3d9ex)
3440 * - D3DUSAGE_RENDERTARGET
3443 if (CheckSurfaceCapability(adapter
, adapter_format_desc
, DeviceType
, format_desc
, SurfaceType
))
3445 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
3446 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, format_desc
))
3448 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
3450 TRACE_(d3d_caps
)("[FAILED] - No depthstencil support\n");
3451 return WINED3DERR_NOTAVAILABLE
;
3455 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
3456 if (CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
3458 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
3460 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
3461 return WINED3DERR_NOTAVAILABLE
;
3465 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3466 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3467 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3469 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3471 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3472 return WINED3DERR_NOTAVAILABLE
;
3476 TRACE_(d3d_caps
)("[FAILED] - Not supported for plain surfaces\n");
3477 return WINED3DERR_NOTAVAILABLE
;
3480 } else if(RType
== WINED3DRTYPE_TEXTURE
) {
3482 * - D3DUSAGE_AUTOGENMIPMAP
3483 * - D3DUSAGE_DEPTHSTENCIL
3485 * - D3DUSAGE_DYNAMIC
3486 * - D3DUSAGE_NONSECURE (d3d9ex)
3487 * - D3DUSAGE_RENDERTARGET
3488 * - D3DUSAGE_SOFTWAREPROCESSING
3489 * - D3DUSAGE_TEXTAPI (d3d9ex)
3490 * - D3DUSAGE_QUERY_WRAPANDMIP
3493 if(SurfaceType
!= SURFACE_OPENGL
) {
3494 TRACE("[FAILED]\n");
3495 return WINED3DERR_NOTAVAILABLE
;
3498 /* Check if the texture format is around */
3499 if (CheckTextureCapability(adapter
, DeviceType
, format_desc
))
3501 if(Usage
& WINED3DUSAGE_AUTOGENMIPMAP
) {
3502 /* Check for automatic mipmap generation support */
3503 if (gl_info
->supported
[SGIS_GENERATE_MIPMAP
])
3505 UsageCaps
|= WINED3DUSAGE_AUTOGENMIPMAP
;
3507 /* When autogenmipmap isn't around continue and return WINED3DOK_NOAUTOGEN instead of D3D_OK */
3508 TRACE_(d3d_caps
)("[FAILED] - No autogenmipmap support, but continuing\n");
3512 /* Always report dynamic locking */
3513 if(Usage
& WINED3DUSAGE_DYNAMIC
)
3514 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
3516 if(Usage
& WINED3DUSAGE_RENDERTARGET
) {
3517 if (CheckRenderTargetCapability(adapter
, adapter_format_desc
, format_desc
))
3519 UsageCaps
|= WINED3DUSAGE_RENDERTARGET
;
3521 TRACE_(d3d_caps
)("[FAILED] - No rendertarget support\n");
3522 return WINED3DERR_NOTAVAILABLE
;
3526 /* Always report software processing */
3527 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
3528 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
3530 /* Check QUERY_FILTER support */
3531 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
3532 if (CheckFilterCapability(adapter
, format_desc
))
3534 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
3536 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
3537 return WINED3DERR_NOTAVAILABLE
;
3541 /* Check QUERY_LEGACYBUMPMAP support */
3542 if(Usage
& WINED3DUSAGE_QUERY_LEGACYBUMPMAP
) {
3543 if (CheckBumpMapCapability(adapter
, DeviceType
, format_desc
))
3545 UsageCaps
|= WINED3DUSAGE_QUERY_LEGACYBUMPMAP
;
3547 TRACE_(d3d_caps
)("[FAILED] - No legacy bumpmap support\n");
3548 return WINED3DERR_NOTAVAILABLE
;
3552 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3553 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3554 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3556 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3558 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3559 return WINED3DERR_NOTAVAILABLE
;
3563 /* Check QUERY_SRGBREAD support */
3564 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
3565 if (CheckSrgbReadCapability(adapter
, format_desc
))
3567 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
3569 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
3570 return WINED3DERR_NOTAVAILABLE
;
3574 /* Check QUERY_SRGBWRITE support */
3575 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
3576 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
3578 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
3580 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
3581 return WINED3DERR_NOTAVAILABLE
;
3585 /* Check QUERY_VERTEXTEXTURE support */
3586 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
3587 if (CheckVertexTextureCapability(adapter
, format_desc
))
3589 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
3591 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
3592 return WINED3DERR_NOTAVAILABLE
;
3596 /* Check QUERY_WRAPANDMIP support */
3597 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
3598 if (CheckWrapAndMipCapability(adapter
, format_desc
))
3600 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
3602 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
3603 return WINED3DERR_NOTAVAILABLE
;
3607 if(Usage
& WINED3DUSAGE_DEPTHSTENCIL
) {
3608 if (CheckDepthStencilCapability(adapter
, adapter_format_desc
, format_desc
))
3610 UsageCaps
|= WINED3DUSAGE_DEPTHSTENCIL
;
3612 TRACE_(d3d_caps
)("[FAILED] - No depth stencil support\n");
3613 return WINED3DERR_NOTAVAILABLE
;
3617 TRACE_(d3d_caps
)("[FAILED] - Texture format not supported\n");
3618 return WINED3DERR_NOTAVAILABLE
;
3620 } else if((RType
== WINED3DRTYPE_VOLUME
) || (RType
== WINED3DRTYPE_VOLUMETEXTURE
)) {
3621 /* Volume is to VolumeTexture what Surface is to Texture but its usage caps are not documented.
3622 * Most driver seem to offer (nearly) the same on Volume and VolumeTexture, so do that too.
3624 * Volumetexture allows:
3625 * - D3DUSAGE_DYNAMIC
3626 * - D3DUSAGE_NONSECURE (d3d9ex)
3627 * - D3DUSAGE_SOFTWAREPROCESSING
3628 * - D3DUSAGE_QUERY_WRAPANDMIP
3631 if(SurfaceType
!= SURFACE_OPENGL
) {
3632 TRACE("[FAILED]\n");
3633 return WINED3DERR_NOTAVAILABLE
;
3636 /* Check volume texture and volume usage caps */
3637 if (gl_info
->supported
[EXT_TEXTURE3D
])
3639 if (!CheckTextureCapability(adapter
, DeviceType
, format_desc
))
3641 TRACE_(d3d_caps
)("[FAILED] - Format not supported\n");
3642 return WINED3DERR_NOTAVAILABLE
;
3645 /* Always report dynamic locking */
3646 if(Usage
& WINED3DUSAGE_DYNAMIC
)
3647 UsageCaps
|= WINED3DUSAGE_DYNAMIC
;
3649 /* Always report software processing */
3650 if(Usage
& WINED3DUSAGE_SOFTWAREPROCESSING
)
3651 UsageCaps
|= WINED3DUSAGE_SOFTWAREPROCESSING
;
3653 /* Check QUERY_FILTER support */
3654 if(Usage
& WINED3DUSAGE_QUERY_FILTER
) {
3655 if (CheckFilterCapability(adapter
, format_desc
))
3657 UsageCaps
|= WINED3DUSAGE_QUERY_FILTER
;
3659 TRACE_(d3d_caps
)("[FAILED] - No query filter support\n");
3660 return WINED3DERR_NOTAVAILABLE
;
3664 /* Check QUERY_POSTPIXELSHADER_BLENDING support */
3665 if(Usage
& WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
) {
3666 if (CheckPostPixelShaderBlendingCapability(adapter
, format_desc
))
3668 UsageCaps
|= WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING
;
3670 TRACE_(d3d_caps
)("[FAILED] - No query post pixelshader blending support\n");
3671 return WINED3DERR_NOTAVAILABLE
;
3675 /* Check QUERY_SRGBREAD support */
3676 if(Usage
& WINED3DUSAGE_QUERY_SRGBREAD
) {
3677 if (CheckSrgbReadCapability(adapter
, format_desc
))
3679 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBREAD
;
3681 TRACE_(d3d_caps
)("[FAILED] - No query srgbread support\n");
3682 return WINED3DERR_NOTAVAILABLE
;
3686 /* Check QUERY_SRGBWRITE support */
3687 if(Usage
& WINED3DUSAGE_QUERY_SRGBWRITE
) {
3688 if (CheckSrgbWriteCapability(adapter
, DeviceType
, format_desc
))
3690 UsageCaps
|= WINED3DUSAGE_QUERY_SRGBWRITE
;
3692 TRACE_(d3d_caps
)("[FAILED] - No query srgbwrite support\n");
3693 return WINED3DERR_NOTAVAILABLE
;
3697 /* Check QUERY_VERTEXTEXTURE support */
3698 if(Usage
& WINED3DUSAGE_QUERY_VERTEXTEXTURE
) {
3699 if (CheckVertexTextureCapability(adapter
, format_desc
))
3701 UsageCaps
|= WINED3DUSAGE_QUERY_VERTEXTEXTURE
;
3703 TRACE_(d3d_caps
)("[FAILED] - No query vertextexture support\n");
3704 return WINED3DERR_NOTAVAILABLE
;
3708 /* Check QUERY_WRAPANDMIP support */
3709 if(Usage
& WINED3DUSAGE_QUERY_WRAPANDMIP
) {
3710 if (CheckWrapAndMipCapability(adapter
, format_desc
))
3712 UsageCaps
|= WINED3DUSAGE_QUERY_WRAPANDMIP
;
3714 TRACE_(d3d_caps
)("[FAILED] - No wrapping and mipmapping support\n");
3715 return WINED3DERR_NOTAVAILABLE
;
3719 TRACE_(d3d_caps
)("[FAILED] - No volume texture support\n");
3720 return WINED3DERR_NOTAVAILABLE
;
3723 /* Filter formats that need conversion; For one part, this conversion is unimplemented,
3724 * and volume textures are huge, so it would be a big performance hit. Unless we hit an
3725 * app needing one of those formats, don't advertize them to avoid leading apps into
3726 * temptation. The windows drivers don't support most of those formats on volumes anyway,
3729 switch(CheckFormat
) {
3730 case WINED3DFMT_P8_UINT
:
3731 case WINED3DFMT_L4A4_UNORM
:
3732 case WINED3DFMT_R32_FLOAT
:
3733 case WINED3DFMT_R16_FLOAT
:
3734 case WINED3DFMT_R8G8_SNORM_L8X8_UNORM
:
3735 case WINED3DFMT_R5G5_SNORM_L6_UNORM
:
3736 case WINED3DFMT_R16G16_UNORM
:
3737 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
3738 return WINED3DERR_NOTAVAILABLE
;
3740 case WINED3DFMT_R8G8B8A8_SNORM
:
3741 case WINED3DFMT_R16G16_SNORM
:
3742 if (!gl_info
->supported
[NV_TEXTURE_SHADER
])
3744 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
3745 return WINED3DERR_NOTAVAILABLE
;
3749 case WINED3DFMT_R8G8_SNORM
:
3750 if (!gl_info
->supported
[NV_TEXTURE_SHADER
])
3752 TRACE_(d3d_caps
)("[FAILED] - No converted formats on volumes\n");
3753 return WINED3DERR_NOTAVAILABLE
;
3757 case WINED3DFMT_DXT1
:
3758 case WINED3DFMT_DXT2
:
3759 case WINED3DFMT_DXT3
:
3760 case WINED3DFMT_DXT4
:
3761 case WINED3DFMT_DXT5
:
3762 /* The GL_EXT_texture_compression_s3tc spec requires that loading an s3tc
3763 * compressed texture results in an error. While the D3D refrast does
3764 * support s3tc volumes, at least the nvidia windows driver does not, so
3765 * we're free not to support this format.
3767 TRACE_(d3d_caps
)("[FAILED] - DXTn does not support 3D textures\n");
3768 return WINED3DERR_NOTAVAILABLE
;
3771 /* Do nothing, continue with checking the format below */
3774 } else if(RType
== WINED3DRTYPE_BUFFER
){
3775 /* For instance vertexbuffer/indexbuffer aren't supported yet because no Windows drivers seem to offer it */
3776 TRACE_(d3d_caps
)("Unhandled resource type D3DRTYPE_INDEXBUFFER / D3DRTYPE_VERTEXBUFFER\n");
3777 return WINED3DERR_NOTAVAILABLE
;
3780 /* When the UsageCaps exactly matches Usage return WINED3D_OK except for the situation in which
3781 * WINED3DUSAGE_AUTOGENMIPMAP isn't around, then WINED3DOK_NOAUTOGEN is returned if all the other
3782 * usage flags match. */
3783 if(UsageCaps
== Usage
) {
3785 } else if((UsageCaps
== (Usage
& ~WINED3DUSAGE_AUTOGENMIPMAP
)) && (Usage
& WINED3DUSAGE_AUTOGENMIPMAP
)){
3786 return WINED3DOK_NOAUTOGEN
;
3788 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
);
3789 return WINED3DERR_NOTAVAILABLE
;
3793 static HRESULT WINAPI
IWineD3DImpl_CheckDeviceFormatConversion(IWineD3D
*iface
, UINT adapter_idx
,
3794 WINED3DDEVTYPE device_type
, WINED3DFORMAT src_format
, WINED3DFORMAT dst_format
)
3796 FIXME("iface %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n",
3797 iface
, adapter_idx
, debug_d3ddevicetype(device_type
), debug_d3dformat(src_format
),
3798 debug_d3dformat(dst_format
));
3803 /* Note: d3d8 passes in a pointer to a D3DCAPS8 structure, which is a true
3804 subset of a D3DCAPS9 structure. However, it has to come via a void *
3805 as the d3d8 interface cannot import the d3d9 header */
3806 static HRESULT WINAPI
IWineD3DImpl_GetDeviceCaps(IWineD3D
*iface
, UINT Adapter
, WINED3DDEVTYPE DeviceType
, WINED3DCAPS
* pCaps
) {
3808 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
3809 struct wined3d_adapter
*adapter
= &This
->adapters
[Adapter
];
3810 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
3811 int vs_selected_mode
;
3812 int ps_selected_mode
;
3813 struct shader_caps shader_caps
;
3814 struct fragment_caps fragment_caps
;
3815 const shader_backend_t
*shader_backend
;
3816 const struct fragment_pipeline
*frag_pipeline
= NULL
;
3817 DWORD ckey_caps
, blit_caps
, fx_caps
;
3819 TRACE_(d3d_caps
)("(%p)->(Adptr:%d, DevType: %x, pCaps: %p)\n", This
, Adapter
, DeviceType
, pCaps
);
3821 if (Adapter
>= IWineD3D_GetAdapterCount(iface
)) {
3822 return WINED3DERR_INVALIDCALL
;
3825 select_shader_mode(&adapter
->gl_info
, &ps_selected_mode
, &vs_selected_mode
);
3827 /* ------------------------------------------------
3828 The following fields apply to both d3d8 and d3d9
3829 ------------------------------------------------ */
3830 pCaps
->DeviceType
= (DeviceType
== WINED3DDEVTYPE_HAL
) ? WINED3DDEVTYPE_HAL
: WINED3DDEVTYPE_REF
; /* Not quite true, but use h/w supported by opengl I suppose */
3831 pCaps
->AdapterOrdinal
= Adapter
;
3834 pCaps
->Caps2
= WINED3DCAPS2_CANRENDERWINDOWED
|
3835 WINED3DCAPS2_FULLSCREENGAMMA
|
3836 WINED3DCAPS2_DYNAMICTEXTURES
;
3837 if (gl_info
->supported
[SGIS_GENERATE_MIPMAP
])
3839 pCaps
->Caps2
|= WINED3DCAPS2_CANAUTOGENMIPMAP
;
3842 pCaps
->Caps3
= WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD
|
3843 WINED3DCAPS3_COPY_TO_VIDMEM
|
3844 WINED3DCAPS3_COPY_TO_SYSTEMMEM
;
3846 pCaps
->PresentationIntervals
= WINED3DPRESENT_INTERVAL_IMMEDIATE
|
3847 WINED3DPRESENT_INTERVAL_ONE
;
3849 pCaps
->CursorCaps
= WINED3DCURSORCAPS_COLOR
|
3850 WINED3DCURSORCAPS_LOWRES
;
3852 pCaps
->DevCaps
= WINED3DDEVCAPS_FLOATTLVERTEX
|
3853 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY
|
3854 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY
|
3855 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY
|
3856 WINED3DDEVCAPS_DRAWPRIMTLVERTEX
|
3857 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT
|
3858 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY
|
3859 WINED3DDEVCAPS_PUREDEVICE
|
3860 WINED3DDEVCAPS_HWRASTERIZATION
|
3861 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY
|
3862 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY
|
3863 WINED3DDEVCAPS_CANRENDERAFTERFLIP
|
3864 WINED3DDEVCAPS_DRAWPRIMITIVES2
|
3865 WINED3DDEVCAPS_DRAWPRIMITIVES2EX
|
3866 WINED3DDEVCAPS_RTPATCHES
;
3868 pCaps
->PrimitiveMiscCaps
= WINED3DPMISCCAPS_CULLNONE
|
3869 WINED3DPMISCCAPS_CULLCCW
|
3870 WINED3DPMISCCAPS_CULLCW
|
3871 WINED3DPMISCCAPS_COLORWRITEENABLE
|
3872 WINED3DPMISCCAPS_CLIPTLVERTS
|
3873 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS
|
3874 WINED3DPMISCCAPS_MASKZ
|
3875 WINED3DPMISCCAPS_BLENDOP
|
3876 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING
;
3878 WINED3DPMISCCAPS_NULLREFERENCE
3879 WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS
3880 WINED3DPMISCCAPS_FOGANDSPECULARALPHA
3881 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS
3882 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */
3884 if (gl_info
->supported
[EXT_BLEND_EQUATION_SEPARATE
] && gl_info
->supported
[EXT_BLEND_FUNC_SEPARATE
])
3885 pCaps
->PrimitiveMiscCaps
|= WINED3DPMISCCAPS_SEPARATEALPHABLEND
;
3887 pCaps
->RasterCaps
= WINED3DPRASTERCAPS_DITHER
|
3888 WINED3DPRASTERCAPS_PAT
|
3889 WINED3DPRASTERCAPS_WFOG
|
3890 WINED3DPRASTERCAPS_ZFOG
|
3891 WINED3DPRASTERCAPS_FOGVERTEX
|
3892 WINED3DPRASTERCAPS_FOGTABLE
|
3893 WINED3DPRASTERCAPS_STIPPLE
|
3894 WINED3DPRASTERCAPS_SUBPIXEL
|
3895 WINED3DPRASTERCAPS_ZTEST
|
3896 WINED3DPRASTERCAPS_SCISSORTEST
|
3897 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS
|
3898 WINED3DPRASTERCAPS_DEPTHBIAS
;
3900 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
3902 pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_ANISOTROPY
|
3903 WINED3DPRASTERCAPS_ZBIAS
|
3904 WINED3DPRASTERCAPS_MIPMAPLODBIAS
;
3906 if (gl_info
->supported
[NV_FOG_DISTANCE
])
3908 pCaps
->RasterCaps
|= WINED3DPRASTERCAPS_FOGRANGE
;
3911 WINED3DPRASTERCAPS_COLORPERSPECTIVE
3912 WINED3DPRASTERCAPS_STRETCHBLTMULTISAMPLE
3913 WINED3DPRASTERCAPS_ANTIALIASEDGES
3914 WINED3DPRASTERCAPS_ZBUFFERLESSHSR
3915 WINED3DPRASTERCAPS_WBUFFER */
3917 pCaps
->ZCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
3918 WINED3DPCMPCAPS_EQUAL
|
3919 WINED3DPCMPCAPS_GREATER
|
3920 WINED3DPCMPCAPS_GREATEREQUAL
|
3921 WINED3DPCMPCAPS_LESS
|
3922 WINED3DPCMPCAPS_LESSEQUAL
|
3923 WINED3DPCMPCAPS_NEVER
|
3924 WINED3DPCMPCAPS_NOTEQUAL
;
3926 pCaps
->SrcBlendCaps
= WINED3DPBLENDCAPS_BOTHINVSRCALPHA
|
3927 WINED3DPBLENDCAPS_BOTHSRCALPHA
|
3928 WINED3DPBLENDCAPS_DESTALPHA
|
3929 WINED3DPBLENDCAPS_DESTCOLOR
|
3930 WINED3DPBLENDCAPS_INVDESTALPHA
|
3931 WINED3DPBLENDCAPS_INVDESTCOLOR
|
3932 WINED3DPBLENDCAPS_INVSRCALPHA
|
3933 WINED3DPBLENDCAPS_INVSRCCOLOR
|
3934 WINED3DPBLENDCAPS_ONE
|
3935 WINED3DPBLENDCAPS_SRCALPHA
|
3936 WINED3DPBLENDCAPS_SRCALPHASAT
|
3937 WINED3DPBLENDCAPS_SRCCOLOR
|
3938 WINED3DPBLENDCAPS_ZERO
;
3940 pCaps
->DestBlendCaps
= WINED3DPBLENDCAPS_DESTALPHA
|
3941 WINED3DPBLENDCAPS_DESTCOLOR
|
3942 WINED3DPBLENDCAPS_INVDESTALPHA
|
3943 WINED3DPBLENDCAPS_INVDESTCOLOR
|
3944 WINED3DPBLENDCAPS_INVSRCALPHA
|
3945 WINED3DPBLENDCAPS_INVSRCCOLOR
|
3946 WINED3DPBLENDCAPS_ONE
|
3947 WINED3DPBLENDCAPS_SRCALPHA
|
3948 WINED3DPBLENDCAPS_SRCCOLOR
|
3949 WINED3DPBLENDCAPS_ZERO
;
3950 /* NOTE: WINED3DPBLENDCAPS_SRCALPHASAT is not supported as dest blend factor,
3951 * according to the glBlendFunc manpage
3953 * WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA are
3954 * legacy settings for srcblend only
3957 if (gl_info
->supported
[EXT_BLEND_COLOR
])
3959 pCaps
->SrcBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
3960 pCaps
->DestBlendCaps
|= WINED3DPBLENDCAPS_BLENDFACTOR
;
3964 pCaps
->AlphaCmpCaps
= WINED3DPCMPCAPS_ALWAYS
|
3965 WINED3DPCMPCAPS_EQUAL
|
3966 WINED3DPCMPCAPS_GREATER
|
3967 WINED3DPCMPCAPS_GREATEREQUAL
|
3968 WINED3DPCMPCAPS_LESS
|
3969 WINED3DPCMPCAPS_LESSEQUAL
|
3970 WINED3DPCMPCAPS_NEVER
|
3971 WINED3DPCMPCAPS_NOTEQUAL
;
3973 pCaps
->ShadeCaps
= WINED3DPSHADECAPS_SPECULARGOURAUDRGB
|
3974 WINED3DPSHADECAPS_COLORGOURAUDRGB
|
3975 WINED3DPSHADECAPS_ALPHAFLATBLEND
|
3976 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND
|
3977 WINED3DPSHADECAPS_COLORFLATRGB
|
3978 WINED3DPSHADECAPS_FOGFLAT
|
3979 WINED3DPSHADECAPS_FOGGOURAUD
|
3980 WINED3DPSHADECAPS_SPECULARFLATRGB
;
3982 pCaps
->TextureCaps
= WINED3DPTEXTURECAPS_ALPHA
|
3983 WINED3DPTEXTURECAPS_ALPHAPALETTE
|
3984 WINED3DPTEXTURECAPS_TRANSPARENCY
|
3985 WINED3DPTEXTURECAPS_BORDER
|
3986 WINED3DPTEXTURECAPS_MIPMAP
|
3987 WINED3DPTEXTURECAPS_PROJECTED
|
3988 WINED3DPTEXTURECAPS_PERSPECTIVE
;
3990 if (!gl_info
->supported
[ARB_TEXTURE_NON_POWER_OF_TWO
])
3992 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_POW2
|
3993 WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL
;
3996 if (gl_info
->supported
[EXT_TEXTURE3D
])
3998 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_VOLUMEMAP
|
3999 WINED3DPTEXTURECAPS_MIPVOLUMEMAP
|
4000 WINED3DPTEXTURECAPS_VOLUMEMAP_POW2
;
4003 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
4005 pCaps
->TextureCaps
|= WINED3DPTEXTURECAPS_CUBEMAP
|
4006 WINED3DPTEXTURECAPS_MIPCUBEMAP
|
4007 WINED3DPTEXTURECAPS_CUBEMAP_POW2
;
4011 pCaps
->TextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
4012 WINED3DPTFILTERCAPS_MAGFPOINT
|
4013 WINED3DPTFILTERCAPS_MINFLINEAR
|
4014 WINED3DPTFILTERCAPS_MINFPOINT
|
4015 WINED3DPTFILTERCAPS_MIPFLINEAR
|
4016 WINED3DPTFILTERCAPS_MIPFPOINT
|
4017 WINED3DPTFILTERCAPS_LINEAR
|
4018 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
4019 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
4020 WINED3DPTFILTERCAPS_MIPLINEAR
|
4021 WINED3DPTFILTERCAPS_MIPNEAREST
|
4022 WINED3DPTFILTERCAPS_NEAREST
;
4024 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
4026 pCaps
->TextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
4027 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
4030 if (gl_info
->supported
[ARB_TEXTURE_CUBE_MAP
])
4032 pCaps
->CubeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
4033 WINED3DPTFILTERCAPS_MAGFPOINT
|
4034 WINED3DPTFILTERCAPS_MINFLINEAR
|
4035 WINED3DPTFILTERCAPS_MINFPOINT
|
4036 WINED3DPTFILTERCAPS_MIPFLINEAR
|
4037 WINED3DPTFILTERCAPS_MIPFPOINT
|
4038 WINED3DPTFILTERCAPS_LINEAR
|
4039 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
4040 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
4041 WINED3DPTFILTERCAPS_MIPLINEAR
|
4042 WINED3DPTFILTERCAPS_MIPNEAREST
|
4043 WINED3DPTFILTERCAPS_NEAREST
;
4045 if (gl_info
->supported
[EXT_TEXTURE_FILTER_ANISOTROPIC
])
4047 pCaps
->CubeTextureFilterCaps
|= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
|
4048 WINED3DPTFILTERCAPS_MINFANISOTROPIC
;
4051 pCaps
->CubeTextureFilterCaps
= 0;
4053 if (gl_info
->supported
[EXT_TEXTURE3D
])
4055 pCaps
->VolumeTextureFilterCaps
= WINED3DPTFILTERCAPS_MAGFLINEAR
|
4056 WINED3DPTFILTERCAPS_MAGFPOINT
|
4057 WINED3DPTFILTERCAPS_MINFLINEAR
|
4058 WINED3DPTFILTERCAPS_MINFPOINT
|
4059 WINED3DPTFILTERCAPS_MIPFLINEAR
|
4060 WINED3DPTFILTERCAPS_MIPFPOINT
|
4061 WINED3DPTFILTERCAPS_LINEAR
|
4062 WINED3DPTFILTERCAPS_LINEARMIPLINEAR
|
4063 WINED3DPTFILTERCAPS_LINEARMIPNEAREST
|
4064 WINED3DPTFILTERCAPS_MIPLINEAR
|
4065 WINED3DPTFILTERCAPS_MIPNEAREST
|
4066 WINED3DPTFILTERCAPS_NEAREST
;
4068 pCaps
->VolumeTextureFilterCaps
= 0;
4070 pCaps
->TextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
4071 WINED3DPTADDRESSCAPS_CLAMP
|
4072 WINED3DPTADDRESSCAPS_WRAP
;
4074 if (gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
])
4076 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
4078 if (gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
])
4080 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
4082 if (gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
])
4084 pCaps
->TextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
4087 if (gl_info
->supported
[EXT_TEXTURE3D
])
4089 pCaps
->VolumeTextureAddressCaps
= WINED3DPTADDRESSCAPS_INDEPENDENTUV
|
4090 WINED3DPTADDRESSCAPS_CLAMP
|
4091 WINED3DPTADDRESSCAPS_WRAP
;
4092 if (gl_info
->supported
[ARB_TEXTURE_BORDER_CLAMP
])
4094 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_BORDER
;
4096 if (gl_info
->supported
[ARB_TEXTURE_MIRRORED_REPEAT
])
4098 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRROR
;
4100 if (gl_info
->supported
[ATI_TEXTURE_MIRROR_ONCE
])
4102 pCaps
->VolumeTextureAddressCaps
|= WINED3DPTADDRESSCAPS_MIRRORONCE
;
4105 pCaps
->VolumeTextureAddressCaps
= 0;
4107 pCaps
->LineCaps
= WINED3DLINECAPS_TEXTURE
|
4108 WINED3DLINECAPS_ZTEST
|
4109 WINED3DLINECAPS_BLEND
|
4110 WINED3DLINECAPS_ALPHACMP
|
4111 WINED3DLINECAPS_FOG
;
4112 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different
4113 * idea how generating the smoothing alpha values works; the result is different
4116 pCaps
->MaxTextureWidth
= gl_info
->limits
.texture_size
;
4117 pCaps
->MaxTextureHeight
= gl_info
->limits
.texture_size
;
4119 if (gl_info
->supported
[EXT_TEXTURE3D
])
4120 pCaps
->MaxVolumeExtent
= gl_info
->limits
.texture3d_size
;
4122 pCaps
->MaxVolumeExtent
= 0;
4124 pCaps
->MaxTextureRepeat
= 32768;
4125 pCaps
->MaxTextureAspectRatio
= gl_info
->limits
.texture_size
;
4126 pCaps
->MaxVertexW
= 1.0f
;
4128 pCaps
->GuardBandLeft
= 0.0f
;
4129 pCaps
->GuardBandTop
= 0.0f
;
4130 pCaps
->GuardBandRight
= 0.0f
;
4131 pCaps
->GuardBandBottom
= 0.0f
;
4133 pCaps
->ExtentsAdjust
= 0.0f
;
4135 pCaps
->StencilCaps
= WINED3DSTENCILCAPS_DECRSAT
|
4136 WINED3DSTENCILCAPS_INCRSAT
|
4137 WINED3DSTENCILCAPS_INVERT
|
4138 WINED3DSTENCILCAPS_KEEP
|
4139 WINED3DSTENCILCAPS_REPLACE
|
4140 WINED3DSTENCILCAPS_ZERO
;
4141 if (gl_info
->supported
[EXT_STENCIL_WRAP
])
4143 pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_DECR
|
4144 WINED3DSTENCILCAPS_INCR
;
4146 if (gl_info
->supported
[EXT_STENCIL_TWO_SIDE
] || gl_info
->supported
[ATI_SEPARATE_STENCIL
])
4148 pCaps
->StencilCaps
|= WINED3DSTENCILCAPS_TWOSIDED
;
4151 pCaps
->FVFCaps
= WINED3DFVFCAPS_PSIZE
| 0x0008; /* 8 texture coords */
4153 pCaps
->MaxUserClipPlanes
= gl_info
->limits
.clipplanes
;
4154 pCaps
->MaxActiveLights
= gl_info
->limits
.lights
;
4156 pCaps
->MaxVertexBlendMatrices
= gl_info
->limits
.blends
;
4157 pCaps
->MaxVertexBlendMatrixIndex
= 0;
4159 pCaps
->MaxAnisotropy
= gl_info
->limits
.anisotropy
;
4160 pCaps
->MaxPointSize
= gl_info
->limits
.pointsize_max
;
4163 /* FIXME: Add D3DVTXPCAPS_TWEENING, D3DVTXPCAPS_TEXGEN_SPHEREMAP */
4164 pCaps
->VertexProcessingCaps
= WINED3DVTXPCAPS_DIRECTIONALLIGHTS
|
4165 WINED3DVTXPCAPS_MATERIALSOURCE7
|
4166 WINED3DVTXPCAPS_POSITIONALLIGHTS
|
4167 WINED3DVTXPCAPS_LOCALVIEWER
|
4168 WINED3DVTXPCAPS_VERTEXFOG
|
4169 WINED3DVTXPCAPS_TEXGEN
;
4171 pCaps
->MaxPrimitiveCount
= 0xFFFFF; /* For now set 2^20-1 which is used by most >=Geforce3/Radeon8500 cards */
4172 pCaps
->MaxVertexIndex
= 0xFFFFF;
4173 pCaps
->MaxStreams
= MAX_STREAMS
;
4174 pCaps
->MaxStreamStride
= 1024;
4176 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */
4177 pCaps
->DevCaps2
= WINED3DDEVCAPS2_STREAMOFFSET
|
4178 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET
;
4179 pCaps
->MaxNpatchTessellationLevel
= 0;
4180 pCaps
->MasterAdapterOrdinal
= 0;
4181 pCaps
->AdapterOrdinalInGroup
= 0;
4182 pCaps
->NumberOfAdaptersInGroup
= 1;
4184 pCaps
->NumSimultaneousRTs
= gl_info
->limits
.buffers
;
4186 pCaps
->StretchRectFilterCaps
= WINED3DPTFILTERCAPS_MINFPOINT
|
4187 WINED3DPTFILTERCAPS_MAGFPOINT
|
4188 WINED3DPTFILTERCAPS_MINFLINEAR
|
4189 WINED3DPTFILTERCAPS_MAGFLINEAR
;
4190 pCaps
->VertexTextureFilterCaps
= 0;
4192 memset(&shader_caps
, 0, sizeof(shader_caps
));
4193 shader_backend
= select_shader_backend(adapter
, DeviceType
);
4194 shader_backend
->shader_get_caps(DeviceType
, &adapter
->gl_info
, &shader_caps
);
4196 memset(&fragment_caps
, 0, sizeof(fragment_caps
));
4197 frag_pipeline
= select_fragment_implementation(adapter
, DeviceType
);
4198 frag_pipeline
->get_caps(DeviceType
, &adapter
->gl_info
, &fragment_caps
);
4200 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */
4201 pCaps
->PrimitiveMiscCaps
|= fragment_caps
.PrimitiveMiscCaps
;
4203 /* This takes care for disabling vertex shader or pixel shader caps while leaving the other one enabled.
4204 * Ignore shader model capabilities if disabled in config
4206 if(vs_selected_mode
== SHADER_NONE
) {
4207 TRACE_(d3d_caps
)("Vertex shader disabled in config, reporting version 0.0\n");
4208 pCaps
->VertexShaderVersion
= WINED3DVS_VERSION(0,0);
4209 pCaps
->MaxVertexShaderConst
= 0;
4211 pCaps
->VertexShaderVersion
= shader_caps
.VertexShaderVersion
;
4212 pCaps
->MaxVertexShaderConst
= shader_caps
.MaxVertexShaderConst
;
4215 if(ps_selected_mode
== SHADER_NONE
) {
4216 TRACE_(d3d_caps
)("Pixel shader disabled in config, reporting version 0.0\n");
4217 pCaps
->PixelShaderVersion
= WINED3DPS_VERSION(0,0);
4218 pCaps
->PixelShader1xMaxValue
= 0.0f
;
4220 pCaps
->PixelShaderVersion
= shader_caps
.PixelShaderVersion
;
4221 pCaps
->PixelShader1xMaxValue
= shader_caps
.PixelShader1xMaxValue
;
4224 pCaps
->TextureOpCaps
= fragment_caps
.TextureOpCaps
;
4225 pCaps
->MaxTextureBlendStages
= fragment_caps
.MaxTextureBlendStages
;
4226 pCaps
->MaxSimultaneousTextures
= fragment_caps
.MaxSimultaneousTextures
;
4228 pCaps
->VS20Caps
= shader_caps
.VS20Caps
;
4229 pCaps
->MaxVShaderInstructionsExecuted
= shader_caps
.MaxVShaderInstructionsExecuted
;
4230 pCaps
->MaxVertexShader30InstructionSlots
= shader_caps
.MaxVertexShader30InstructionSlots
;
4231 pCaps
->PS20Caps
= shader_caps
.PS20Caps
;
4232 pCaps
->MaxPShaderInstructionsExecuted
= shader_caps
.MaxPShaderInstructionsExecuted
;
4233 pCaps
->MaxPixelShader30InstructionSlots
= shader_caps
.MaxPixelShader30InstructionSlots
;
4235 /* The following caps are shader specific, but they are things we cannot detect, or which
4236 * are the same among all shader models. So to avoid code duplication set the shader version
4237 * specific, but otherwise constant caps here
4239 if(pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(3,0)) {
4240 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4241 use the VS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum VS3.0 value. */
4242 pCaps
->VS20Caps
.Caps
= WINED3DVS20CAPS_PREDICATION
;
4243 pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4244 pCaps
->VS20Caps
.NumTemps
= max(32, adapter
->gl_info
.limits
.arb_vs_temps
);
4245 pCaps
->VS20Caps
.StaticFlowControlDepth
= WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH
; /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */
4247 pCaps
->MaxVShaderInstructionsExecuted
= 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */
4248 pCaps
->MaxVertexShader30InstructionSlots
= max(512, adapter
->gl_info
.limits
.arb_vs_instructions
);
4250 else if (pCaps
->VertexShaderVersion
== WINED3DVS_VERSION(2,0))
4252 pCaps
->VS20Caps
.Caps
= 0;
4253 pCaps
->VS20Caps
.DynamicFlowControlDepth
= WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH
;
4254 pCaps
->VS20Caps
.NumTemps
= max(12, adapter
->gl_info
.limits
.arb_vs_temps
);
4255 pCaps
->VS20Caps
.StaticFlowControlDepth
= 1;
4257 pCaps
->MaxVShaderInstructionsExecuted
= 65535;
4258 pCaps
->MaxVertexShader30InstructionSlots
= 0;
4259 } else { /* VS 1.x */
4260 pCaps
->VS20Caps
.Caps
= 0;
4261 pCaps
->VS20Caps
.DynamicFlowControlDepth
= 0;
4262 pCaps
->VS20Caps
.NumTemps
= 0;
4263 pCaps
->VS20Caps
.StaticFlowControlDepth
= 0;
4265 pCaps
->MaxVShaderInstructionsExecuted
= 0;
4266 pCaps
->MaxVertexShader30InstructionSlots
= 0;
4269 if(pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(3,0)) {
4270 /* Where possible set the caps based on OpenGL extensions and if they aren't set (in case of software rendering)
4271 use the PS 3.0 from MSDN or else if there's OpenGL spec use a hardcoded value minimum PS 3.0 value. */
4273 /* 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 */
4274 pCaps
->PS20Caps
.Caps
= WINED3DPS20CAPS_ARBITRARYSWIZZLE
|
4275 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS
|
4276 WINED3DPS20CAPS_PREDICATION
|
4277 WINED3DPS20CAPS_NODEPENDENTREADLIMIT
|
4278 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT
;
4279 pCaps
->PS20Caps
.DynamicFlowControlDepth
= WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */
4280 pCaps
->PS20Caps
.NumTemps
= max(32, adapter
->gl_info
.limits
.arb_ps_temps
);
4281 pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH
; /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */
4282 pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS
; /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */
4284 pCaps
->MaxPShaderInstructionsExecuted
= 65535;
4285 pCaps
->MaxPixelShader30InstructionSlots
= max(WINED3DMIN30SHADERINSTRUCTIONS
,
4286 adapter
->gl_info
.limits
.arb_ps_instructions
);
4288 else if(pCaps
->PixelShaderVersion
== WINED3DPS_VERSION(2,0))
4290 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */
4291 pCaps
->PS20Caps
.Caps
= 0;
4292 pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */
4293 pCaps
->PS20Caps
.NumTemps
= max(12, adapter
->gl_info
.limits
.arb_ps_temps
);
4294 pCaps
->PS20Caps
.StaticFlowControlDepth
= WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH
; /* Minimum: 1 */
4295 pCaps
->PS20Caps
.NumInstructionSlots
= WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS
; /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */
4297 pCaps
->MaxPShaderInstructionsExecuted
= 512; /* Minimum value, a GeforceFX uses 1024 */
4298 pCaps
->MaxPixelShader30InstructionSlots
= 0;
4299 } else { /* PS 1.x */
4300 pCaps
->PS20Caps
.Caps
= 0;
4301 pCaps
->PS20Caps
.DynamicFlowControlDepth
= 0;
4302 pCaps
->PS20Caps
.NumTemps
= 0;
4303 pCaps
->PS20Caps
.StaticFlowControlDepth
= 0;
4304 pCaps
->PS20Caps
.NumInstructionSlots
= 0;
4306 pCaps
->MaxPShaderInstructionsExecuted
= 0;
4307 pCaps
->MaxPixelShader30InstructionSlots
= 0;
4310 if(pCaps
->VertexShaderVersion
>= WINED3DVS_VERSION(2,0)) {
4311 /* OpenGL supports all the formats below, perhaps not always
4312 * without conversion, but it supports them.
4313 * Further GLSL doesn't seem to have an official unsigned type so
4314 * don't advertise it yet as I'm not sure how we handle it.
4315 * We might need to add some clamping in the shader engine to
4317 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */
4318 pCaps
->DeclTypes
= WINED3DDTCAPS_UBYTE4
|
4319 WINED3DDTCAPS_UBYTE4N
|
4320 WINED3DDTCAPS_SHORT2N
|
4321 WINED3DDTCAPS_SHORT4N
;
4322 if (gl_info
->supported
[ARB_HALF_FLOAT_VERTEX
])
4324 pCaps
->DeclTypes
|= WINED3DDTCAPS_FLOAT16_2
|
4325 WINED3DDTCAPS_FLOAT16_4
;
4328 pCaps
->DeclTypes
= 0;
4330 /* Set DirectDraw helper Caps */
4331 ckey_caps
= WINEDDCKEYCAPS_DESTBLT
|
4332 WINEDDCKEYCAPS_SRCBLT
;
4333 fx_caps
= WINEDDFXCAPS_BLTALPHA
|
4334 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT
|
4335 WINEDDFXCAPS_BLTMIRRORUPDOWN
|
4336 WINEDDFXCAPS_BLTROTATION90
|
4337 WINEDDFXCAPS_BLTSHRINKX
|
4338 WINEDDFXCAPS_BLTSHRINKXN
|
4339 WINEDDFXCAPS_BLTSHRINKY
|
4340 WINEDDFXCAPS_BLTSHRINKXN
|
4341 WINEDDFXCAPS_BLTSTRETCHX
|
4342 WINEDDFXCAPS_BLTSTRETCHXN
|
4343 WINEDDFXCAPS_BLTSTRETCHY
|
4344 WINEDDFXCAPS_BLTSTRETCHYN
;
4345 blit_caps
= WINEDDCAPS_BLT
|
4346 WINEDDCAPS_BLTCOLORFILL
|
4347 WINEDDCAPS_BLTDEPTHFILL
|
4348 WINEDDCAPS_BLTSTRETCH
|
4349 WINEDDCAPS_CANBLTSYSMEM
|
4350 WINEDDCAPS_CANCLIP
|
4351 WINEDDCAPS_CANCLIPSTRETCHED
|
4352 WINEDDCAPS_COLORKEY
|
4353 WINEDDCAPS_COLORKEYHWASSIST
|
4354 WINEDDCAPS_ALIGNBOUNDARYSRC
;
4356 /* Fill the ddraw caps structure */
4357 pCaps
->DirectDrawCaps
.Caps
= WINEDDCAPS_GDI
|
4358 WINEDDCAPS_PALETTE
|
4360 pCaps
->DirectDrawCaps
.Caps2
= WINEDDCAPS2_CERTIFIED
|
4361 WINEDDCAPS2_NOPAGELOCKREQUIRED
|
4362 WINEDDCAPS2_PRIMARYGAMMA
|
4363 WINEDDCAPS2_WIDESURFACES
|
4364 WINEDDCAPS2_CANRENDERWINDOWED
;
4365 pCaps
->DirectDrawCaps
.SVBCaps
= blit_caps
;
4366 pCaps
->DirectDrawCaps
.SVBCKeyCaps
= ckey_caps
;
4367 pCaps
->DirectDrawCaps
.SVBFXCaps
= fx_caps
;
4368 pCaps
->DirectDrawCaps
.VSBCaps
= blit_caps
;
4369 pCaps
->DirectDrawCaps
.VSBCKeyCaps
= ckey_caps
;
4370 pCaps
->DirectDrawCaps
.VSBFXCaps
= fx_caps
;
4371 pCaps
->DirectDrawCaps
.SSBCaps
= blit_caps
;
4372 pCaps
->DirectDrawCaps
.SSBCKeyCaps
= ckey_caps
;
4373 pCaps
->DirectDrawCaps
.SSBFXCaps
= fx_caps
;
4375 pCaps
->DirectDrawCaps
.ddsCaps
= WINEDDSCAPS_ALPHA
|
4376 WINEDDSCAPS_BACKBUFFER
|
4378 WINEDDSCAPS_FRONTBUFFER
|
4379 WINEDDSCAPS_OFFSCREENPLAIN
|
4380 WINEDDSCAPS_PALETTE
|
4381 WINEDDSCAPS_PRIMARYSURFACE
|
4382 WINEDDSCAPS_SYSTEMMEMORY
|
4383 WINEDDSCAPS_VIDEOMEMORY
|
4384 WINEDDSCAPS_VISIBLE
;
4385 pCaps
->DirectDrawCaps
.StrideAlign
= DDRAW_PITCH_ALIGNMENT
;
4387 /* Set D3D caps if OpenGL is available. */
4388 if (adapter
->opengl
)
4390 pCaps
->DirectDrawCaps
.ddsCaps
|=WINEDDSCAPS_3DDEVICE
|
4391 WINEDDSCAPS_MIPMAP
|
4392 WINEDDSCAPS_TEXTURE
|
4393 WINEDDSCAPS_ZBUFFER
;
4394 pCaps
->DirectDrawCaps
.Caps
|= WINEDDCAPS_3D
;
4400 static HRESULT WINAPI
IWineD3DImpl_CreateDevice(IWineD3D
*iface
, UINT adapter_idx
,
4401 WINED3DDEVTYPE device_type
, HWND focus_window
, DWORD flags
, IUnknown
*parent
,
4402 IWineD3DDeviceParent
*device_parent
, IWineD3DDevice
**device
)
4404 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
4405 IWineD3DDeviceImpl
*object
;
4408 TRACE("iface %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x.\n"
4409 "parent %p, device_parent %p, device %p.\n",
4410 iface
, adapter_idx
, device_type
, focus_window
, flags
,
4411 parent
, device_parent
, device
);
4413 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter
4414 * number and create a device without a 3D adapter for 2D only operation. */
4415 if (IWineD3D_GetAdapterCount(iface
) && adapter_idx
>= IWineD3D_GetAdapterCount(iface
))
4417 return WINED3DERR_INVALIDCALL
;
4420 object
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(*object
));
4423 ERR("Failed to allocate device memory.\n");
4424 return E_OUTOFMEMORY
;
4427 hr
= device_init(object
, This
, adapter_idx
, device_type
, focus_window
, flags
, parent
, device_parent
);
4430 WARN("Failed to initialize device, hr %#x.\n", hr
);
4431 HeapFree(GetProcessHeap(), 0, object
);
4435 TRACE("Created device %p.\n", object
);
4436 *device
= (IWineD3DDevice
*)object
;
4438 IWineD3DDeviceParent_WineD3DDeviceCreated(device_parent
, *device
);
4443 static HRESULT WINAPI
IWineD3DImpl_GetParent(IWineD3D
*iface
, IUnknown
**pParent
) {
4444 IWineD3DImpl
*This
= (IWineD3DImpl
*)iface
;
4445 IUnknown_AddRef(This
->parent
);
4446 *pParent
= This
->parent
;
4450 static void WINE_GLAPI
invalid_func(const void *data
)
4452 ERR("Invalid vertex attribute function called\n");
4456 static void WINE_GLAPI
invalid_texcoord_func(GLenum unit
, const void *data
)
4458 ERR("Invalid texcoord function called\n");
4462 /* Helper functions for providing vertex data to opengl. The arrays are initialized based on
4463 * the extension detection and are used in drawStridedSlow
4465 static void WINE_GLAPI
position_d3dcolor(const void *data
)
4467 DWORD pos
= *((const DWORD
*)data
);
4469 FIXME("Add a test for fixed function position from d3dcolor type\n");
4470 glVertex4s(D3DCOLOR_B_R(pos
),
4476 static void WINE_GLAPI
position_float4(const void *data
)
4478 const GLfloat
*pos
= data
;
4480 if (pos
[3] != 0.0f
&& pos
[3] != 1.0f
)
4482 float w
= 1.0f
/ pos
[3];
4484 glVertex4f(pos
[0] * w
, pos
[1] * w
, pos
[2] * w
, w
);
4492 static void WINE_GLAPI
diffuse_d3dcolor(const void *data
)
4494 DWORD diffuseColor
= *((const DWORD
*)data
);
4496 glColor4ub(D3DCOLOR_B_R(diffuseColor
),
4497 D3DCOLOR_B_G(diffuseColor
),
4498 D3DCOLOR_B_B(diffuseColor
),
4499 D3DCOLOR_B_A(diffuseColor
));
4502 static void WINE_GLAPI
specular_d3dcolor(const void *data
)
4504 DWORD specularColor
= *((const DWORD
*)data
);
4505 GLbyte d
[] = {D3DCOLOR_B_R(specularColor
),
4506 D3DCOLOR_B_G(specularColor
),
4507 D3DCOLOR_B_B(specularColor
)};
4509 specular_func_3ubv(d
);
4512 static void WINE_GLAPI
warn_no_specular_func(const void *data
)
4514 WARN("GL_EXT_secondary_color not supported\n");
4517 static void fillGLAttribFuncs(const struct wined3d_gl_info
*gl_info
)
4519 position_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4520 position_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4521 position_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)glVertex3fv
;
4522 position_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = position_float4
;
4523 position_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = position_d3dcolor
;
4524 position_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4525 position_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4526 position_funcs
[WINED3D_FFP_EMIT_SHORT4
] = (glAttribFunc
)glVertex2sv
;
4527 position_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_func
;
4528 position_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4529 position_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_func
;
4530 position_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4531 position_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_func
;
4532 position_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4533 position_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4534 position_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4535 position_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4537 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4538 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4539 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)glColor3fv
;
4540 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = (glAttribFunc
)glColor4fv
;
4541 diffuse_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = diffuse_d3dcolor
;
4542 diffuse_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4543 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4544 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT4
] = invalid_func
;
4545 diffuse_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = (glAttribFunc
)glColor4ubv
;
4546 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4547 diffuse_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = (glAttribFunc
)glColor4sv
;
4548 diffuse_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4549 diffuse_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = (glAttribFunc
)glColor4usv
;
4550 diffuse_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4551 diffuse_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4552 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4553 diffuse_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4555 /* No 4 component entry points here */
4556 specular_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4557 specular_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4558 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4560 specular_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)GL_EXTCALL(glSecondaryColor3fvEXT
);
4564 specular_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = warn_no_specular_func
;
4566 specular_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = invalid_func
;
4567 if (gl_info
->supported
[EXT_SECONDARY_COLOR
])
4569 specular_func_3ubv
= (glAttribFunc
)GL_EXTCALL(glSecondaryColor3ubvEXT
);
4570 specular_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = specular_d3dcolor
;
4574 specular_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = warn_no_specular_func
;
4576 specular_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4577 specular_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4578 specular_funcs
[WINED3D_FFP_EMIT_SHORT4
] = invalid_func
;
4579 specular_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_func
;
4580 specular_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4581 specular_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_func
;
4582 specular_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4583 specular_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_func
;
4584 specular_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4585 specular_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4586 specular_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4587 specular_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4589 /* Only 3 component entry points here. Test how others behave. Float4 normals are used
4590 * by one of our tests, trying to pass it to the pixel shader, which fails on Windows.
4592 normal_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = invalid_func
;
4593 normal_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = invalid_func
;
4594 normal_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glAttribFunc
)glNormal3fv
;
4595 normal_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = (glAttribFunc
)glNormal3fv
; /* Just ignore the 4th value */
4596 normal_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = invalid_func
;
4597 normal_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_func
;
4598 normal_funcs
[WINED3D_FFP_EMIT_SHORT2
] = invalid_func
;
4599 normal_funcs
[WINED3D_FFP_EMIT_SHORT4
] = invalid_func
;
4600 normal_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_func
;
4601 normal_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_func
;
4602 normal_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_func
;
4603 normal_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_func
;
4604 normal_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_func
;
4605 normal_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_func
;
4606 normal_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_func
;
4607 normal_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_func
;
4608 normal_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_func
;
4610 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT1
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord1fvARB
);
4611 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2fvARB
);
4612 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT3
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord3fvARB
);
4613 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4fvARB
);
4614 multi_texcoord_funcs
[WINED3D_FFP_EMIT_D3DCOLOR
] = invalid_texcoord_func
;
4615 multi_texcoord_funcs
[WINED3D_FFP_EMIT_UBYTE4
] = invalid_texcoord_func
;
4616 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2svARB
);
4617 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4svARB
);
4618 multi_texcoord_funcs
[WINED3D_FFP_EMIT_UBYTE4N
] = invalid_texcoord_func
;
4619 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT2N
] = invalid_texcoord_func
;
4620 multi_texcoord_funcs
[WINED3D_FFP_EMIT_SHORT4N
] = invalid_texcoord_func
;
4621 multi_texcoord_funcs
[WINED3D_FFP_EMIT_USHORT2N
] = invalid_texcoord_func
;
4622 multi_texcoord_funcs
[WINED3D_FFP_EMIT_USHORT4N
] = invalid_texcoord_func
;
4623 multi_texcoord_funcs
[WINED3D_FFP_EMIT_UDEC3
] = invalid_texcoord_func
;
4624 multi_texcoord_funcs
[WINED3D_FFP_EMIT_DEC3N
] = invalid_texcoord_func
;
4625 if (gl_info
->supported
[NV_HALF_FLOAT
])
4627 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT */
4628 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord2hvNV
);
4629 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = (glMultiTexCoordFunc
)GL_EXTCALL(glMultiTexCoord4hvNV
);
4631 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_2
] = invalid_texcoord_func
;
4632 multi_texcoord_funcs
[WINED3D_FFP_EMIT_FLOAT16_4
] = invalid_texcoord_func
;
4636 BOOL
InitAdapters(IWineD3DImpl
*This
)
4638 static HMODULE mod_gl
;
4640 int ps_selected_mode
, vs_selected_mode
;
4642 /* No need to hold any lock. The calling library makes sure only one thread calls
4643 * wined3d simultaneously
4646 TRACE("Initializing adapters\n");
4649 #ifdef USE_WIN32_OPENGL
4650 #define USE_GL_FUNC(pfn) pfn = (void*)GetProcAddress(mod_gl, #pfn);
4651 mod_gl
= LoadLibraryA("opengl32.dll");
4653 ERR("Can't load opengl32.dll!\n");
4657 #define USE_GL_FUNC(pfn) pfn = (void*)pwglGetProcAddress(#pfn);
4658 /* To bypass the opengl32 thunks load wglGetProcAddress from gdi32 (glXGetProcAddress wrapper) instead of opengl32's */
4659 mod_gl
= GetModuleHandleA("gdi32.dll");
4663 /* Load WGL core functions from opengl32.dll */
4664 #define USE_WGL_FUNC(pfn) p##pfn = (void*)GetProcAddress(mod_gl, #pfn);
4668 if(!pwglGetProcAddress
) {
4669 ERR("Unable to load wglGetProcAddress!\n");
4673 /* Dynamically load all GL core functions */
4677 /* Load glFinish and glFlush from opengl32.dll even if we're not using WIN32 opengl
4678 * otherwise because we have to use winex11.drv's override
4680 #ifdef USE_WIN32_OPENGL
4681 wglFinish
= (void*)GetProcAddress(mod_gl
, "glFinish");
4682 wglFlush
= (void*)GetProcAddress(mod_gl
, "glFlush");
4684 wglFinish
= (void*)pwglGetProcAddress("wglFinish");
4685 wglFlush
= (void*)pwglGetProcAddress("wglFlush");
4688 glEnableWINE
= glEnable
;
4689 glDisableWINE
= glDisable
;
4691 /* For now only one default adapter */
4693 struct wined3d_adapter
*adapter
= &This
->adapters
[0];
4694 const struct wined3d_gl_info
*gl_info
= &adapter
->gl_info
;
4695 struct wined3d_fake_gl_ctx fake_gl_ctx
= {0};
4699 WineD3D_PixelFormat
*cfgs
;
4700 DISPLAY_DEVICEW DisplayDevice
;
4703 TRACE("Initializing default adapter\n");
4704 adapter
->ordinal
= 0;
4705 adapter
->monitorPoint
.x
= -1;
4706 adapter
->monitorPoint
.y
= -1;
4708 if (!AllocateLocallyUniqueId(&adapter
->luid
))
4710 DWORD err
= GetLastError();
4711 ERR("Failed to set adapter LUID (%#x).\n", err
);
4714 TRACE("Allocated LUID %08x:%08x for adapter.\n",
4715 adapter
->luid
.HighPart
, adapter
->luid
.LowPart
);
4717 if (!WineD3D_CreateFakeGLContext(&fake_gl_ctx
))
4719 ERR("Failed to get a gl context for default adapter\n");
4723 ret
= IWineD3DImpl_FillGLCaps(&adapter
->driver_info
, &adapter
->gl_info
);
4725 ERR("Failed to initialize gl caps for default adapter\n");
4726 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4729 ret
= initPixelFormats(&adapter
->gl_info
, adapter
->driver_info
.vendor
);
4731 ERR("Failed to init gl formats\n");
4732 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4736 hdc
= fake_gl_ctx
.dc
;
4738 /* Use the VideoRamSize registry setting when set */
4739 if(wined3d_settings
.emulated_textureram
)
4740 adapter
->TextureRam
= wined3d_settings
.emulated_textureram
;
4742 adapter
->TextureRam
= adapter
->gl_info
.vidmem
;
4743 adapter
->UsedTextureRam
= 0;
4744 TRACE("Emulating %dMB of texture ram\n", adapter
->TextureRam
/(1024*1024));
4746 /* Initialize the Adapter's DeviceName which is required for ChangeDisplaySettings and friends */
4747 DisplayDevice
.cb
= sizeof(DisplayDevice
);
4748 EnumDisplayDevicesW(NULL
, 0 /* Adapter 0 = iDevNum 0 */, &DisplayDevice
, 0);
4749 TRACE("DeviceName: %s\n", debugstr_w(DisplayDevice
.DeviceName
));
4750 strcpyW(adapter
->DeviceName
, DisplayDevice
.DeviceName
);
4752 if (gl_info
->supported
[WGL_ARB_PIXEL_FORMAT
])
4759 attribute
= WGL_NUMBER_PIXEL_FORMATS_ARB
;
4760 GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, 0, 0, 1, &attribute
, &adapter
->nCfgs
));
4762 adapter
->cfgs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, adapter
->nCfgs
*sizeof(WineD3D_PixelFormat
));
4763 cfgs
= adapter
->cfgs
;
4764 attribs
[nAttribs
++] = WGL_RED_BITS_ARB
;
4765 attribs
[nAttribs
++] = WGL_GREEN_BITS_ARB
;
4766 attribs
[nAttribs
++] = WGL_BLUE_BITS_ARB
;
4767 attribs
[nAttribs
++] = WGL_ALPHA_BITS_ARB
;
4768 attribs
[nAttribs
++] = WGL_DEPTH_BITS_ARB
;
4769 attribs
[nAttribs
++] = WGL_STENCIL_BITS_ARB
;
4770 attribs
[nAttribs
++] = WGL_DRAW_TO_WINDOW_ARB
;
4771 attribs
[nAttribs
++] = WGL_PIXEL_TYPE_ARB
;
4772 attribs
[nAttribs
++] = WGL_DOUBLE_BUFFER_ARB
;
4773 attribs
[nAttribs
++] = WGL_AUX_BUFFERS_ARB
;
4775 for (iPixelFormat
=1; iPixelFormat
<= adapter
->nCfgs
; ++iPixelFormat
)
4777 res
= GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, nAttribs
, attribs
, values
));
4782 /* Cache the pixel format */
4783 cfgs
->iPixelFormat
= iPixelFormat
;
4784 cfgs
->redSize
= values
[0];
4785 cfgs
->greenSize
= values
[1];
4786 cfgs
->blueSize
= values
[2];
4787 cfgs
->alphaSize
= values
[3];
4788 cfgs
->depthSize
= values
[4];
4789 cfgs
->stencilSize
= values
[5];
4790 cfgs
->windowDrawable
= values
[6];
4791 cfgs
->iPixelType
= values
[7];
4792 cfgs
->doubleBuffer
= values
[8];
4793 cfgs
->auxBuffers
= values
[9];
4795 cfgs
->pbufferDrawable
= FALSE
;
4796 /* Check for pbuffer support when it is around as
4797 * wglGetPixelFormatAttribiv fails for unknown attributes. */
4798 if (gl_info
->supported
[WGL_ARB_PBUFFER
])
4800 int attrib
= WGL_DRAW_TO_PBUFFER_ARB
;
4802 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, 1, &attrib
, &value
)))
4803 cfgs
->pbufferDrawable
= value
;
4806 cfgs
->numSamples
= 0;
4807 /* Check multisample support */
4808 if (gl_info
->supported
[ARB_MULTISAMPLE
])
4810 int attrib
[2] = {WGL_SAMPLE_BUFFERS_ARB
, WGL_SAMPLES_ARB
};
4812 if(GL_EXTCALL(wglGetPixelFormatAttribivARB(hdc
, iPixelFormat
, 0, 2, attrib
, value
))) {
4813 /* value[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether multisampling is supported.
4814 * value[1] = number of multi sample buffers*/
4816 cfgs
->numSamples
= value
[1];
4820 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
);
4826 int nCfgs
= DescribePixelFormat(hdc
, 0, 0, 0);
4827 adapter
->cfgs
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, nCfgs
*sizeof(WineD3D_PixelFormat
));
4828 adapter
->nCfgs
= 0; /* We won't accept all formats e.g. software accelerated ones will be skipped */
4830 cfgs
= adapter
->cfgs
;
4831 for(iPixelFormat
=1; iPixelFormat
<=nCfgs
; iPixelFormat
++)
4833 PIXELFORMATDESCRIPTOR ppfd
;
4835 res
= DescribePixelFormat(hdc
, iPixelFormat
, sizeof(PIXELFORMATDESCRIPTOR
), &ppfd
);
4839 /* We only want HW acceleration using an OpenGL ICD driver.
4840 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering
4841 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD driver (e.g. 3dfx minigl)
4843 if(ppfd
.dwFlags
& (PFD_GENERIC_FORMAT
| PFD_GENERIC_ACCELERATED
))
4845 TRACE("Skipping iPixelFormat=%d because it isn't ICD accelerated\n", iPixelFormat
);
4849 cfgs
->iPixelFormat
= iPixelFormat
;
4850 cfgs
->redSize
= ppfd
.cRedBits
;
4851 cfgs
->greenSize
= ppfd
.cGreenBits
;
4852 cfgs
->blueSize
= ppfd
.cBlueBits
;
4853 cfgs
->alphaSize
= ppfd
.cAlphaBits
;
4854 cfgs
->depthSize
= ppfd
.cDepthBits
;
4855 cfgs
->stencilSize
= ppfd
.cStencilBits
;
4856 cfgs
->pbufferDrawable
= 0;
4857 cfgs
->windowDrawable
= (ppfd
.dwFlags
& PFD_DRAW_TO_WINDOW
) ? 1 : 0;
4858 cfgs
->iPixelType
= (ppfd
.iPixelType
== PFD_TYPE_RGBA
) ? WGL_TYPE_RGBA_ARB
: WGL_TYPE_COLORINDEX_ARB
;
4859 cfgs
->doubleBuffer
= (ppfd
.dwFlags
& PFD_DOUBLEBUFFER
) ? 1 : 0;
4860 cfgs
->auxBuffers
= ppfd
.cAuxBuffers
;
4861 cfgs
->numSamples
= 0;
4863 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
);
4868 /* 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 */
4871 ERR("Disabling Direct3D because no hardware accelerated pixel formats have been found!\n");
4873 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4874 HeapFree(GetProcessHeap(), 0, adapter
->cfgs
);
4879 /* D16, D24X8 and D24S8 are common depth / depth+stencil formats. All drivers support them though this doesn't
4880 * mean that the format is offered in hardware. For instance Geforce8 cards don't have offer D16 in hardware
4881 * but just fake it using D24(X8?) which is fine. D3D also allows that.
4882 * Some display drivers (i915 on Linux) only report mixed depth+stencil formats like D24S8. MSDN clearly mentions
4883 * that only on lockable formats (e.g. D16_locked) the bit order is guaranteed and that on other formats the
4884 * driver is allowed to consume more bits EXCEPT for stencil bits.
4886 * Mark an adapter with this broken stencil behavior.
4888 adapter
->brokenStencil
= TRUE
;
4889 for (i
= 0, cfgs
= adapter
->cfgs
; i
< adapter
->nCfgs
; ++i
)
4891 /* Nearly all drivers offer depth formats without stencil, only on i915 this if-statement won't be entered. */
4892 if(cfgs
[i
].depthSize
&& !cfgs
[i
].stencilSize
) {
4893 adapter
->brokenStencil
= FALSE
;
4898 WineD3D_ReleaseFakeGLContext(&fake_gl_ctx
);
4900 select_shader_mode(&adapter
->gl_info
, &ps_selected_mode
, &vs_selected_mode
);
4901 fillGLAttribFuncs(&adapter
->gl_info
);
4902 adapter
->opengl
= TRUE
;
4904 This
->adapter_count
= 1;
4905 TRACE("%u adapters successfully initialized\n", This
->adapter_count
);
4910 /* Initialize an adapter for ddraw-only memory counting */
4911 memset(This
->adapters
, 0, sizeof(This
->adapters
));
4912 This
->adapters
[0].ordinal
= 0;
4913 This
->adapters
[0].opengl
= FALSE
;
4914 This
->adapters
[0].monitorPoint
.x
= -1;
4915 This
->adapters
[0].monitorPoint
.y
= -1;
4917 This
->adapters
[0].driver_info
.name
= "Display";
4918 This
->adapters
[0].driver_info
.description
= "WineD3D DirectDraw Emulation";
4919 if(wined3d_settings
.emulated_textureram
) {
4920 This
->adapters
[0].TextureRam
= wined3d_settings
.emulated_textureram
;
4922 This
->adapters
[0].TextureRam
= 8 * 1024 * 1024; /* This is plenty for a DDraw-only card */
4925 initPixelFormatsNoGL(&This
->adapters
[0].gl_info
);
4927 This
->adapter_count
= 1;
4931 /**********************************************************
4932 * IWineD3D VTbl follows
4933 **********************************************************/
4935 const IWineD3DVtbl IWineD3D_Vtbl
=
4938 IWineD3DImpl_QueryInterface
,
4939 IWineD3DImpl_AddRef
,
4940 IWineD3DImpl_Release
,
4942 IWineD3DImpl_GetParent
,
4943 IWineD3DImpl_GetAdapterCount
,
4944 IWineD3DImpl_RegisterSoftwareDevice
,
4945 IWineD3DImpl_GetAdapterMonitor
,
4946 IWineD3DImpl_GetAdapterModeCount
,
4947 IWineD3DImpl_EnumAdapterModes
,
4948 IWineD3DImpl_GetAdapterDisplayMode
,
4949 IWineD3DImpl_GetAdapterIdentifier
,
4950 IWineD3DImpl_CheckDeviceMultiSampleType
,
4951 IWineD3DImpl_CheckDepthStencilMatch
,
4952 IWineD3DImpl_CheckDeviceType
,
4953 IWineD3DImpl_CheckDeviceFormat
,
4954 IWineD3DImpl_CheckDeviceFormatConversion
,
4955 IWineD3DImpl_GetDeviceCaps
,
4956 IWineD3DImpl_CreateDevice
4959 static void STDMETHODCALLTYPE
wined3d_null_wined3d_object_destroyed(void *parent
) {}
4961 const struct wined3d_parent_ops wined3d_null_parent_ops
=
4963 wined3d_null_wined3d_object_destroyed
,