1 /* 2 * Copyright 2002-2004 Jason Edmeades 3 * Copyright 2003-2004 Raphael Junqueira 4 * Copyright 2004 Christian Costa 5 * Copyright 2005 Oliver Stieber 6 * Copyright 2007-2008 Stefan Dösinger for CodeWeavers 7 * Copyright 2009-2011 Henri Verbeet for CodeWeavers 8 * 9 * This library is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU Lesser General Public 11 * License as published by the Free Software Foundation; either 12 * version 2.1 of the License, or (at your option) any later version. 13 * 14 * This library is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 17 * Lesser General Public License for more details. 18 * 19 * You should have received a copy of the GNU Lesser General Public 20 * License along with this library; if not, write to the Free Software 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 22 */ 23 24 #include "config.h" 25 #include "wine/port.h" 26 27 #include <stdio.h> 28 29 #include "wined3d_private.h" 30 #include "wine/winternl.h" 31 32 WINE_DEFAULT_DEBUG_CHANNEL(d3d); 33 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf); 34 WINE_DECLARE_DEBUG_CHANNEL(winediag); 35 36 #define DEFAULT_REFRESH_RATE 0 37 38 /* The driver names reflect the lowest GPU supported 39 * by a certain driver, so DRIVER_AMD_R300 supports 40 * R3xx, R4xx and R5xx GPUs. */ 41 enum wined3d_display_driver 42 { 43 DRIVER_AMD_RAGE_128PRO, 44 DRIVER_AMD_R100, 45 DRIVER_AMD_R300, 46 DRIVER_AMD_R600, 47 DRIVER_AMD_RX, 48 DRIVER_INTEL_GMA800, 49 DRIVER_INTEL_GMA900, 50 DRIVER_INTEL_GMA950, 51 DRIVER_INTEL_GMA3000, 52 DRIVER_INTEL_HD4000, 53 DRIVER_NVIDIA_TNT, 54 DRIVER_NVIDIA_GEFORCE2MX, 55 DRIVER_NVIDIA_GEFORCEFX, 56 DRIVER_NVIDIA_GEFORCE6, 57 DRIVER_NVIDIA_GEFORCE8, 58 DRIVER_VMWARE, 59 DRIVER_UNKNOWN 60 }; 61 62 enum wined3d_driver_model 63 { 64 DRIVER_MODEL_GENERIC, 65 DRIVER_MODEL_WIN9X, 66 DRIVER_MODEL_NT40, 67 DRIVER_MODEL_NT5X, 68 DRIVER_MODEL_NT6X 69 }; 70 71 enum wined3d_gl_vendor 72 { 73 GL_VENDOR_UNKNOWN, 74 GL_VENDOR_APPLE, 75 GL_VENDOR_FGLRX, 76 GL_VENDOR_MESA, 77 GL_VENDOR_NVIDIA, 78 }; 79 80 enum wined3d_d3d_level 81 { 82 WINED3D_D3D_LEVEL_5, 83 WINED3D_D3D_LEVEL_6, 84 WINED3D_D3D_LEVEL_7, 85 WINED3D_D3D_LEVEL_8, 86 WINED3D_D3D_LEVEL_9_SM2, 87 WINED3D_D3D_LEVEL_9_SM3, 88 WINED3D_D3D_LEVEL_10, 89 WINED3D_D3D_LEVEL_11, 90 WINED3D_D3D_LEVEL_COUNT 91 }; 92 93 /* The d3d device ID */ 94 static const GUID IID_D3DDEVICE_D3DUID = { 0xaeb2cdd4, 0x6e41, 0x43ea, { 0x94,0x1c,0x83,0x61,0xcc,0x76,0x07,0x81 } }; 95 96 /* Extension detection */ 97 struct wined3d_extension_map 98 { 99 const char *extension_string; 100 enum wined3d_gl_extension extension; 101 }; 102 103 static const struct wined3d_extension_map gl_extension_map[] = 104 { 105 /* APPLE */ 106 {"GL_APPLE_fence", APPLE_FENCE }, 107 {"GL_APPLE_float_pixels", APPLE_FLOAT_PIXELS }, 108 {"GL_APPLE_flush_buffer_range", APPLE_FLUSH_BUFFER_RANGE }, 109 {"GL_APPLE_ycbcr_422", APPLE_YCBCR_422 }, 110 111 /* ARB */ 112 {"GL_ARB_base_instance", ARB_BASE_INSTANCE }, 113 {"GL_ARB_blend_func_extended", ARB_BLEND_FUNC_EXTENDED }, 114 {"GL_ARB_clear_buffer_object", ARB_CLEAR_BUFFER_OBJECT }, 115 {"GL_ARB_clear_texture", ARB_CLEAR_TEXTURE }, 116 {"GL_ARB_clip_control", ARB_CLIP_CONTROL }, 117 {"GL_ARB_color_buffer_float", ARB_COLOR_BUFFER_FLOAT }, 118 {"GL_ARB_compute_shader", ARB_COMPUTE_SHADER }, 119 {"GL_ARB_conservative_depth", ARB_CONSERVATIVE_DEPTH }, 120 {"GL_ARB_copy_buffer", ARB_COPY_BUFFER }, 121 {"GL_ARB_copy_image", ARB_COPY_IMAGE }, 122 {"GL_ARB_cull_distance", ARB_CULL_DISTANCE }, 123 {"GL_ARB_debug_output", ARB_DEBUG_OUTPUT }, 124 {"GL_ARB_depth_buffer_float", ARB_DEPTH_BUFFER_FLOAT }, 125 {"GL_ARB_depth_clamp", ARB_DEPTH_CLAMP }, 126 {"GL_ARB_depth_texture", ARB_DEPTH_TEXTURE }, 127 {"GL_ARB_derivative_control", ARB_DERIVATIVE_CONTROL }, 128 {"GL_ARB_draw_buffers", ARB_DRAW_BUFFERS }, 129 {"GL_ARB_draw_elements_base_vertex", ARB_DRAW_ELEMENTS_BASE_VERTEX }, 130 {"GL_ARB_draw_indirect", ARB_DRAW_INDIRECT }, 131 {"GL_ARB_draw_instanced", ARB_DRAW_INSTANCED }, 132 {"GL_ARB_ES2_compatibility", ARB_ES2_COMPATIBILITY }, 133 {"GL_ARB_ES3_compatibility", ARB_ES3_COMPATIBILITY }, 134 {"GL_ARB_explicit_attrib_location", ARB_EXPLICIT_ATTRIB_LOCATION }, 135 {"GL_ARB_fragment_coord_conventions", ARB_FRAGMENT_COORD_CONVENTIONS}, 136 {"GL_ARB_fragment_layer_viewport", ARB_FRAGMENT_LAYER_VIEWPORT }, 137 {"GL_ARB_fragment_program", ARB_FRAGMENT_PROGRAM }, 138 {"GL_ARB_fragment_shader", ARB_FRAGMENT_SHADER }, 139 {"GL_ARB_framebuffer_no_attachments", ARB_FRAMEBUFFER_NO_ATTACHMENTS}, 140 {"GL_ARB_framebuffer_object", ARB_FRAMEBUFFER_OBJECT }, 141 {"GL_ARB_framebuffer_sRGB", ARB_FRAMEBUFFER_SRGB }, 142 {"GL_ARB_geometry_shader4", ARB_GEOMETRY_SHADER4 }, 143 {"GL_ARB_gpu_shader5", ARB_GPU_SHADER5 }, 144 {"GL_ARB_half_float_pixel", ARB_HALF_FLOAT_PIXEL }, 145 {"GL_ARB_half_float_vertex", ARB_HALF_FLOAT_VERTEX }, 146 {"GL_ARB_instanced_arrays", ARB_INSTANCED_ARRAYS }, 147 {"GL_ARB_internalformat_query", ARB_INTERNALFORMAT_QUERY }, 148 {"GL_ARB_internalformat_query2", ARB_INTERNALFORMAT_QUERY2 }, 149 {"GL_ARB_map_buffer_alignment", ARB_MAP_BUFFER_ALIGNMENT }, 150 {"GL_ARB_map_buffer_range", ARB_MAP_BUFFER_RANGE }, 151 {"GL_ARB_multisample", ARB_MULTISAMPLE }, 152 {"GL_ARB_multitexture", ARB_MULTITEXTURE }, 153 {"GL_ARB_occlusion_query", ARB_OCCLUSION_QUERY }, 154 {"GL_ARB_pipeline_statistics_query", ARB_PIPELINE_STATISTICS_QUERY }, 155 {"GL_ARB_pixel_buffer_object", ARB_PIXEL_BUFFER_OBJECT }, 156 {"GL_ARB_point_parameters", ARB_POINT_PARAMETERS }, 157 {"GL_ARB_point_sprite", ARB_POINT_SPRITE }, 158 {"GL_ARB_provoking_vertex", ARB_PROVOKING_VERTEX }, 159 {"GL_ARB_sampler_objects", ARB_SAMPLER_OBJECTS }, 160 {"GL_ARB_seamless_cube_map", ARB_SEAMLESS_CUBE_MAP }, 161 {"GL_ARB_shader_atomic_counters", ARB_SHADER_ATOMIC_COUNTERS }, 162 {"GL_ARB_shader_bit_encoding", ARB_SHADER_BIT_ENCODING }, 163 {"GL_ARB_shader_image_load_store", ARB_SHADER_IMAGE_LOAD_STORE }, 164 {"GL_ARB_shader_image_size", ARB_SHADER_IMAGE_SIZE }, 165 {"GL_ARB_shader_storage_buffer_object", ARB_SHADER_STORAGE_BUFFER_OBJECT}, 166 {"GL_ARB_shader_texture_lod", ARB_SHADER_TEXTURE_LOD }, 167 {"GL_ARB_shading_language_100", ARB_SHADING_LANGUAGE_100 }, 168 {"GL_ARB_shading_language_420pack", ARB_SHADING_LANGUAGE_420PACK }, 169 {"GL_ARB_shading_language_packing", ARB_SHADING_LANGUAGE_PACKING }, 170 {"GL_ARB_shadow", ARB_SHADOW }, 171 {"GL_ARB_stencil_texturing", ARB_STENCIL_TEXTURING }, 172 {"GL_ARB_sync", ARB_SYNC }, 173 {"GL_ARB_tessellation_shader", ARB_TESSELLATION_SHADER }, 174 {"GL_ARB_texture_border_clamp", ARB_TEXTURE_BORDER_CLAMP }, 175 {"GL_ARB_texture_buffer_object", ARB_TEXTURE_BUFFER_OBJECT }, 176 {"GL_ARB_texture_buffer_range", ARB_TEXTURE_BUFFER_RANGE }, 177 {"GL_ARB_texture_compression", ARB_TEXTURE_COMPRESSION }, 178 {"GL_ARB_texture_compression_bptc", ARB_TEXTURE_COMPRESSION_BPTC }, 179 {"GL_ARB_texture_compression_rgtc", ARB_TEXTURE_COMPRESSION_RGTC }, 180 {"GL_ARB_texture_cube_map", ARB_TEXTURE_CUBE_MAP }, 181 {"GL_ARB_texture_cube_map_array", ARB_TEXTURE_CUBE_MAP_ARRAY }, 182 {"GL_ARB_texture_env_combine", ARB_TEXTURE_ENV_COMBINE }, 183 {"GL_ARB_texture_env_dot3", ARB_TEXTURE_ENV_DOT3 }, 184 {"GL_ARB_texture_filter_anisotropic", ARB_TEXTURE_FILTER_ANISOTROPIC}, 185 {"GL_ARB_texture_float", ARB_TEXTURE_FLOAT }, 186 {"GL_ARB_texture_gather", ARB_TEXTURE_GATHER }, 187 {"GL_ARB_texture_mirrored_repeat", ARB_TEXTURE_MIRRORED_REPEAT }, 188 {"GL_ARB_texture_mirror_clamp_to_edge", ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE}, 189 {"GL_ARB_texture_multisample", ARB_TEXTURE_MULTISAMPLE }, 190 {"GL_ARB_texture_non_power_of_two", ARB_TEXTURE_NON_POWER_OF_TWO }, 191 {"GL_ARB_texture_query_levels", ARB_TEXTURE_QUERY_LEVELS }, 192 {"GL_ARB_texture_rectangle", ARB_TEXTURE_RECTANGLE }, 193 {"GL_ARB_texture_rg", ARB_TEXTURE_RG }, 194 {"GL_ARB_texture_rgb10_a2ui", ARB_TEXTURE_RGB10_A2UI }, 195 {"GL_ARB_texture_storage", ARB_TEXTURE_STORAGE }, 196 {"GL_ARB_texture_storage_multisample", ARB_TEXTURE_STORAGE_MULTISAMPLE}, 197 {"GL_ARB_texture_swizzle", ARB_TEXTURE_SWIZZLE }, 198 {"GL_ARB_texture_view", ARB_TEXTURE_VIEW }, 199 {"GL_ARB_timer_query", ARB_TIMER_QUERY }, 200 {"GL_ARB_transform_feedback2", ARB_TRANSFORM_FEEDBACK2 }, 201 {"GL_ARB_transform_feedback3", ARB_TRANSFORM_FEEDBACK3 }, 202 {"GL_ARB_uniform_buffer_object", ARB_UNIFORM_BUFFER_OBJECT }, 203 {"GL_ARB_vertex_array_bgra", ARB_VERTEX_ARRAY_BGRA }, 204 {"GL_ARB_vertex_blend", ARB_VERTEX_BLEND }, 205 {"GL_ARB_vertex_buffer_object", ARB_VERTEX_BUFFER_OBJECT }, 206 {"GL_ARB_vertex_program", ARB_VERTEX_PROGRAM }, 207 {"GL_ARB_vertex_shader", ARB_VERTEX_SHADER }, 208 {"GL_ARB_vertex_type_2_10_10_10_rev", ARB_VERTEX_TYPE_2_10_10_10_REV}, 209 {"GL_ARB_viewport_array", ARB_VIEWPORT_ARRAY }, 210 211 /* ATI */ 212 {"GL_ATI_fragment_shader", ATI_FRAGMENT_SHADER }, 213 {"GL_ATI_separate_stencil", ATI_SEPARATE_STENCIL }, 214 {"GL_ATI_texture_compression_3dc", ATI_TEXTURE_COMPRESSION_3DC }, 215 {"GL_ATI_texture_env_combine3", ATI_TEXTURE_ENV_COMBINE3 }, 216 {"GL_ATI_texture_mirror_once", ATI_TEXTURE_MIRROR_ONCE }, 217 218 /* EXT */ 219 {"GL_EXT_blend_color", EXT_BLEND_COLOR }, 220 {"GL_EXT_blend_equation_separate", EXT_BLEND_EQUATION_SEPARATE }, 221 {"GL_EXT_blend_func_separate", EXT_BLEND_FUNC_SEPARATE }, 222 {"GL_EXT_blend_minmax", EXT_BLEND_MINMAX }, 223 {"GL_EXT_blend_subtract", EXT_BLEND_SUBTRACT }, 224 {"GL_EXT_depth_bounds_test", EXT_DEPTH_BOUNDS_TEST }, 225 {"GL_EXT_draw_buffers2", EXT_DRAW_BUFFERS2 }, 226 {"GL_EXT_fog_coord", EXT_FOG_COORD }, 227 {"GL_EXT_framebuffer_blit", EXT_FRAMEBUFFER_BLIT }, 228 {"GL_EXT_framebuffer_multisample", EXT_FRAMEBUFFER_MULTISAMPLE }, 229 {"GL_EXT_framebuffer_object", EXT_FRAMEBUFFER_OBJECT }, 230 {"GL_EXT_gpu_program_parameters", EXT_GPU_PROGRAM_PARAMETERS }, 231 {"GL_EXT_gpu_shader4", EXT_GPU_SHADER4 }, 232 {"GL_EXT_packed_depth_stencil", EXT_PACKED_DEPTH_STENCIL }, 233 {"GL_EXT_packed_float", EXT_PACKED_FLOAT }, 234 {"GL_EXT_point_parameters", EXT_POINT_PARAMETERS }, 235 {"GL_EXT_polygon_offset_clamp", EXT_POLYGON_OFFSET_CLAMP }, 236 {"GL_EXT_provoking_vertex", EXT_PROVOKING_VERTEX }, 237 {"GL_EXT_secondary_color", EXT_SECONDARY_COLOR }, 238 {"GL_EXT_stencil_two_side", EXT_STENCIL_TWO_SIDE }, 239 {"GL_EXT_stencil_wrap", EXT_STENCIL_WRAP }, 240 {"GL_EXT_texture3D", EXT_TEXTURE3D }, 241 {"GL_EXT_texture_array", EXT_TEXTURE_ARRAY }, 242 {"GL_EXT_texture_compression_rgtc", EXT_TEXTURE_COMPRESSION_RGTC }, 243 {"GL_EXT_texture_compression_s3tc", EXT_TEXTURE_COMPRESSION_S3TC }, 244 {"GL_EXT_texture_env_combine", EXT_TEXTURE_ENV_COMBINE }, 245 {"GL_EXT_texture_env_dot3", EXT_TEXTURE_ENV_DOT3 }, 246 {"GL_EXT_texture_filter_anisotropic", ARB_TEXTURE_FILTER_ANISOTROPIC}, 247 {"GL_EXT_texture_integer", EXT_TEXTURE_INTEGER }, 248 {"GL_EXT_texture_lod_bias", EXT_TEXTURE_LOD_BIAS }, 249 {"GL_EXT_texture_mirror_clamp", EXT_TEXTURE_MIRROR_CLAMP }, 250 {"GL_EXT_texture_shared_exponent", EXT_TEXTURE_SHARED_EXPONENT }, 251 {"GL_EXT_texture_snorm", EXT_TEXTURE_SNORM }, 252 {"GL_EXT_texture_sRGB", EXT_TEXTURE_SRGB }, 253 {"GL_EXT_texture_sRGB_decode", EXT_TEXTURE_SRGB_DECODE }, 254 {"GL_EXT_vertex_array_bgra", EXT_VERTEX_ARRAY_BGRA }, 255 256 /* NV */ 257 {"GL_NV_fence", NV_FENCE }, 258 {"GL_NV_fog_distance", NV_FOG_DISTANCE }, 259 {"GL_NV_fragment_program", NV_FRAGMENT_PROGRAM }, 260 {"GL_NV_fragment_program2", NV_FRAGMENT_PROGRAM2 }, 261 {"GL_NV_fragment_program_option", NV_FRAGMENT_PROGRAM_OPTION }, 262 {"GL_NV_half_float", NV_HALF_FLOAT }, 263 {"GL_NV_light_max_exponent", NV_LIGHT_MAX_EXPONENT }, 264 {"GL_NV_point_sprite", NV_POINT_SPRITE }, 265 {"GL_NV_register_combiners", NV_REGISTER_COMBINERS }, 266 {"GL_NV_register_combiners2", NV_REGISTER_COMBINERS2 }, 267 {"GL_NV_texgen_reflection", NV_TEXGEN_REFLECTION }, 268 {"GL_NV_texture_env_combine4", NV_TEXTURE_ENV_COMBINE4 }, 269 {"GL_NV_texture_shader", NV_TEXTURE_SHADER }, 270 {"GL_NV_texture_shader2", NV_TEXTURE_SHADER2 }, 271 {"GL_NV_vertex_program", NV_VERTEX_PROGRAM }, 272 {"GL_NV_vertex_program1_1", NV_VERTEX_PROGRAM1_1 }, 273 {"GL_NV_vertex_program2", NV_VERTEX_PROGRAM2 }, 274 {"GL_NV_vertex_program2_option", NV_VERTEX_PROGRAM2_OPTION }, 275 {"GL_NV_vertex_program3", NV_VERTEX_PROGRAM3 }, 276 {"GL_NVX_gpu_memory_info", NVX_GPU_MEMORY_INFO }, 277 }; 278 279 static const struct wined3d_extension_map wgl_extension_map[] = 280 { 281 {"WGL_ARB_pixel_format", WGL_ARB_PIXEL_FORMAT }, 282 {"WGL_EXT_swap_control", WGL_EXT_SWAP_CONTROL }, 283 {"WGL_WINE_pixel_format_passthrough", WGL_WINE_PIXEL_FORMAT_PASSTHROUGH}, 284 {"WGL_WINE_query_renderer", WGL_WINE_QUERY_RENDERER }, 285 }; 286 287 /********************************************************** 288 * Utility functions follow 289 **********************************************************/ 290 291 const struct min_lookup minMipLookup[] = 292 { 293 /* NONE POINT LINEAR */ 294 {{GL_NEAREST, GL_NEAREST, GL_NEAREST}}, /* NONE */ 295 {{GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST, GL_NEAREST_MIPMAP_LINEAR}}, /* POINT*/ 296 {{GL_LINEAR, GL_LINEAR_MIPMAP_NEAREST, GL_LINEAR_MIPMAP_LINEAR}}, /* LINEAR */ 297 }; 298 299 const GLenum magLookup[] = 300 { 301 /* NONE POINT LINEAR */ 302 GL_NEAREST, GL_NEAREST, GL_LINEAR, 303 }; 304 305 static void wined3d_caps_gl_ctx_destroy(const struct wined3d_caps_gl_ctx *ctx) 306 { 307 const struct wined3d_gl_info *gl_info = ctx->gl_info; 308 309 TRACE("Destroying caps GL context.\n"); 310 311 /* Both glDeleteProgram and glDeleteBuffers silently ignore 0 IDs but 312 * this function might be called before the relevant function pointers 313 * in gl_info are initialized. */ 314 if (ctx->test_program_id || ctx->test_vbo) 315 { 316 GL_EXTCALL(glDeleteProgram(ctx->test_program_id)); 317 GL_EXTCALL(glDeleteBuffers(1, &ctx->test_vbo)); 318 } 319 320 if (!wglMakeCurrent(NULL, NULL)) 321 ERR("Failed to disable caps GL context.\n"); 322 323 if (!wglDeleteContext(ctx->gl_ctx)) 324 { 325 DWORD err = GetLastError(); 326 ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx->gl_ctx, err); 327 } 328 329 wined3d_release_dc(ctx->wnd, ctx->dc); 330 DestroyWindow(ctx->wnd); 331 332 if (ctx->restore_gl_ctx && !wglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx)) 333 ERR("Failed to restore previous GL context.\n"); 334 } 335 336 static BOOL wined3d_caps_gl_ctx_create_attribs(struct wined3d_caps_gl_ctx *caps_gl_ctx, 337 struct wined3d_gl_info *gl_info) 338 { 339 HGLRC new_ctx; 340 341 if (!(gl_info->p_wglCreateContextAttribsARB = (void *)wglGetProcAddress("wglCreateContextAttribsARB"))) 342 return TRUE; 343 344 if (!(new_ctx = context_create_wgl_attribs(gl_info, caps_gl_ctx->dc, NULL))) 345 { 346 gl_info->p_wglCreateContextAttribsARB = NULL; 347 return FALSE; 348 } 349 350 if (!wglMakeCurrent(caps_gl_ctx->dc, new_ctx)) 351 { 352 ERR("Failed to make new context current, last error %#x.\n", GetLastError()); 353 if (!wglDeleteContext(new_ctx)) 354 ERR("Failed to delete new context, last error %#x.\n", GetLastError()); 355 gl_info->p_wglCreateContextAttribsARB = NULL; 356 return TRUE; 357 } 358 359 if (!wglDeleteContext(caps_gl_ctx->gl_ctx)) 360 ERR("Failed to delete old context, last error %#x.\n", GetLastError()); 361 caps_gl_ctx->gl_ctx = new_ctx; 362 363 return TRUE; 364 } 365 366 static BOOL wined3d_caps_gl_ctx_create(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx) 367 { 368 PIXELFORMATDESCRIPTOR pfd; 369 int iPixelFormat; 370 371 TRACE("getting context...\n"); 372 373 ctx->restore_dc = wglGetCurrentDC(); 374 ctx->restore_gl_ctx = wglGetCurrentContext(); 375 376 /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */ 377 ctx->wnd = CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME, "WineD3D fake window", 378 WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL); 379 if (!ctx->wnd) 380 { 381 ERR("Failed to create a window.\n"); 382 goto fail; 383 } 384 385 ctx->dc = GetDC(ctx->wnd); 386 if (!ctx->dc) 387 { 388 ERR("Failed to get a DC.\n"); 389 goto fail; 390 } 391 392 /* PixelFormat selection */ 393 ZeroMemory(&pfd, sizeof(pfd)); 394 pfd.nSize = sizeof(pfd); 395 pfd.nVersion = 1; 396 pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */ 397 pfd.iPixelType = PFD_TYPE_RGBA; 398 pfd.cColorBits = 32; 399 pfd.iLayerType = PFD_MAIN_PLANE; 400 401 if (!(iPixelFormat = ChoosePixelFormat(ctx->dc, &pfd))) 402 { 403 /* If this happens something is very wrong as ChoosePixelFormat barely fails. */ 404 ERR("Failed to find a suitable pixel format.\n"); 405 goto fail; 406 } 407 DescribePixelFormat(ctx->dc, iPixelFormat, sizeof(pfd), &pfd); 408 SetPixelFormat(ctx->dc, iPixelFormat, &pfd); 409 410 /* Create a GL context. */ 411 if (!(ctx->gl_ctx = wglCreateContext(ctx->dc))) 412 { 413 WARN("Failed to create default context for capabilities initialization.\n"); 414 goto fail; 415 } 416 417 /* Make it the current GL context. */ 418 if (!wglMakeCurrent(ctx->dc, ctx->gl_ctx)) 419 { 420 ERR("Failed to make caps GL context current.\n"); 421 goto fail; 422 } 423 424 ctx->gl_info = &adapter->gl_info; 425 return TRUE; 426 427 fail: 428 if (ctx->gl_ctx) wglDeleteContext(ctx->gl_ctx); 429 ctx->gl_ctx = NULL; 430 if (ctx->dc) ReleaseDC(ctx->wnd, ctx->dc); 431 ctx->dc = NULL; 432 if (ctx->wnd) DestroyWindow(ctx->wnd); 433 ctx->wnd = NULL; 434 if (ctx->restore_gl_ctx && !wglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx)) 435 ERR("Failed to restore previous GL context.\n"); 436 437 return FALSE; 438 } 439 440 /* Adjust the amount of used texture memory */ 441 UINT64 adapter_adjust_memory(struct wined3d_adapter *adapter, INT64 amount) 442 { 443 adapter->vram_bytes_used += amount; 444 TRACE("Adjusted used adapter memory by 0x%s to 0x%s.\n", 445 wine_dbgstr_longlong(amount), 446 wine_dbgstr_longlong(adapter->vram_bytes_used)); 447 return adapter->vram_bytes_used; 448 } 449 450 static void wined3d_adapter_cleanup(struct wined3d_adapter *adapter) 451 { 452 heap_free(adapter->gl_info.formats); 453 heap_free(adapter->cfgs); 454 } 455 456 ULONG CDECL wined3d_incref(struct wined3d *wined3d) 457 { 458 ULONG refcount = InterlockedIncrement(&wined3d->ref); 459 460 TRACE("%p increasing refcount to %u.\n", wined3d, refcount); 461 462 return refcount; 463 } 464 465 ULONG CDECL wined3d_decref(struct wined3d *wined3d) 466 { 467 ULONG refcount = InterlockedDecrement(&wined3d->ref); 468 469 TRACE("%p decreasing refcount to %u.\n", wined3d, refcount); 470 471 if (!refcount) 472 { 473 unsigned int i; 474 475 for (i = 0; i < wined3d->adapter_count; ++i) 476 { 477 wined3d_adapter_cleanup(&wined3d->adapters[i]); 478 } 479 heap_free(wined3d); 480 } 481 482 return refcount; 483 } 484 485 /* Context activation is done by the caller. */ 486 static BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info) 487 { 488 GLuint prog; 489 BOOL ret = FALSE; 490 static const char testcode[] = 491 "!!ARBvp1.0\n" 492 "PARAM C[66] = { program.env[0..65] };\n" 493 "ADDRESS A0;" 494 "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n" 495 "ARL A0.x, zero.x;\n" 496 "MOV result.position, C[A0.x + 65];\n" 497 "END\n"; 498 499 while (gl_info->gl_ops.gl.p_glGetError()); 500 GL_EXTCALL(glGenProgramsARB(1, &prog)); 501 if(!prog) { 502 ERR("Failed to create an ARB offset limit test program\n"); 503 } 504 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog)); 505 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, 506 strlen(testcode), testcode)); 507 if (gl_info->gl_ops.gl.p_glGetError()) 508 { 509 TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n"); 510 TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB))); 511 ret = TRUE; 512 } else TRACE("OpenGL implementation allows offsets > 63\n"); 513 514 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0)); 515 GL_EXTCALL(glDeleteProgramsARB(1, &prog)); 516 checkGLcall("ARB vp offset limit test cleanup"); 517 518 return ret; 519 } 520 521 static BOOL match_amd_r300_to_500(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 522 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 523 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 524 { 525 if (card_vendor != HW_VENDOR_AMD) return FALSE; 526 if (device == CARD_AMD_RADEON_9500) return TRUE; 527 if (device == CARD_AMD_RADEON_X700) return TRUE; 528 if (device == CARD_AMD_RADEON_X1600) return TRUE; 529 return FALSE; 530 } 531 532 static BOOL match_geforce5(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 533 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 534 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 535 { 536 if (card_vendor == HW_VENDOR_NVIDIA) 537 { 538 if (device == CARD_NVIDIA_GEFORCEFX_5200 || 539 device == CARD_NVIDIA_GEFORCEFX_5600 || 540 device == CARD_NVIDIA_GEFORCEFX_5800) 541 { 542 return TRUE; 543 } 544 } 545 return FALSE; 546 } 547 548 static BOOL match_apple(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 549 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 550 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 551 { 552 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from 553 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to 554 * detect the Apple OpenGL implementation to apply some extension fixups afterwards. 555 * 556 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks 557 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11. 558 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions 559 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render 560 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So 561 * the chance that other implementations support them is rather small since Win32 QuickTime uses 562 * DirectDraw, not OpenGL. 563 * 564 * This test has been moved into wined3d_guess_gl_vendor() 565 */ 566 return gl_vendor == GL_VENDOR_APPLE; 567 } 568 569 /* Context activation is done by the caller. */ 570 static void test_pbo_functionality(struct wined3d_gl_info *gl_info) 571 { 572 /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs, 573 * but glTexSubImage from a PBO fails miserably, with the first line repeated over 574 * all the texture. This function detects this bug by its symptom and disables PBOs 575 * if the test fails. 576 * 577 * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA, 578 * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use 579 * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data 580 * read back is compared to the original. If they are equal PBOs are assumed to work, 581 * otherwise the PBO extension is disabled. */ 582 GLuint texture, pbo; 583 static const unsigned int pattern[] = 584 { 585 0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000, 586 0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff, 587 0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff, 588 0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff 589 }; 590 unsigned int check[ARRAY_SIZE(pattern)]; 591 592 /* No PBO -> No point in testing them. */ 593 if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return; 594 595 while (gl_info->gl_ops.gl.p_glGetError()); 596 gl_info->gl_ops.gl.p_glGenTextures(1, &texture); 597 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, texture); 598 599 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0); 600 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, 0); 601 checkGLcall("Specifying the PBO test texture"); 602 603 GL_EXTCALL(glGenBuffers(1, &pbo)); 604 GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo)); 605 GL_EXTCALL(glBufferData(GL_PIXEL_UNPACK_BUFFER, sizeof(pattern), pattern, GL_STREAM_DRAW)); 606 checkGLcall("Specifying the PBO test pbo"); 607 608 gl_info->gl_ops.gl.p_glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); 609 checkGLcall("Loading the PBO test texture"); 610 611 GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0)); 612 613 gl_info->gl_ops.gl.p_glFinish(); /* just to be sure */ 614 615 memset(check, 0, sizeof(check)); 616 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check); 617 checkGLcall("Reading back the PBO test texture"); 618 619 gl_info->gl_ops.gl.p_glDeleteTextures(1, &texture); 620 GL_EXTCALL(glDeleteBuffers(1, &pbo)); 621 checkGLcall("PBO test cleanup"); 622 623 if (memcmp(check, pattern, sizeof(check))) 624 { 625 WARN_(d3d_perf)("PBO test failed, read back data doesn't match original.\n" 626 "Disabling PBOs. This may result in slower performance.\n"); 627 gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE; 628 } 629 else 630 { 631 TRACE("PBO test successful.\n"); 632 } 633 } 634 635 static BOOL match_apple_intel(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 636 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 637 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 638 { 639 return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE); 640 } 641 642 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 643 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 644 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 645 { 646 if (gl_vendor != GL_VENDOR_APPLE) return FALSE; 647 if (card_vendor != HW_VENDOR_AMD) return FALSE; 648 if (device == CARD_AMD_RADEON_X1600) return FALSE; 649 return TRUE; 650 } 651 652 static BOOL match_dx10_capable(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 653 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 654 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 655 { 656 /* DX9 cards support 40 single float varyings in hardware, most drivers report 32. ATI misreports 657 * 44 varyings. So assume that if we have more than 44 varyings we have a dx10 card. 658 * This detection is for the gl_ClipPos varying quirk. If a d3d9 card really supports more than 44 659 * varyings and we subtract one in dx9 shaders it's not going to hurt us because the dx9 limit is 660 * hardcoded 661 * 662 * dx10 cards usually have 64 varyings */ 663 return gl_info->limits.glsl_varyings > 44; 664 } 665 666 static BOOL match_not_dx10_capable(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 667 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 668 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 669 { 670 return !match_dx10_capable(gl_info, ctx, gl_renderer, gl_vendor, card_vendor, device); 671 } 672 673 /* A GL context is provided by the caller */ 674 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 675 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 676 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 677 { 678 GLenum error; 679 DWORD data[16]; 680 681 if (!gl_info->supported[EXT_SECONDARY_COLOR]) 682 return FALSE; 683 684 while (gl_info->gl_ops.gl.p_glGetError()); 685 GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data); 686 error = gl_info->gl_ops.gl.p_glGetError(); 687 688 if (error == GL_NO_ERROR) 689 { 690 TRACE("GL Implementation accepts 4 component specular color pointers\n"); 691 return TRUE; 692 } 693 else 694 { 695 TRACE("GL implementation does not accept 4 component specular colors, error %s\n", 696 debug_glerror(error)); 697 return FALSE; 698 } 699 } 700 701 /* A GL context is provided by the caller */ 702 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 703 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 704 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 705 { 706 GLuint prog; 707 BOOL ret = FALSE; 708 GLint pos; 709 static const char testcode[] = 710 "!!ARBvp1.0\n" 711 "OPTION NV_vertex_program2;\n" 712 "MOV result.clip[0], 0.0;\n" 713 "MOV result.position, 0.0;\n" 714 "END\n"; 715 716 if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE; 717 718 while (gl_info->gl_ops.gl.p_glGetError()); 719 720 GL_EXTCALL(glGenProgramsARB(1, &prog)); 721 if(!prog) 722 { 723 ERR("Failed to create the NVvp clip test program\n"); 724 return FALSE; 725 } 726 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog)); 727 GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, 728 strlen(testcode), testcode)); 729 gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos); 730 if(pos != -1) 731 { 732 WARN("GL_NV_vertex_program2_option result.clip[] test failed\n"); 733 TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB))); 734 ret = TRUE; 735 while (gl_info->gl_ops.gl.p_glGetError()); 736 } 737 else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n"); 738 739 GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0)); 740 GL_EXTCALL(glDeleteProgramsARB(1, &prog)); 741 checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup"); 742 743 return ret; 744 } 745 746 /* Context activation is done by the caller. */ 747 static BOOL match_fbo_tex_update(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 748 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 749 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 750 { 751 char data[4 * 4 * 4]; 752 GLuint tex, fbo; 753 GLenum status; 754 755 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE; 756 757 memset(data, 0xcc, sizeof(data)); 758 759 gl_info->gl_ops.gl.p_glGenTextures(1, &tex); 760 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex); 761 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 762 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 763 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 4, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); 764 checkGLcall("glTexImage2D"); 765 766 gl_info->fbo_ops.glGenFramebuffers(1, &fbo); 767 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 768 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0); 769 checkGLcall("glFramebufferTexture2D"); 770 771 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER); 772 if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status); 773 checkGLcall("glCheckFramebufferStatus"); 774 775 memset(data, 0x11, sizeof(data)); 776 gl_info->gl_ops.gl.p_glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data); 777 checkGLcall("glTexSubImage2D"); 778 779 gl_info->gl_ops.gl.p_glClearColor(0.996f, 0.729f, 0.745f, 0.792f); 780 gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT); 781 checkGLcall("glClear"); 782 783 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data); 784 checkGLcall("glGetTexImage"); 785 786 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0); 787 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0); 788 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0); 789 checkGLcall("glBindTexture"); 790 791 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo); 792 gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex); 793 checkGLcall("glDeleteTextures"); 794 795 return *(DWORD *)data == 0x11111111; 796 } 797 798 /* Context activation is done by the caller. */ 799 static BOOL match_broken_rgba16(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 800 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 801 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 802 { 803 /* GL_RGBA16 uses GL_RGBA8 internally on Geforce 7 and older cards. 804 * This leads to graphical bugs in Half Life 2 and Unreal engine games. */ 805 GLuint tex; 806 GLint size; 807 808 gl_info->gl_ops.gl.p_glGenTextures(1, &tex); 809 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex); 810 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT, NULL); 811 checkGLcall("glTexImage2D"); 812 813 gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &size); 814 checkGLcall("glGetTexLevelParameteriv"); 815 TRACE("Real color depth is %d\n", size); 816 817 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0); 818 checkGLcall("glBindTexture"); 819 gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex); 820 checkGLcall("glDeleteTextures"); 821 822 return size < 16; 823 } 824 825 static BOOL match_fglrx(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 826 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 827 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 828 { 829 return gl_vendor == GL_VENDOR_FGLRX; 830 } 831 832 static BOOL match_r200(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 833 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 834 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 835 { 836 if (card_vendor != HW_VENDOR_AMD) return FALSE; 837 if (device == CARD_AMD_RADEON_8500) return TRUE; 838 return FALSE; 839 } 840 841 static BOOL match_broken_arb_fog(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 842 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 843 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 844 { 845 DWORD data[4]; 846 GLuint tex, fbo; 847 GLenum status; 848 float color[4] = {0.0f, 1.0f, 0.0f, 0.0f}; 849 GLuint prog; 850 GLint err_pos; 851 static const char program_code[] = 852 "!!ARBfp1.0\n" 853 "OPTION ARB_fog_linear;\n" 854 "MOV result.color, {1.0, 0.0, 0.0, 0.0};\n" 855 "END\n"; 856 857 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) 858 return FALSE; 859 if (!gl_info->supported[ARB_FRAGMENT_PROGRAM]) 860 return FALSE; 861 862 gl_info->gl_ops.gl.p_glGenTextures(1, &tex); 863 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex); 864 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 865 gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 866 gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB8, 4, 1, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, NULL); 867 checkGLcall("glTexImage2D"); 868 869 gl_info->fbo_ops.glGenFramebuffers(1, &fbo); 870 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo); 871 gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0); 872 checkGLcall("glFramebufferTexture2D"); 873 874 status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER); 875 if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status); 876 checkGLcall("glCheckFramebufferStatus"); 877 878 gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 1.0f, 0.0f); 879 gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT); 880 checkGLcall("glClear"); 881 gl_info->gl_ops.gl.p_glViewport(0, 0, 4, 1); 882 checkGLcall("glViewport"); 883 884 gl_info->gl_ops.gl.p_glEnable(GL_FOG); 885 gl_info->gl_ops.gl.p_glFogf(GL_FOG_START, 0.5f); 886 gl_info->gl_ops.gl.p_glFogf(GL_FOG_END, 0.5f); 887 gl_info->gl_ops.gl.p_glFogi(GL_FOG_MODE, GL_LINEAR); 888 gl_info->gl_ops.gl.p_glHint(GL_FOG_HINT, GL_NICEST); 889 gl_info->gl_ops.gl.p_glFogfv(GL_FOG_COLOR, color); 890 checkGLcall("fog setup"); 891 892 GL_EXTCALL(glGenProgramsARB(1, &prog)); 893 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog)); 894 GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, 895 strlen(program_code), program_code)); 896 gl_info->gl_ops.gl.p_glEnable(GL_FRAGMENT_PROGRAM_ARB); 897 checkGLcall("Test fragment program setup"); 898 899 gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &err_pos); 900 if (err_pos != -1) 901 { 902 const char *error_str; 903 error_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB); 904 FIXME("Fog test program error at position %d: %s\n\n", err_pos, debugstr_a(error_str)); 905 } 906 907 gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP); 908 gl_info->gl_ops.gl.p_glVertex3f(-1.0f, -1.0f, 0.0f); 909 gl_info->gl_ops.gl.p_glVertex3f( 1.0f, -1.0f, 1.0f); 910 gl_info->gl_ops.gl.p_glVertex3f(-1.0f, 1.0f, 0.0f); 911 gl_info->gl_ops.gl.p_glVertex3f( 1.0f, 1.0f, 1.0f); 912 gl_info->gl_ops.gl.p_glEnd(); 913 checkGLcall("ARBfp fog test draw"); 914 915 gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data); 916 checkGLcall("glGetTexImage"); 917 data[0] &= 0x00ffffff; 918 data[1] &= 0x00ffffff; 919 data[2] &= 0x00ffffff; 920 data[3] &= 0x00ffffff; 921 922 gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0); 923 gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0); 924 925 gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo); 926 gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex); 927 gl_info->gl_ops.gl.p_glDisable(GL_FOG); 928 GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0)); 929 gl_info->gl_ops.gl.p_glDisable(GL_FRAGMENT_PROGRAM_ARB); 930 GL_EXTCALL(glDeleteProgramsARB(1, &prog)); 931 checkGLcall("ARBfp fog test teardown"); 932 933 TRACE("Fog test data: %08x %08x %08x %08x\n", data[0], data[1], data[2], data[3]); 934 return data[0] != 0x00ff0000 || data[3] != 0x0000ff00; 935 } 936 937 static BOOL match_broken_viewport_subpixel_bits(const struct wined3d_gl_info *gl_info, 938 struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 939 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 940 { 941 if (!gl_info->supported[ARB_VIEWPORT_ARRAY]) 942 return FALSE; 943 if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) 944 return FALSE; 945 return !wined3d_caps_gl_ctx_test_viewport_subpixel_bits(ctx); 946 } 947 948 static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info) 949 { 950 /* MacOS needs uniforms for relative addressing offsets. This can accumulate to quite a few uniforms. 951 * Beyond that the general uniform isn't optimal, so reserve a number of uniforms. 12 vec4's should 952 * allow 48 different offsets or other helper immediate values. */ 953 TRACE("Reserving 12 GLSL constants for compiler private use.\n"); 954 gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12); 955 } 956 957 static void quirk_amd_dx9(struct wined3d_gl_info *gl_info) 958 { 959 /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and earlier cards, although 960 * these cards only support GL_ARB_texture_rectangle(D3DPTEXTURECAPS_NONPOW2CONDITIONAL). 961 * If real NP2 textures are used, the driver falls back to software. We could just remove the 962 * extension and use GL_ARB_texture_rectangle instead, but texture_rectangle is inconvenient 963 * due to the non-normalized texture coordinates. Thus set an internal extension flag, 964 * GL_WINE_normalized_texrect, which signals the code that it can use non power of two textures 965 * as per GL_ARB_texture_non_power_of_two, but has to stick to the texture_rectangle limits. 966 * 967 * fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it advertises opengl 2.0 which 968 * has this extension promoted to core. The extension loading code sets this extension supported 969 * due to that, so this code works on fglrx as well. */ 970 if(gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) 971 { 972 TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n"); 973 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE; 974 gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] = TRUE; 975 } 976 } 977 978 static void quirk_no_np2(struct wined3d_gl_info *gl_info) 979 { 980 /* The nVidia GeForceFX series reports OpenGL 2.0 capabilities with the latest drivers versions, but 981 * doesn't explicitly advertise the ARB_tex_npot extension in the GL extension string. 982 * This usually means that ARB_tex_npot is supported in hardware as long as the application is staying 983 * within the limits enforced by the ARB_texture_rectangle extension. This however is not true for the 984 * FX series, which instantly falls back to a slower software path as soon as ARB_tex_npot is used. 985 * We therefore completely remove ARB_tex_npot from the list of supported extensions. 986 * 987 * Note that wine_normalized_texrect can't be used in this case because internally it uses ARB_tex_npot, 988 * triggering the software fallback. There is not much we can do here apart from disabling the 989 * software-emulated extension and re-enable ARB_tex_rect (which was previously disabled 990 * in wined3d_adapter_init_gl_caps). 991 * This fixup removes performance problems on both the FX 5900 and FX 5700 (e.g. for framebuffer 992 * post-processing effects in the game "Max Payne 2"). 993 * The behaviour can be verified through a simple test app attached in bugreport #14724. */ 994 TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n"); 995 gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE; 996 gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE; 997 } 998 999 static void quirk_texcoord_w(struct wined3d_gl_info *gl_info) 1000 { 1001 /* The Intel GPUs on MacOS set the .w register of texcoords to 0.0 by default, which causes problems 1002 * with fixed function fragment processing. Ideally this flag should be detected with a test shader 1003 * and OpenGL feedback mode, but some GL implementations (MacOS ATI at least, probably all MacOS ones) 1004 * do not like vertex shaders in feedback mode and return an error, even though it should be valid 1005 * according to the spec. 1006 * 1007 * We don't want to enable this on all cards, as it adds an extra instruction per texcoord used. This 1008 * makes the shader slower and eats instruction slots which should be available to the d3d app. 1009 * 1010 * ATI Radeon HD 2xxx cards on MacOS have the issue. Instead of checking for the buggy cards, blacklist 1011 * all radeon cards on Macs and whitelist the good ones. That way we're prepared for the future. If 1012 * this workaround is activated on cards that do not need it, it won't break things, just affect 1013 * performance negatively. */ 1014 TRACE("Enabling vertex texture coord fixes in vertex shaders.\n"); 1015 gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W; 1016 } 1017 1018 static void quirk_clip_varying(struct wined3d_gl_info *gl_info) 1019 { 1020 gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING; 1021 } 1022 1023 static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info) 1024 { 1025 gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA; 1026 } 1027 1028 static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info) 1029 { 1030 gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN; 1031 } 1032 1033 static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info) 1034 { 1035 gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE; 1036 } 1037 1038 static void quirk_broken_rgba16(struct wined3d_gl_info *gl_info) 1039 { 1040 gl_info->quirks |= WINED3D_QUIRK_BROKEN_RGBA16; 1041 } 1042 1043 static void quirk_infolog_spam(struct wined3d_gl_info *gl_info) 1044 { 1045 gl_info->quirks |= WINED3D_QUIRK_INFO_LOG_SPAM; 1046 } 1047 1048 static void quirk_limited_tex_filtering(struct wined3d_gl_info *gl_info) 1049 { 1050 /* Nvidia GeForce 6xxx and 7xxx support accelerated VTF only on a few 1051 selected texture formats. They are apparently the only DX9 class GPUs 1052 supporting VTF. 1053 Also, DX9-era GPUs are somewhat limited with float textures 1054 filtering and blending. */ 1055 gl_info->quirks |= WINED3D_QUIRK_LIMITED_TEX_FILTERING; 1056 } 1057 1058 static void quirk_r200_constants(struct wined3d_gl_info *gl_info) 1059 { 1060 /* The Mesa r200 driver (and there is no other driver for this GPU Wine would run on) 1061 * loads some fog parameters (start, end, exponent, but not the color) into the 1062 * program. 1063 * 1064 * Apparently the fog hardware is only able to handle linear fog with a range of 0.0;1.0, 1065 * and it is the responsibility of the vertex pipeline to handle non-linear fog and 1066 * linear fog with start and end other than 0.0 and 1.0. */ 1067 TRACE("Reserving 1 ARB constant for compiler private use.\n"); 1068 gl_info->reserved_arb_constants = max(gl_info->reserved_arb_constants, 1); 1069 } 1070 1071 static void quirk_broken_arb_fog(struct wined3d_gl_info *gl_info) 1072 { 1073 gl_info->quirks |= WINED3D_QUIRK_BROKEN_ARB_FOG; 1074 } 1075 1076 static void quirk_broken_viewport_subpixel_bits(struct wined3d_gl_info *gl_info) 1077 { 1078 if (gl_info->supported[ARB_CLIP_CONTROL]) 1079 { 1080 TRACE("Disabling ARB_clip_control.\n"); 1081 gl_info->supported[ARB_CLIP_CONTROL] = FALSE; 1082 } 1083 } 1084 1085 struct driver_quirk 1086 { 1087 BOOL (*match)(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 1088 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 1089 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device); 1090 void (*apply)(struct wined3d_gl_info *gl_info); 1091 const char *description; 1092 }; 1093 1094 static const struct driver_quirk quirk_table[] = 1095 { 1096 { 1097 match_amd_r300_to_500, 1098 quirk_amd_dx9, 1099 "AMD normalized texrect quirk" 1100 }, 1101 { 1102 match_apple, 1103 quirk_apple_glsl_constants, 1104 "Apple GLSL uniform override" 1105 }, 1106 { 1107 match_geforce5, 1108 quirk_no_np2, 1109 "Geforce 5 NP2 disable" 1110 }, 1111 { 1112 match_apple_intel, 1113 quirk_texcoord_w, 1114 "Init texcoord .w for Apple Intel GPU driver" 1115 }, 1116 { 1117 match_apple_nonr500ati, 1118 quirk_texcoord_w, 1119 "Init texcoord .w for Apple ATI >= r600 GPU driver" 1120 }, 1121 { 1122 match_dx10_capable, 1123 quirk_clip_varying, 1124 "Reserved varying for gl_ClipPos" 1125 }, 1126 { 1127 /* GL_EXT_secondary_color does not allow 4 component secondary colors, but most 1128 * GL implementations accept it. The Mac GL is the only implementation known to 1129 * reject it. 1130 * 1131 * If we can pass 4 component specular colors, do it, because (a) we don't have 1132 * to screw around with the data, and (b) the D3D fixed function vertex pipeline 1133 * passes specular alpha to the pixel shader if any is used. Otherwise the 1134 * specular alpha is used to pass the fog coordinate, which we pass to opengl 1135 * via GL_EXT_fog_coord. 1136 */ 1137 match_allows_spec_alpha, 1138 quirk_allows_specular_alpha, 1139 "Allow specular alpha quirk" 1140 }, 1141 { 1142 match_broken_nv_clip, 1143 quirk_disable_nvvp_clip, 1144 "Apple NV_vertex_program clip bug quirk" 1145 }, 1146 { 1147 match_fbo_tex_update, 1148 quirk_fbo_tex_update, 1149 "FBO rebind for attachment updates" 1150 }, 1151 { 1152 match_broken_rgba16, 1153 quirk_broken_rgba16, 1154 "True RGBA16 is not available" 1155 }, 1156 { 1157 match_fglrx, 1158 quirk_infolog_spam, 1159 "Not printing GLSL infolog" 1160 }, 1161 { 1162 match_not_dx10_capable, 1163 quirk_limited_tex_filtering, 1164 "Texture filtering, blending and VTF support is limited" 1165 }, 1166 { 1167 match_r200, 1168 quirk_r200_constants, 1169 "r200 vertex shader constants" 1170 }, 1171 { 1172 match_broken_arb_fog, 1173 quirk_broken_arb_fog, 1174 "ARBfp fogstart == fogend workaround" 1175 }, 1176 { 1177 match_broken_viewport_subpixel_bits, 1178 quirk_broken_viewport_subpixel_bits, 1179 "Nvidia viewport subpixel bits bug" 1180 }, 1181 }; 1182 1183 /* Certain applications (Steam) complain if we report an outdated driver version. In general, 1184 * reporting a driver version is moot because we are not the Windows driver, and we have different 1185 * bugs, features, etc. 1186 * 1187 * The driver version has the form "x.y.z.w". 1188 * 1189 * "x" is the Windows version the driver is meant for: 1190 * 4 -> 95/98/NT4 1191 * 5 -> 2000 1192 * 6 -> 2000/XP 1193 * 7 -> Vista 1194 * 8 -> Win 7 1195 * 1196 * "y" is the maximum Direct3D version the driver supports. 1197 * y -> d3d version mapping: 1198 * 11 -> d3d6 1199 * 12 -> d3d7 1200 * 13 -> d3d8 1201 * 14 -> d3d9 1202 * 15 -> d3d10 1203 * 16 -> d3d10.1 1204 * 17 -> d3d11 1205 * 1206 * "z" is the subversion number. 1207 * 1208 * "w" is the vendor specific driver build number. 1209 */ 1210 1211 struct driver_version_information 1212 { 1213 enum wined3d_display_driver driver; 1214 enum wined3d_driver_model driver_model; 1215 const char *driver_name; /* name of Windows driver */ 1216 WORD version; /* version word ('y'), contained in low word of DriverVersion.HighPart */ 1217 WORD subversion; /* subversion word ('z'), contained in high word of DriverVersion.LowPart */ 1218 WORD build; /* build number ('w'), contained in low word of DriverVersion.LowPart */ 1219 }; 1220 1221 /* The driver version table contains driver information for different devices on several OS versions. */ 1222 static const struct driver_version_information driver_version_table[] = 1223 { 1224 /* AMD 1225 * - Radeon HD2x00 (R600) and up supported by current drivers. 1226 * - Radeon 9500 (R300) - X1*00 (R5xx) supported up to Catalyst 9.3 (Linux) and 10.2 (XP/Vista/Win7) 1227 * - Radeon 7xxx (R100) - 9250 (RV250) supported up to Catalyst 6.11 (XP) 1228 * - Rage 128 supported up to XP, latest official build 6.13.3279 dated October 2001 */ 1229 {DRIVER_AMD_RAGE_128PRO, DRIVER_MODEL_NT5X, "ati2dvaa.dll", 13, 3279, 0}, 1230 {DRIVER_AMD_R100, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 6614}, 1231 {DRIVER_AMD_R300, DRIVER_MODEL_NT5X, "ati2dvag.dll", 14, 10, 6764}, 1232 {DRIVER_AMD_R600, DRIVER_MODEL_NT5X, "ati2dvag.dll", 17, 10, 1280}, 1233 {DRIVER_AMD_R300, DRIVER_MODEL_NT6X, "atiumdag.dll", 14, 10, 741 }, 1234 {DRIVER_AMD_R600, DRIVER_MODEL_NT6X, "atiumdag.dll", 17, 10, 1280}, 1235 {DRIVER_AMD_RX, DRIVER_MODEL_NT6X, "aticfx32.dll", 17, 10, 1474}, 1236 1237 /* Intel 1238 * The drivers are unified but not all versions support all GPUs. At some point the 2k/xp 1239 * drivers used ialmrnt5.dll for GMA800/GMA900 but at some point the file was renamed to 1240 * igxprd32.dll but the GMA800 driver was never updated. */ 1241 {DRIVER_INTEL_GMA800, DRIVER_MODEL_NT5X, "ialmrnt5.dll", 14, 10, 3889}, 1242 {DRIVER_INTEL_GMA900, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4764}, 1243 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 4926}, 1244 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT5X, "igxprd32.dll", 14, 10, 5218}, 1245 {DRIVER_INTEL_GMA950, DRIVER_MODEL_NT6X, "igdumd32.dll", 14, 10, 1504}, 1246 {DRIVER_INTEL_GMA3000, DRIVER_MODEL_NT6X, "igdumd32.dll", 15, 10, 1666}, 1247 {DRIVER_INTEL_HD4000, DRIVER_MODEL_NT6X, "igdumdim32.dll", 19, 15, 4352}, 1248 1249 /* Nvidia 1250 * - Geforce8 and newer is supported by the current 340.52 driver on XP-Win8 1251 * - Geforce6 and 7 support is up to 307.83 on XP-Win8 1252 * - GeforceFX support is up to 173.x on <= XP 1253 * - Geforce2MX/3/4 up to 96.x on <= XP 1254 * - TNT/Geforce1/2 up to 71.x on <= XP 1255 * All version numbers used below are from the Linux nvidia drivers. */ 1256 {DRIVER_NVIDIA_TNT, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 7186}, 1257 {DRIVER_NVIDIA_GEFORCE2MX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 10, 9371}, 1258 {DRIVER_NVIDIA_GEFORCEFX, DRIVER_MODEL_NT5X, "nv4_disp.dll", 14, 11, 7516}, 1259 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT5X, "nv4_disp.dll", 18, 13, 783}, 1260 {DRIVER_NVIDIA_GEFORCE8, DRIVER_MODEL_NT5X, "nv4_disp.dll", 18, 13, 4052}, 1261 {DRIVER_NVIDIA_GEFORCE6, DRIVER_MODEL_NT6X, "nvd3dum.dll", 18, 13, 783}, 1262 {DRIVER_NVIDIA_GEFORCE8, DRIVER_MODEL_NT6X, "nvd3dum.dll", 18, 13, 4052}, 1263 1264 /* VMware */ 1265 {DRIVER_VMWARE, DRIVER_MODEL_NT5X, "vm3dum.dll", 14, 1, 1134}, 1266 }; 1267 1268 struct gpu_description 1269 { 1270 WORD vendor; /* reported PCI card vendor ID */ 1271 WORD card; /* reported PCI card device ID */ 1272 const char *description; /* Description of the card e.g. NVIDIA RIVA TNT */ 1273 enum wined3d_display_driver driver; 1274 unsigned int vidmem; 1275 }; 1276 1277 /* The amount of video memory stored in the gpu description table is the minimum amount of video memory 1278 * found on a board containing a specific GPU. */ 1279 static const struct gpu_description gpu_description_table[] = 1280 { 1281 /* Nvidia cards */ 1282 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_128, "NVIDIA RIVA 128", DRIVER_NVIDIA_TNT, 4 }, 1283 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT, "NVIDIA RIVA TNT", DRIVER_NVIDIA_TNT, 16 }, 1284 {HW_VENDOR_NVIDIA, CARD_NVIDIA_RIVA_TNT2, "NVIDIA RIVA TNT2/TNT2 Pro", DRIVER_NVIDIA_TNT, 32 }, 1285 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE, "NVIDIA GeForce 256", DRIVER_NVIDIA_TNT, 32 }, 1286 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2, "NVIDIA GeForce2 GTS/GeForce2 Pro", DRIVER_NVIDIA_TNT, 32 }, 1287 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE2_MX, "NVIDIA GeForce2 MX/MX 400", DRIVER_NVIDIA_GEFORCE2MX,32 }, 1288 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE3, "NVIDIA GeForce3", DRIVER_NVIDIA_GEFORCE2MX,64 }, 1289 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_MX, "NVIDIA GeForce4 MX 460", DRIVER_NVIDIA_GEFORCE2MX,64 }, 1290 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE4_TI4200, "NVIDIA GeForce4 Ti 4200", DRIVER_NVIDIA_GEFORCE2MX,64, }, 1291 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5200, "NVIDIA GeForce FX 5200", DRIVER_NVIDIA_GEFORCEFX, 64 }, 1292 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5600, "NVIDIA GeForce FX 5600", DRIVER_NVIDIA_GEFORCEFX, 128 }, 1293 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCEFX_5800, "NVIDIA GeForce FX 5800", DRIVER_NVIDIA_GEFORCEFX, 256 }, 1294 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6200, "NVIDIA GeForce 6200", DRIVER_NVIDIA_GEFORCE6, 64 }, 1295 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6600GT, "NVIDIA GeForce 6600 GT", DRIVER_NVIDIA_GEFORCE6, 128 }, 1296 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_6800, "NVIDIA GeForce 6800", DRIVER_NVIDIA_GEFORCE6, 128 }, 1297 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7300, "NVIDIA GeForce Go 7300", DRIVER_NVIDIA_GEFORCE6, 256 }, 1298 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7400, "NVIDIA GeForce Go 7400", DRIVER_NVIDIA_GEFORCE6, 256 }, 1299 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7600, "NVIDIA GeForce 7600 GT", DRIVER_NVIDIA_GEFORCE6, 256 }, 1300 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_7800GT, "NVIDIA GeForce 7800 GT", DRIVER_NVIDIA_GEFORCE6, 256 }, 1301 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8200, "NVIDIA GeForce 8200", DRIVER_NVIDIA_GEFORCE8, 512 }, 1302 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8300GS, "NVIDIA GeForce 8300 GS", DRIVER_NVIDIA_GEFORCE8, 128 }, 1303 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8400GS, "NVIDIA GeForce 8400 GS", DRIVER_NVIDIA_GEFORCE8, 128 }, 1304 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8500GT, "NVIDIA GeForce 8500 GT", DRIVER_NVIDIA_GEFORCE8, 256 }, 1305 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600GT, "NVIDIA GeForce 8600 GT", DRIVER_NVIDIA_GEFORCE8, 256 }, 1306 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8600MGT, "NVIDIA GeForce 8600M GT", DRIVER_NVIDIA_GEFORCE8, 512 }, 1307 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTS, "NVIDIA GeForce 8800 GTS", DRIVER_NVIDIA_GEFORCE8, 320 }, 1308 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_8800GTX, "NVIDIA GeForce 8800 GTX", DRIVER_NVIDIA_GEFORCE8, 768 }, 1309 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9200, "NVIDIA GeForce 9200", DRIVER_NVIDIA_GEFORCE8, 256 }, 1310 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9300, "NVIDIA GeForce 9300", DRIVER_NVIDIA_GEFORCE8, 256 }, 1311 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400M, "NVIDIA GeForce 9400M", DRIVER_NVIDIA_GEFORCE8, 256 }, 1312 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9400GT, "NVIDIA GeForce 9400 GT", DRIVER_NVIDIA_GEFORCE8, 256 }, 1313 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9500GT, "NVIDIA GeForce 9500 GT", DRIVER_NVIDIA_GEFORCE8, 256 }, 1314 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9600GT, "NVIDIA GeForce 9600 GT", DRIVER_NVIDIA_GEFORCE8, 512 }, 1315 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9700MGT, "NVIDIA GeForce 9700M GT", DRIVER_NVIDIA_GEFORCE8, 512 }, 1316 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_9800GT, "NVIDIA GeForce 9800 GT", DRIVER_NVIDIA_GEFORCE8, 512 }, 1317 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_210, "NVIDIA GeForce 210", DRIVER_NVIDIA_GEFORCE8, 512 }, 1318 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT220, "NVIDIA GeForce GT 220", DRIVER_NVIDIA_GEFORCE8, 512 }, 1319 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT240, "NVIDIA GeForce GT 240", DRIVER_NVIDIA_GEFORCE8, 512 }, 1320 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS250, "NVIDIA GeForce GTS 250", DRIVER_NVIDIA_GEFORCE8, 1024}, 1321 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX260, "NVIDIA GeForce GTX 260", DRIVER_NVIDIA_GEFORCE8, 1024}, 1322 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX275, "NVIDIA GeForce GTX 275", DRIVER_NVIDIA_GEFORCE8, 896 }, 1323 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX280, "NVIDIA GeForce GTX 280", DRIVER_NVIDIA_GEFORCE8, 1024}, 1324 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_315M, "NVIDIA GeForce 315M", DRIVER_NVIDIA_GEFORCE8, 512 }, 1325 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_320M, "NVIDIA GeForce 320M", DRIVER_NVIDIA_GEFORCE8, 256}, 1326 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT320M, "NVIDIA GeForce GT 320M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1327 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT325M, "NVIDIA GeForce GT 325M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1328 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT330, "NVIDIA GeForce GT 330", DRIVER_NVIDIA_GEFORCE8, 1024}, 1329 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS350M, "NVIDIA GeForce GTS 350M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1330 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_410M, "NVIDIA GeForce 410M", DRIVER_NVIDIA_GEFORCE8, 512}, 1331 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT420, "NVIDIA GeForce GT 420", DRIVER_NVIDIA_GEFORCE8, 2048}, 1332 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT425M, "NVIDIA GeForce GT 425M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1333 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT430, "NVIDIA GeForce GT 430", DRIVER_NVIDIA_GEFORCE8, 1024}, 1334 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT440, "NVIDIA GeForce GT 440", DRIVER_NVIDIA_GEFORCE8, 1024}, 1335 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTS450, "NVIDIA GeForce GTS 450", DRIVER_NVIDIA_GEFORCE8, 1024}, 1336 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX460, "NVIDIA GeForce GTX 460", DRIVER_NVIDIA_GEFORCE8, 768 }, 1337 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX460M, "NVIDIA GeForce GTX 460M", DRIVER_NVIDIA_GEFORCE8, 1536}, 1338 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX465, "NVIDIA GeForce GTX 465", DRIVER_NVIDIA_GEFORCE8, 1024}, 1339 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX470, "NVIDIA GeForce GTX 470", DRIVER_NVIDIA_GEFORCE8, 1280}, 1340 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX480, "NVIDIA GeForce GTX 480", DRIVER_NVIDIA_GEFORCE8, 1536}, 1341 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT520, "NVIDIA GeForce GT 520", DRIVER_NVIDIA_GEFORCE8, 1024}, 1342 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT525M, "NVIDIA GeForce GT 525M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1343 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT540M, "NVIDIA GeForce GT 540M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1344 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX550, "NVIDIA GeForce GTX 550 Ti", DRIVER_NVIDIA_GEFORCE8, 1024}, 1345 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT555M, "NVIDIA GeForce GT 555M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1346 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX560TI, "NVIDIA GeForce GTX 560 Ti", DRIVER_NVIDIA_GEFORCE8, 1024}, 1347 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX560M, "NVIDIA GeForce GTX 560M", DRIVER_NVIDIA_GEFORCE8, 3072}, 1348 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX560, "NVIDIA GeForce GTX 560", DRIVER_NVIDIA_GEFORCE8, 1024}, 1349 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX570, "NVIDIA GeForce GTX 570", DRIVER_NVIDIA_GEFORCE8, 1280}, 1350 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX580, "NVIDIA GeForce GTX 580", DRIVER_NVIDIA_GEFORCE8, 1536}, 1351 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT610, "NVIDIA GeForce GT 610", DRIVER_NVIDIA_GEFORCE8, 1024}, 1352 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT630, "NVIDIA GeForce GT 630", DRIVER_NVIDIA_GEFORCE8, 1024}, 1353 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT630M, "NVIDIA GeForce GT 630M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1354 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT640M, "NVIDIA GeForce GT 640M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1355 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT650M, "NVIDIA GeForce GT 650M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1356 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX650, "NVIDIA GeForce GTX 650", DRIVER_NVIDIA_GEFORCE8, 1024}, 1357 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX650TI, "NVIDIA GeForce GTX 650 Ti", DRIVER_NVIDIA_GEFORCE8, 1024}, 1358 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX660, "NVIDIA GeForce GTX 660", DRIVER_NVIDIA_GEFORCE8, 2048}, 1359 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX660M, "NVIDIA GeForce GTX 660M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1360 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX660TI, "NVIDIA GeForce GTX 660 Ti", DRIVER_NVIDIA_GEFORCE8, 2048}, 1361 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX670, "NVIDIA GeForce GTX 670", DRIVER_NVIDIA_GEFORCE8, 2048}, 1362 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX670MX, "NVIDIA GeForce GTX 670MX", DRIVER_NVIDIA_GEFORCE8, 3072}, 1363 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX675MX, "NVIDIA GeForce GTX 675MX", DRIVER_NVIDIA_GEFORCE8, 4096}, 1364 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX680, "NVIDIA GeForce GTX 680", DRIVER_NVIDIA_GEFORCE8, 2048}, 1365 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX690, "NVIDIA GeForce GTX 690", DRIVER_NVIDIA_GEFORCE8, 2048}, 1366 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT730, "NVIDIA GeForce GT 730", DRIVER_NVIDIA_GEFORCE8, 2048}, 1367 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT730M, "NVIDIA GeForce GT 730M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1368 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT740M, "NVIDIA GeForce GT 740M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1369 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GT750M, "NVIDIA GeForce GT 750M", DRIVER_NVIDIA_GEFORCE8, 1024}, 1370 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX750, "NVIDIA GeForce GTX 750", DRIVER_NVIDIA_GEFORCE8, 1024}, 1371 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX750TI, "NVIDIA GeForce GTX 750 Ti", DRIVER_NVIDIA_GEFORCE8, 2048}, 1372 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX760, "NVIDIA GeForce GTX 760", DRIVER_NVIDIA_GEFORCE8, 2048}, 1373 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX760TI, "NVIDIA GeForce GTX 760 Ti", DRIVER_NVIDIA_GEFORCE8, 2048}, 1374 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX765M, "NVIDIA GeForce GTX 765M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1375 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX770M, "NVIDIA GeForce GTX 770M", DRIVER_NVIDIA_GEFORCE8, 3072}, 1376 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX770, "NVIDIA GeForce GTX 770", DRIVER_NVIDIA_GEFORCE8, 2048}, 1377 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX780, "NVIDIA GeForce GTX 780", DRIVER_NVIDIA_GEFORCE8, 3072}, 1378 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX780TI, "NVIDIA GeForce GTX 780 Ti", DRIVER_NVIDIA_GEFORCE8, 3072}, 1379 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTXTITAN, "NVIDIA GeForce GTX TITAN", DRIVER_NVIDIA_GEFORCE8, 6144}, 1380 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTXTITANB, "NVIDIA GeForce GTX TITAN Black", DRIVER_NVIDIA_GEFORCE8, 6144}, 1381 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTXTITANX, "NVIDIA GeForce GTX TITAN X", DRIVER_NVIDIA_GEFORCE8, 12288}, 1382 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTXTITANZ, "NVIDIA GeForce GTX TITAN Z", DRIVER_NVIDIA_GEFORCE8, 12288}, 1383 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_820M, "NVIDIA GeForce 820M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1384 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_830M, "NVIDIA GeForce 830M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1385 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_840M, "NVIDIA GeForce 840M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1386 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_845M, "NVIDIA GeForce 845M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1387 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX850M, "NVIDIA GeForce GTX 850M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1388 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX860M, "NVIDIA GeForce GTX 860M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1389 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX870M, "NVIDIA GeForce GTX 870M", DRIVER_NVIDIA_GEFORCE8, 3072}, 1390 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX880M, "NVIDIA GeForce GTX 880M", DRIVER_NVIDIA_GEFORCE8, 4096}, 1391 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_940M, "NVIDIA GeForce 940M", DRIVER_NVIDIA_GEFORCE8, 4096}, 1392 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX950, "NVIDIA GeForce GTX 950", DRIVER_NVIDIA_GEFORCE8, 2048}, 1393 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX950M, "NVIDIA GeForce GTX 950M", DRIVER_NVIDIA_GEFORCE8, 4096}, 1394 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX960, "NVIDIA GeForce GTX 960", DRIVER_NVIDIA_GEFORCE8, 4096}, 1395 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX960M, "NVIDIA GeForce GTX 960M", DRIVER_NVIDIA_GEFORCE8, 2048}, 1396 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX970, "NVIDIA GeForce GTX 970", DRIVER_NVIDIA_GEFORCE8, 4096}, 1397 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX970M, "NVIDIA GeForce GTX 970M", DRIVER_NVIDIA_GEFORCE8, 3072}, 1398 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX980, "NVIDIA GeForce GTX 980", DRIVER_NVIDIA_GEFORCE8, 4096}, 1399 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX980TI, "NVIDIA GeForce GTX 980 Ti", DRIVER_NVIDIA_GEFORCE8, 6144}, 1400 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1050, "NVIDIA GeForce GTX 1050", DRIVER_NVIDIA_GEFORCE8, 2048}, 1401 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1060, "NVIDIA GeForce GTX 1060", DRIVER_NVIDIA_GEFORCE8, 6144}, 1402 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1070, "NVIDIA GeForce GTX 1070", DRIVER_NVIDIA_GEFORCE8, 8192}, 1403 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1080, "NVIDIA GeForce GTX 1080", DRIVER_NVIDIA_GEFORCE8, 8192}, 1404 {HW_VENDOR_NVIDIA, CARD_NVIDIA_GEFORCE_GTX1080TI, "NVIDIA GeForce GTX 1080 Ti", DRIVER_NVIDIA_GEFORCE8, 11264}, 1405 {HW_VENDOR_NVIDIA, CARD_NVIDIA_TITANX_PASCAL, "NVIDIA TITAN X (Pascal)", DRIVER_NVIDIA_GEFORCE8, 12288}, 1406 1407 /* AMD cards */ 1408 {HW_VENDOR_AMD, CARD_AMD_RAGE_128PRO, "ATI Rage Fury", DRIVER_AMD_RAGE_128PRO, 16 }, 1409 {HW_VENDOR_AMD, CARD_AMD_RADEON_7200, "ATI RADEON 7200 SERIES", DRIVER_AMD_R100, 32 }, 1410 {HW_VENDOR_AMD, CARD_AMD_RADEON_8500, "ATI RADEON 8500 SERIES", DRIVER_AMD_R100, 64 }, 1411 {HW_VENDOR_AMD, CARD_AMD_RADEON_9500, "ATI Radeon 9500", DRIVER_AMD_R300, 64 }, 1412 {HW_VENDOR_AMD, CARD_AMD_RADEON_XPRESS_200M, "ATI RADEON XPRESS 200M Series", DRIVER_AMD_R300, 64 }, 1413 {HW_VENDOR_AMD, CARD_AMD_RADEON_X700, "ATI Radeon X700 SE", DRIVER_AMD_R300, 128 }, 1414 {HW_VENDOR_AMD, CARD_AMD_RADEON_X1600, "ATI Radeon X1600 Series", DRIVER_AMD_R300, 128 }, 1415 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD2350, "ATI Mobility Radeon HD 2350", DRIVER_AMD_R600, 256 }, 1416 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD2600, "ATI Mobility Radeon HD 2600", DRIVER_AMD_R600, 256 }, 1417 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD2900, "ATI Radeon HD 2900 XT", DRIVER_AMD_R600, 512 }, 1418 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD3200, "ATI Radeon HD 3200 Graphics", DRIVER_AMD_R600, 128 }, 1419 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD3850, "ATI Radeon HD 3850 AGP", DRIVER_AMD_R600, 512 }, 1420 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4200M, "ATI Mobility Radeon HD 4200", DRIVER_AMD_R600, 256 }, 1421 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4350, "ATI Radeon HD 4350", DRIVER_AMD_R600, 256 }, 1422 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4600, "ATI Radeon HD 4600 Series", DRIVER_AMD_R600, 512 }, 1423 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4700, "ATI Radeon HD 4700 Series", DRIVER_AMD_R600, 512 }, 1424 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD4800, "ATI Radeon HD 4800 Series", DRIVER_AMD_R600, 512 }, 1425 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5400, "ATI Radeon HD 5400 Series", DRIVER_AMD_R600, 512 }, 1426 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5600, "ATI Radeon HD 5600 Series", DRIVER_AMD_R600, 512 }, 1427 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5700, "ATI Radeon HD 5700 Series", DRIVER_AMD_R600, 512 }, 1428 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5800, "ATI Radeon HD 5800 Series", DRIVER_AMD_R600, 1024}, 1429 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD5900, "ATI Radeon HD 5900 Series", DRIVER_AMD_R600, 1024}, 1430 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6300, "AMD Radeon HD 6300 series Graphics", DRIVER_AMD_R600, 1024}, 1431 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6400, "AMD Radeon HD 6400 Series", DRIVER_AMD_R600, 1024}, 1432 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6410D, "AMD Radeon HD 6410D", DRIVER_AMD_R600, 1024}, 1433 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6480G, "AMD Radeon HD 6480G", DRIVER_AMD_R600, 512 }, 1434 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6550D, "AMD Radeon HD 6550D", DRIVER_AMD_R600, 1024}, 1435 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6600, "AMD Radeon HD 6600 Series", DRIVER_AMD_R600, 1024}, 1436 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6600M, "AMD Radeon HD 6600M Series", DRIVER_AMD_R600, 512 }, 1437 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6700, "AMD Radeon HD 6700 Series", DRIVER_AMD_R600, 1024}, 1438 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6800, "AMD Radeon HD 6800 Series", DRIVER_AMD_R600, 1024}, 1439 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD6900, "AMD Radeon HD 6900 Series", DRIVER_AMD_R600, 2048}, 1440 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD7660D, "AMD Radeon HD 7660D", DRIVER_AMD_R600, 2048}, 1441 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD7700, "AMD Radeon HD 7700 Series", DRIVER_AMD_R600, 1024}, 1442 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD7800, "AMD Radeon HD 7800 Series", DRIVER_AMD_R600, 2048}, 1443 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD7900, "AMD Radeon HD 7900 Series", DRIVER_AMD_R600, 2048}, 1444 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD8600M, "AMD Radeon HD 8600M Series", DRIVER_AMD_R600, 1024}, 1445 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD8670, "AMD Radeon HD 8670", DRIVER_AMD_R600, 2048}, 1446 {HW_VENDOR_AMD, CARD_AMD_RADEON_HD8770, "AMD Radeon HD 8770", DRIVER_AMD_R600, 2048}, 1447 {HW_VENDOR_AMD, CARD_AMD_RADEON_R3, "AMD Radeon HD 8400 / R3 Series", DRIVER_AMD_R600, 2048}, 1448 {HW_VENDOR_AMD, CARD_AMD_RADEON_R7, "AMD Radeon(TM) R7 Graphics", DRIVER_AMD_R600, 2048}, 1449 {HW_VENDOR_AMD, CARD_AMD_RADEON_R9_285, "AMD Radeon R9 285", DRIVER_AMD_RX, 2048}, 1450 {HW_VENDOR_AMD, CARD_AMD_RADEON_R9_290, "AMD Radeon R9 290", DRIVER_AMD_RX, 4096}, 1451 {HW_VENDOR_AMD, CARD_AMD_RADEON_R9_FURY, "AMD Radeon (TM) R9 Fury Series", DRIVER_AMD_RX, 4096}, 1452 {HW_VENDOR_AMD, CARD_AMD_RADEON_RX_460, "Radeon(TM) RX 460 Graphics", DRIVER_AMD_RX, 4096}, 1453 {HW_VENDOR_AMD, CARD_AMD_RADEON_RX_480, "Radeon (TM) RX 480 Graphics", DRIVER_AMD_RX, 4096}, 1454 1455 /* VMware */ 1456 {HW_VENDOR_VMWARE, CARD_VMWARE_SVGA3D, "VMware SVGA 3D (Microsoft Corporation - WDDM)", DRIVER_VMWARE, 1024}, 1457 1458 /* Intel cards */ 1459 {HW_VENDOR_INTEL, CARD_INTEL_830M, "Intel(R) 82830M Graphics Controller", DRIVER_INTEL_GMA800, 32 }, 1460 {HW_VENDOR_INTEL, CARD_INTEL_855GM, "Intel(R) 82852/82855 GM/GME Graphics Controller", DRIVER_INTEL_GMA800, 32 }, 1461 {HW_VENDOR_INTEL, CARD_INTEL_845G, "Intel(R) 845G", DRIVER_INTEL_GMA800, 32 }, 1462 {HW_VENDOR_INTEL, CARD_INTEL_865G, "Intel(R) 82865G Graphics Controller", DRIVER_INTEL_GMA800, 32 }, 1463 {HW_VENDOR_INTEL, CARD_INTEL_915G, "Intel(R) 82915G/GV/910GL Express Chipset Family", DRIVER_INTEL_GMA900, 64 }, 1464 {HW_VENDOR_INTEL, CARD_INTEL_E7221G, "Intel(R) E7221G", DRIVER_INTEL_GMA900, 64 }, 1465 {HW_VENDOR_INTEL, CARD_INTEL_915GM, "Mobile Intel(R) 915GM/GMS,910GML Express Chipset Family", DRIVER_INTEL_GMA900, 64 }, 1466 {HW_VENDOR_INTEL, CARD_INTEL_945G, "Intel(R) 945G", DRIVER_INTEL_GMA950, 64 }, 1467 {HW_VENDOR_INTEL, CARD_INTEL_945GM, "Mobile Intel(R) 945GM Express Chipset Family", DRIVER_INTEL_GMA950, 64 }, 1468 {HW_VENDOR_INTEL, CARD_INTEL_945GME, "Intel(R) 945GME", DRIVER_INTEL_GMA950, 64 }, 1469 {HW_VENDOR_INTEL, CARD_INTEL_Q35, "Intel(R) Q35", DRIVER_INTEL_GMA950, 64 }, 1470 {HW_VENDOR_INTEL, CARD_INTEL_G33, "Intel(R) G33", DRIVER_INTEL_GMA950, 64 }, 1471 {HW_VENDOR_INTEL, CARD_INTEL_Q33, "Intel(R) Q33", DRIVER_INTEL_GMA950, 64 }, 1472 {HW_VENDOR_INTEL, CARD_INTEL_PNVG, "Intel(R) IGD", DRIVER_INTEL_GMA950, 64 }, 1473 {HW_VENDOR_INTEL, CARD_INTEL_PNVM, "Intel(R) IGD", DRIVER_INTEL_GMA950, 64 }, 1474 {HW_VENDOR_INTEL, CARD_INTEL_965Q, "Intel(R) 965Q", DRIVER_INTEL_GMA3000, 128}, 1475 {HW_VENDOR_INTEL, CARD_INTEL_965G, "Intel(R) 965G", DRIVER_INTEL_GMA3000, 128}, 1476 {HW_VENDOR_INTEL, CARD_INTEL_946GZ, "Intel(R) 946GZ", DRIVER_INTEL_GMA3000, 128}, 1477 {HW_VENDOR_INTEL, CARD_INTEL_965GM, "Mobile Intel(R) 965 Express Chipset Family", DRIVER_INTEL_GMA3000, 128}, 1478 {HW_VENDOR_INTEL, CARD_INTEL_965GME, "Intel(R) 965GME", DRIVER_INTEL_GMA3000, 128}, 1479 {HW_VENDOR_INTEL, CARD_INTEL_GM45, "Mobile Intel(R) GM45 Express Chipset Family", DRIVER_INTEL_GMA3000, 512}, 1480 {HW_VENDOR_INTEL, CARD_INTEL_IGD, "Intel(R) Integrated Graphics Device", DRIVER_INTEL_GMA3000, 512}, 1481 {HW_VENDOR_INTEL, CARD_INTEL_G45, "Intel(R) G45/G43", DRIVER_INTEL_GMA3000, 512}, 1482 {HW_VENDOR_INTEL, CARD_INTEL_Q45, "Intel(R) Q45/Q43", DRIVER_INTEL_GMA3000, 512}, 1483 {HW_VENDOR_INTEL, CARD_INTEL_G41, "Intel(R) G41", DRIVER_INTEL_GMA3000, 512}, 1484 {HW_VENDOR_INTEL, CARD_INTEL_B43, "Intel(R) B43", DRIVER_INTEL_GMA3000, 512}, 1485 {HW_VENDOR_INTEL, CARD_INTEL_ILKD, "Intel(R) HD Graphics", DRIVER_INTEL_GMA3000, 1536}, 1486 {HW_VENDOR_INTEL, CARD_INTEL_ILKM, "Intel(R) HD Graphics", DRIVER_INTEL_GMA3000, 1536}, 1487 {HW_VENDOR_INTEL, CARD_INTEL_SNBD, "Intel(R) HD Graphics 3000", DRIVER_INTEL_GMA3000, 1536}, 1488 {HW_VENDOR_INTEL, CARD_INTEL_SNBM, "Intel(R) HD Graphics 3000", DRIVER_INTEL_GMA3000, 1536}, 1489 {HW_VENDOR_INTEL, CARD_INTEL_SNBS, "Intel(R) HD Graphics Family", DRIVER_INTEL_GMA3000, 1536}, 1490 {HW_VENDOR_INTEL, CARD_INTEL_IVBD, "Intel(R) HD Graphics 4000", DRIVER_INTEL_HD4000, 1536}, 1491 {HW_VENDOR_INTEL, CARD_INTEL_IVBM, "Intel(R) HD Graphics 4000", DRIVER_INTEL_HD4000, 1536}, 1492 {HW_VENDOR_INTEL, CARD_INTEL_IVBS, "Intel(R) HD Graphics Family", DRIVER_INTEL_HD4000, 1536}, 1493 {HW_VENDOR_INTEL, CARD_INTEL_HWD, "Intel(R) HD Graphics 4600", DRIVER_INTEL_HD4000, 1536}, 1494 {HW_VENDOR_INTEL, CARD_INTEL_HWM, "Intel(R) HD Graphics 4600", DRIVER_INTEL_HD4000, 1536}, 1495 {HW_VENDOR_INTEL, CARD_INTEL_HD5000, "Intel(R) HD Graphics 5000", DRIVER_INTEL_HD4000, 1536}, 1496 {HW_VENDOR_INTEL, CARD_INTEL_I5100_1, "Intel(R) Iris(TM) Graphics 5100", DRIVER_INTEL_HD4000, 1536}, 1497 {HW_VENDOR_INTEL, CARD_INTEL_I5100_2, "Intel(R) Iris(TM) Graphics 5100", DRIVER_INTEL_HD4000, 1536}, 1498 {HW_VENDOR_INTEL, CARD_INTEL_I5100_3, "Intel(R) Iris(TM) Graphics 5100", DRIVER_INTEL_HD4000, 1536}, 1499 {HW_VENDOR_INTEL, CARD_INTEL_I5100_4, "Intel(R) Iris(TM) Graphics 5100", DRIVER_INTEL_HD4000, 1536}, 1500 {HW_VENDOR_INTEL, CARD_INTEL_IP5200_1, "Intel(R) Iris(TM) Pro Graphics 5200", DRIVER_INTEL_HD4000, 1536}, 1501 {HW_VENDOR_INTEL, CARD_INTEL_IP5200_2, "Intel(R) Iris(TM) Pro Graphics 5200", DRIVER_INTEL_HD4000, 1536}, 1502 {HW_VENDOR_INTEL, CARD_INTEL_IP5200_3, "Intel(R) Iris(TM) Pro Graphics 5200", DRIVER_INTEL_HD4000, 1536}, 1503 {HW_VENDOR_INTEL, CARD_INTEL_IP5200_4, "Intel(R) Iris(TM) Pro Graphics 5200", DRIVER_INTEL_HD4000, 1536}, 1504 {HW_VENDOR_INTEL, CARD_INTEL_IP5200_5, "Intel(R) Iris(TM) Pro Graphics 5200", DRIVER_INTEL_HD4000, 1536}, 1505 {HW_VENDOR_INTEL, CARD_INTEL_HD5300, "Intel(R) HD Graphics 5300", DRIVER_INTEL_HD4000, 2048}, 1506 {HW_VENDOR_INTEL, CARD_INTEL_HD5500, "Intel(R) HD Graphics 5500", DRIVER_INTEL_HD4000, 2048}, 1507 {HW_VENDOR_INTEL, CARD_INTEL_HD5600, "Intel(R) HD Graphics 5600", DRIVER_INTEL_HD4000, 2048}, 1508 {HW_VENDOR_INTEL, CARD_INTEL_HD6000, "Intel(R) HD Graphics 6000", DRIVER_INTEL_HD4000, 2048}, 1509 {HW_VENDOR_INTEL, CARD_INTEL_I6100, "Intel(R) Iris(TM) Graphics 6100", DRIVER_INTEL_HD4000, 2048}, 1510 {HW_VENDOR_INTEL, CARD_INTEL_IP6200, "Intel(R) Iris(TM) Pro Graphics 6200", DRIVER_INTEL_HD4000, 2048}, 1511 {HW_VENDOR_INTEL, CARD_INTEL_IPP6300, "Intel(R) Iris(TM) Pro Graphics P6300", DRIVER_INTEL_HD4000, 2048}, 1512 {HW_VENDOR_INTEL, CARD_INTEL_HD510_1, "Intel(R) HD Graphics 510", DRIVER_INTEL_HD4000, 2048}, 1513 {HW_VENDOR_INTEL, CARD_INTEL_HD510_2, "Intel(R) HD Graphics 510", DRIVER_INTEL_HD4000, 2048}, 1514 {HW_VENDOR_INTEL, CARD_INTEL_HD510_3, "Intel(R) HD Graphics 510", DRIVER_INTEL_HD4000, 2048}, 1515 {HW_VENDOR_INTEL, CARD_INTEL_HD515, "Intel(R) HD Graphics 515", DRIVER_INTEL_HD4000, 2048}, 1516 {HW_VENDOR_INTEL, CARD_INTEL_HD520_1, "Intel(R) HD Graphics 520", DRIVER_INTEL_HD4000, 2048}, 1517 {HW_VENDOR_INTEL, CARD_INTEL_HD520_2, "Intel(R) HD Graphics 520", DRIVER_INTEL_HD4000, 2048}, 1518 {HW_VENDOR_INTEL, CARD_INTEL_HD530_1, "Intel(R) HD Graphics 530", DRIVER_INTEL_HD4000, 2048}, 1519 {HW_VENDOR_INTEL, CARD_INTEL_HD530_2, "Intel(R) HD Graphics 530", DRIVER_INTEL_HD4000, 2048}, 1520 {HW_VENDOR_INTEL, CARD_INTEL_HDP530, "Intel(R) HD Graphics P530", DRIVER_INTEL_HD4000, 2048}, 1521 {HW_VENDOR_INTEL, CARD_INTEL_I540, "Intel(R) Iris(TM) Graphics 540", DRIVER_INTEL_HD4000, 2048}, 1522 {HW_VENDOR_INTEL, CARD_INTEL_I550, "Intel(R) Iris(TM) Graphics 550", DRIVER_INTEL_HD4000, 2048}, 1523 {HW_VENDOR_INTEL, CARD_INTEL_I555, "Intel(R) Iris(TM) Graphics 555", DRIVER_INTEL_HD4000, 2048}, 1524 {HW_VENDOR_INTEL, CARD_INTEL_IP555, "Intel(R) Iris(TM) Graphics P555", DRIVER_INTEL_HD4000, 2048}, 1525 {HW_VENDOR_INTEL, CARD_INTEL_IP580_1, "Intel(R) Iris(TM) Pro Graphics 580", DRIVER_INTEL_HD4000, 2048}, 1526 {HW_VENDOR_INTEL, CARD_INTEL_IP580_2, "Intel(R) Iris(TM) Pro Graphics 580", DRIVER_INTEL_HD4000, 2048}, 1527 {HW_VENDOR_INTEL, CARD_INTEL_IPP580_1, "Intel(R) Iris(TM) Pro Graphics P580", DRIVER_INTEL_HD4000, 2048}, 1528 {HW_VENDOR_INTEL, CARD_INTEL_IPP580_2, "Intel(R) Iris(TM) Pro Graphics P580", DRIVER_INTEL_HD4000, 2048}, 1529 }; 1530 1531 static const struct driver_version_information *get_driver_version_info(enum wined3d_display_driver driver, 1532 enum wined3d_driver_model driver_model) 1533 { 1534 unsigned int i; 1535 1536 TRACE("Looking up version info for driver=%d driver_model=%d\n", driver, driver_model); 1537 for (i = 0; i < ARRAY_SIZE(driver_version_table); ++i) 1538 { 1539 const struct driver_version_information *entry = &driver_version_table[i]; 1540 1541 if (entry->driver == driver && (driver_model == DRIVER_MODEL_GENERIC 1542 || entry->driver_model == driver_model)) 1543 { 1544 TRACE("Found driver \"%s\", version %u, subversion %u, build %u.\n", 1545 entry->driver_name, entry->version, entry->subversion, entry->build); 1546 return entry; 1547 } 1548 } 1549 return NULL; 1550 } 1551 1552 static const struct gpu_description *get_gpu_description(enum wined3d_pci_vendor vendor, 1553 enum wined3d_pci_device device) 1554 { 1555 unsigned int i; 1556 1557 for (i = 0; i < ARRAY_SIZE(gpu_description_table); ++i) 1558 { 1559 if (vendor == gpu_description_table[i].vendor && device == gpu_description_table[i].card) 1560 return &gpu_description_table[i]; 1561 } 1562 1563 return NULL; 1564 } 1565 1566 static const struct gpu_description *query_gpu_description(const struct wined3d_gl_info *gl_info, UINT64 *vram_bytes) 1567 { 1568 enum wined3d_pci_vendor vendor = PCI_VENDOR_NONE; 1569 enum wined3d_pci_device device = PCI_DEVICE_NONE; 1570 const struct gpu_description *gpu_description; 1571 static unsigned int once; 1572 1573 if (gl_info->supported[WGL_WINE_QUERY_RENDERER]) 1574 { 1575 GLuint value; 1576 1577 if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_VENDOR_ID_WINE, &value))) 1578 vendor = value; 1579 if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_DEVICE_ID_WINE, &value))) 1580 device = value; 1581 if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_VIDEO_MEMORY_WINE, &value))) 1582 *vram_bytes = (UINT64)value * 1024 * 1024; 1583 TRACE("Card reports vendor PCI ID 0x%04x, device PCI ID 0x%04x, 0x%s bytes of video memory.\n", 1584 vendor, device, wine_dbgstr_longlong(*vram_bytes)); 1585 } 1586 else if (gl_info->supported[NVX_GPU_MEMORY_INFO]) 1587 { 1588 GLint vram_kb; 1589 gl_info->gl_ops.gl.p_glGetIntegerv(GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX, &vram_kb); 1590 1591 *vram_bytes = (UINT64)vram_kb * 1024; 1592 TRACE("Got 0x%s as video memory from NVX_GPU_MEMORY_INFO extension.\n", 1593 wine_dbgstr_longlong(*vram_bytes)); 1594 } 1595 1596 if (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE) 1597 { 1598 vendor = wined3d_settings.pci_vendor_id; 1599 TRACE("Overriding vendor PCI ID with 0x%04x.\n", vendor); 1600 } 1601 1602 if (wined3d_settings.pci_device_id != PCI_DEVICE_NONE) 1603 { 1604 device = wined3d_settings.pci_device_id; 1605 TRACE("Overriding device PCI ID with 0x%04x.\n", device); 1606 } 1607 1608 if (wined3d_settings.emulated_textureram) 1609 { 1610 *vram_bytes = wined3d_settings.emulated_textureram; 1611 TRACE("Overriding amount of video memory with 0x%s bytes.\n", 1612 wine_dbgstr_longlong(*vram_bytes)); 1613 } 1614 1615 if (!(gpu_description = get_gpu_description(vendor, device)) 1616 && (wined3d_settings.pci_vendor_id != PCI_VENDOR_NONE 1617 || wined3d_settings.pci_device_id != PCI_DEVICE_NONE) && !once++) 1618 ERR_(winediag)("Invalid GPU override %04x:%04x specified, ignoring.\n", vendor, device); 1619 1620 return gpu_description; 1621 } 1622 1623 static void init_driver_info(struct wined3d_driver_info *driver_info, 1624 const struct gpu_description *gpu_desc, UINT64 vram_bytes) 1625 { 1626 OSVERSIONINFOW os_version; 1627 WORD driver_os_version; 1628 enum wined3d_display_driver driver; 1629 enum wined3d_driver_model driver_model; 1630 const struct driver_version_information *version_info; 1631 1632 memset(&os_version, 0, sizeof(os_version)); 1633 os_version.dwOSVersionInfoSize = sizeof(os_version); 1634 if (!GetVersionExW(&os_version)) 1635 { 1636 ERR("Failed to get OS version, reporting 2000/XP.\n"); 1637 driver_os_version = 6; 1638 driver_model = DRIVER_MODEL_NT5X; 1639 } 1640 else 1641 { 1642 TRACE("OS version %u.%u.\n", os_version.dwMajorVersion, os_version.dwMinorVersion); 1643 switch (os_version.dwMajorVersion) 1644 { 1645 case 4: 1646 /* If needed we could distinguish between 9x and NT4, but this code won't make 1647 * sense for NT4 since it had no way to obtain this info through DirectDraw 3.0. 1648 */ 1649 driver_os_version = 4; 1650 driver_model = DRIVER_MODEL_WIN9X; 1651 break; 1652 1653 case 5: 1654 driver_os_version = 6; 1655 driver_model = DRIVER_MODEL_NT5X; 1656 break; 1657 1658 case 6: 1659 if (os_version.dwMinorVersion == 0) 1660 { 1661 driver_os_version = 7; 1662 driver_model = DRIVER_MODEL_NT6X; 1663 } 1664 else if (os_version.dwMinorVersion == 1) 1665 { 1666 driver_os_version = 8; 1667 driver_model = DRIVER_MODEL_NT6X; 1668 } 1669 else 1670 { 1671 if (os_version.dwMinorVersion > 2) 1672 { 1673 FIXME("Unhandled OS version %u.%u, reporting Win 8.\n", 1674 os_version.dwMajorVersion, os_version.dwMinorVersion); 1675 } 1676 driver_os_version = 9; 1677 driver_model = DRIVER_MODEL_NT6X; 1678 } 1679 break; 1680 1681 case 10: 1682 driver_os_version = 10; 1683 driver_model = DRIVER_MODEL_NT6X; 1684 break; 1685 1686 default: 1687 FIXME("Unhandled OS version %u.%u, reporting 2000/XP.\n", 1688 os_version.dwMajorVersion, os_version.dwMinorVersion); 1689 driver_os_version = 6; 1690 driver_model = DRIVER_MODEL_NT5X; 1691 break; 1692 } 1693 } 1694 1695 driver_info->vendor = gpu_desc->vendor; 1696 driver_info->device = gpu_desc->card; 1697 driver_info->description = gpu_desc->description; 1698 driver_info->vram_bytes = vram_bytes ? vram_bytes : (UINT64)gpu_desc->vidmem * 1024 * 1024; 1699 driver = gpu_desc->driver; 1700 1701 /** 1702 * Diablo 2 crashes when the amount of video memory is greater than 0x7fffffff. 1703 * In order to avoid this application bug we limit the amount of video memory 1704 * to LONG_MAX for older Windows versions. 1705 */ 1706 #ifdef __i386__ 1707 if (driver_model < DRIVER_MODEL_NT6X && driver_info->vram_bytes > LONG_MAX) 1708 { 1709 TRACE("Limiting amount of video memory to %#lx bytes for OS version older than Vista.\n", LONG_MAX); 1710 driver_info->vram_bytes = LONG_MAX; 1711 } 1712 #endif 1713 1714 /* Try to obtain driver version information for the current Windows version. This fails in 1715 * some cases: 1716 * - the gpu is not available on the currently selected OS version: 1717 * - Geforce GTX480 on Win98. When running applications in compatibility mode on Windows, 1718 * version information for the current Windows version is returned instead of faked info. 1719 * We do the same and assume the default Windows version to emulate is WinXP. 1720 * 1721 * - Videocard is a Riva TNT but winver is set to win7 (there are no drivers for this beast) 1722 * For now return the XP driver info. Perhaps later on we should return VESA. 1723 * 1724 * - the gpu is not in our database (can happen when the user overrides the vendor_id / device_id) 1725 * This could be an indication that our database is not up to date, so this should be fixed. 1726 */ 1727 if ((version_info = get_driver_version_info(driver, driver_model)) 1728 || (version_info = get_driver_version_info(driver, DRIVER_MODEL_GENERIC))) 1729 { 1730 driver_info->name = version_info->driver_name; 1731 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, version_info->version); 1732 driver_info->version_low = MAKEDWORD_VERSION(version_info->subversion, version_info->build); 1733 } 1734 else 1735 { 1736 ERR("No driver version info found for device %04x:%04x, driver model %#x.\n", 1737 driver_info->vendor, driver_info->device, driver_model); 1738 driver_info->name = "Display"; 1739 driver_info->version_high = MAKEDWORD_VERSION(driver_os_version, 15); 1740 driver_info->version_low = MAKEDWORD_VERSION(8, 6); /* Nvidia RIVA TNT, arbitrary */ 1741 } 1742 1743 TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n", 1744 driver_info->version_high, driver_info->version_low); 1745 } 1746 1747 /* Context activation is done by the caller. */ 1748 static void fixup_extensions(struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx, 1749 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor, 1750 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device) 1751 { 1752 unsigned int i; 1753 1754 for (i = 0; i < ARRAY_SIZE(quirk_table); ++i) 1755 { 1756 if (!quirk_table[i].match(gl_info, ctx, gl_renderer, gl_vendor, card_vendor, device)) continue; 1757 TRACE("Applying driver quirk \"%s\".\n", quirk_table[i].description); 1758 quirk_table[i].apply(gl_info); 1759 } 1760 1761 /* Find out if PBOs work as they are supposed to. */ 1762 test_pbo_functionality(gl_info); 1763 } 1764 1765 static DWORD wined3d_parse_gl_version(const char *gl_version) 1766 { 1767 const char *ptr = gl_version; 1768 int major, minor; 1769 1770 major = atoi(ptr); 1771 if (major <= 0) 1772 ERR("Invalid OpenGL major version %d.\n", major); 1773 1774 while (isdigit(*ptr)) ++ptr; 1775 if (*ptr++ != '.') 1776 ERR("Invalid OpenGL version string %s.\n", debugstr_a(gl_version)); 1777 1778 minor = atoi(ptr); 1779 1780 TRACE("Found OpenGL version %d.%d.\n", major, minor); 1781 1782 return MAKEDWORD_VERSION(major, minor); 1783 } 1784 1785 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(const struct wined3d_gl_info *gl_info, 1786 const char *gl_vendor_string, const char *gl_renderer, const char *gl_version) 1787 { 1788 /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from 1789 * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to 1790 * detect the Apple OpenGL implementation to apply some extension fixups afterwards. 1791 * 1792 * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks 1793 * aren't sufficient either because a Linux binary may display on a macos X server via remote X11. 1794 * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions 1795 * like client storage might be supported on other implementations too, but GL_APPLE_flush_render 1796 * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So 1797 * the chance that other implementations support them is rather small since Win32 QuickTime uses 1798 * DirectDraw, not OpenGL. */ 1799 if (gl_info->supported[APPLE_FENCE] && gl_info->supported[APPLE_YCBCR_422]) 1800 return GL_VENDOR_APPLE; 1801 1802 if (strstr(gl_vendor_string, "NVIDIA")) 1803 return GL_VENDOR_NVIDIA; 1804 1805 if (strstr(gl_vendor_string, "ATI")) 1806 return GL_VENDOR_FGLRX; 1807 1808 if (strstr(gl_vendor_string, "Mesa") 1809 || strstr(gl_vendor_string, "Brian Paul") 1810 || strstr(gl_vendor_string, "X.Org") 1811 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.") 1812 || strstr(gl_vendor_string, "DRI R300 Project") 1813 || strstr(gl_vendor_string, "Tungsten Graphics, Inc") 1814 || strstr(gl_vendor_string, "VMware, Inc.") 1815 || strstr(gl_vendor_string, "Intel") 1816 || strstr(gl_renderer, "Mesa") 1817 || strstr(gl_renderer, "Gallium") 1818 || strstr(gl_renderer, "Intel") 1819 || strstr(gl_version, "Mesa")) 1820 return GL_VENDOR_MESA; 1821 1822 FIXME("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_UNKNOWN.\n", 1823 debugstr_a(gl_vendor_string)); 1824 1825 return GL_VENDOR_UNKNOWN; 1826 } 1827 1828 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer) 1829 { 1830 if (strstr(gl_vendor_string, "NVIDIA") 1831 || strstr(gl_vendor_string, "Nouveau") 1832 || strstr(gl_vendor_string, "nouveau")) 1833 return HW_VENDOR_NVIDIA; 1834 1835 if (strstr(gl_vendor_string, "ATI") 1836 || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.") 1837 || strstr(gl_vendor_string, "X.Org R300 Project") 1838 || strstr(gl_renderer, "AMD") 1839 || strstr(gl_renderer, "FirePro") 1840 || strstr(gl_renderer, "Radeon") 1841 || strstr(gl_renderer, "R100") 1842 || strstr(gl_renderer, "R200") 1843 || strstr(gl_renderer, "R300") 1844 || strstr(gl_renderer, "R600") 1845 || strstr(gl_renderer, "R700")) 1846 return HW_VENDOR_AMD; 1847 1848 if (strstr(gl_vendor_string, "Intel(R)") 1849 /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */ 1850 || strstr(gl_renderer, "Intel") 1851 || strstr(gl_renderer, "i915") 1852 || strstr(gl_vendor_string, "Intel Inc.")) 1853 return HW_VENDOR_INTEL; 1854 1855 if (strstr(gl_renderer, "SVGA3D")) 1856 return HW_VENDOR_VMWARE; 1857 1858 if (strstr(gl_vendor_string, "Mesa") 1859 || strstr(gl_vendor_string, "Brian Paul") 1860 || strstr(gl_vendor_string, "Tungsten Graphics, Inc") 1861 || strstr(gl_vendor_string, "VMware, Inc.")) 1862 return HW_VENDOR_SOFTWARE; 1863 1864 FIXME("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string)); 1865 1866 return HW_VENDOR_NVIDIA; 1867 } 1868 1869 static enum wined3d_d3d_level d3d_level_from_caps(const struct shader_caps *shader_caps, const struct fragment_caps *fragment_caps, DWORD glsl_version) 1870 { 1871 if (shader_caps->vs_version >= 5) 1872 return WINED3D_D3D_LEVEL_11; 1873 if (shader_caps->vs_version == 4) 1874 return WINED3D_D3D_LEVEL_10; 1875 if (shader_caps->vs_version == 3) 1876 { 1877 /* wined3d with default settings at the moment doesn't expose SM4+ on 1878 * Mesa drivers. */ 1879 if (glsl_version >= MAKEDWORD_VERSION(4, 30)) 1880 return WINED3D_D3D_LEVEL_11; 1881 if (glsl_version >= MAKEDWORD_VERSION(1, 30)) 1882 return WINED3D_D3D_LEVEL_10; 1883 return WINED3D_D3D_LEVEL_9_SM3; 1884 } 1885 if (shader_caps->vs_version == 2) 1886 return WINED3D_D3D_LEVEL_9_SM2; 1887 if (shader_caps->vs_version == 1) 1888 return WINED3D_D3D_LEVEL_8; 1889 1890 if (fragment_caps->TextureOpCaps & WINED3DTEXOPCAPS_DOTPRODUCT3) 1891 return WINED3D_D3D_LEVEL_7; 1892 if (fragment_caps->MaxSimultaneousTextures > 1) 1893 return WINED3D_D3D_LEVEL_6; 1894 1895 return WINED3D_D3D_LEVEL_5; 1896 } 1897 1898 static const struct wined3d_renderer_table 1899 { 1900 const char *renderer; 1901 enum wined3d_pci_device id; 1902 } 1903 cards_nvidia_binary[] = 1904 { 1905 /* Direct 3D 11 */ 1906 {"TITAN X (Pascal)", CARD_NVIDIA_TITANX_PASCAL}, /* GeForce 1000 - highend */ 1907 {"GTX 1080 Ti", CARD_NVIDIA_GEFORCE_GTX1080TI}, /* GeForce 1000 - highend */ 1908 {"GTX 1080", CARD_NVIDIA_GEFORCE_GTX1080}, /* GeForce 1000 - highend */ 1909 {"GTX 1070", CARD_NVIDIA_GEFORCE_GTX1070}, /* GeForce 1000 - highend */ 1910 {"GTX 1060", CARD_NVIDIA_GEFORCE_GTX1060}, /* GeForce 1000 - midend high */ 1911 {"GTX 1050", CARD_NVIDIA_GEFORCE_GTX1050}, /* GeForce 1000 - midend */ 1912 {"GTX 980 Ti", CARD_NVIDIA_GEFORCE_GTX980TI}, /* GeForce 900 - highend */ 1913 {"GTX 980", CARD_NVIDIA_GEFORCE_GTX980}, /* GeForce 900 - highend */ 1914 {"GTX 970M", CARD_NVIDIA_GEFORCE_GTX970M}, /* GeForce 900 - highend mobile*/ 1915 {"GTX 970", CARD_NVIDIA_GEFORCE_GTX970}, /* GeForce 900 - highend */ 1916 {"GTX TITAN X", CARD_NVIDIA_GEFORCE_GTXTITANX}, /* Geforce 900 - highend */ 1917 {"GTX 960M", CARD_NVIDIA_GEFORCE_GTX960M}, /* GeForce 900 - midend high mobile */ 1918 {"GTX 960", CARD_NVIDIA_GEFORCE_GTX960}, /* GeForce 900 - midend high */ 1919 {"GTX 950M", CARD_NVIDIA_GEFORCE_GTX950M}, /* GeForce 900 - midend mobile */ 1920 {"GTX 950", CARD_NVIDIA_GEFORCE_GTX950}, /* GeForce 900 - midend */ 1921 {"GeForce 940M", CARD_NVIDIA_GEFORCE_940M}, /* GeForce 900 - midend mobile */ 1922 {"GTX 880M", CARD_NVIDIA_GEFORCE_GTX880M}, /* GeForce 800 - mobile */ 1923 {"GTX 870M", CARD_NVIDIA_GEFORCE_GTX870M}, /* GeForce 800 - mobile */ 1924 {"GTX 860M", CARD_NVIDIA_GEFORCE_GTX860M}, /* GeForce 800 - mobile */ 1925 {"GTX 850M", CARD_NVIDIA_GEFORCE_GTX850M}, /* GeForce 800 - mobile */ 1926 {"GeForce 845M", CARD_NVIDIA_GEFORCE_845M}, /* GeForce 800 - mobile */ 1927 {"GeForce 840M", CARD_NVIDIA_GEFORCE_840M}, /* GeForce 800 - mobile */ 1928 {"GeForce 830M", CARD_NVIDIA_GEFORCE_830M}, /* GeForce 800 - mobile */ 1929 {"GeForce 820M", CARD_NVIDIA_GEFORCE_820M}, /* GeForce 800 - mobile */ 1930 {"GTX 780 Ti", CARD_NVIDIA_GEFORCE_GTX780TI}, /* Geforce 700 - highend */ 1931 {"GTX TITAN Black", CARD_NVIDIA_GEFORCE_GTXTITANB}, /* Geforce 700 - highend */ 1932 {"GTX TITAN Z", CARD_NVIDIA_GEFORCE_GTXTITANZ}, /* Geforce 700 - highend */ 1933 {"GTX TITAN", CARD_NVIDIA_GEFORCE_GTXTITAN}, /* Geforce 700 - highend */ 1934 {"GTX 780", CARD_NVIDIA_GEFORCE_GTX780}, /* Geforce 700 - highend */ 1935 {"GTX 770M", CARD_NVIDIA_GEFORCE_GTX770M}, /* Geforce 700 - midend high mobile */ 1936 {"GTX 770", CARD_NVIDIA_GEFORCE_GTX770}, /* Geforce 700 - highend */ 1937 {"GTX 765M", CARD_NVIDIA_GEFORCE_GTX765M}, /* Geforce 700 - midend high mobile */ 1938 {"GTX 760 Ti", CARD_NVIDIA_GEFORCE_GTX760TI}, /* Geforce 700 - midend high */ 1939 {"GTX 760", CARD_NVIDIA_GEFORCE_GTX760}, /* Geforce 700 - midend high */ 1940 {"GTX 750 Ti", CARD_NVIDIA_GEFORCE_GTX750TI}, /* Geforce 700 - midend */ 1941 {"GTX 750", CARD_NVIDIA_GEFORCE_GTX750}, /* Geforce 700 - midend */ 1942 {"GT 750M", CARD_NVIDIA_GEFORCE_GT750M}, /* Geforce 700 - midend mobile */ 1943 {"GT 740M", CARD_NVIDIA_GEFORCE_GT740M}, /* Geforce 700 - midend mobile */ 1944 {"GT 730M", CARD_NVIDIA_GEFORCE_GT730M}, /* Geforce 700 - midend mobile */ 1945 {"GT 730", CARD_NVIDIA_GEFORCE_GT730}, /* Geforce 700 - lowend */ 1946 {"GTX 690", CARD_NVIDIA_GEFORCE_GTX690}, /* Geforce 600 - highend */ 1947 {"GTX 680", CARD_NVIDIA_GEFORCE_GTX680}, /* Geforce 600 - highend */ 1948 {"GTX 675MX", CARD_NVIDIA_GEFORCE_GTX675MX}, /* Geforce 600 - highend */ 1949 {"GTX 670MX", CARD_NVIDIA_GEFORCE_GTX670MX}, /* Geforce 600 - highend */ 1950 {"GTX 670", CARD_NVIDIA_GEFORCE_GTX670}, /* Geforce 600 - midend high */ 1951 {"GTX 660 Ti", CARD_NVIDIA_GEFORCE_GTX660TI}, /* Geforce 600 - midend high */ 1952 {"GTX 660M", CARD_NVIDIA_GEFORCE_GTX660M}, /* Geforce 600 - midend high mobile */ 1953 {"GTX 660", CARD_NVIDIA_GEFORCE_GTX660}, /* Geforce 600 - midend high */ 1954 {"GTX 650 Ti", CARD_NVIDIA_GEFORCE_GTX650TI}, /* Geforce 600 - lowend */ 1955 {"GTX 650", CARD_NVIDIA_GEFORCE_GTX650}, /* Geforce 600 - lowend */ 1956 {"GT 650M", CARD_NVIDIA_GEFORCE_GT650M}, /* Geforce 600 - midend mobile */ 1957 {"GT 640M", CARD_NVIDIA_GEFORCE_GT640M}, /* Geforce 600 - midend mobile */ 1958 {"GT 630M", CARD_NVIDIA_GEFORCE_GT630M}, /* Geforce 600 - midend mobile */ 1959 {"GT 630", CARD_NVIDIA_GEFORCE_GT630}, /* Geforce 600 - lowend */ 1960 {"GT 610", CARD_NVIDIA_GEFORCE_GT610}, /* Geforce 600 - lowend */ 1961 {"GTX 580", CARD_NVIDIA_GEFORCE_GTX580}, /* Geforce 500 - highend */ 1962 {"GTX 570", CARD_NVIDIA_GEFORCE_GTX570}, /* Geforce 500 - midend high */ 1963 {"GTX 560 Ti", CARD_NVIDIA_GEFORCE_GTX560TI}, /* Geforce 500 - midend */ 1964 {"GTX 560M", CARD_NVIDIA_GEFORCE_GTX560M}, /* Geforce 500 - midend mobile */ 1965 {"GTX 560", CARD_NVIDIA_GEFORCE_GTX560}, /* Geforce 500 - midend */ 1966 {"GT 555M", CARD_NVIDIA_GEFORCE_GT555M}, /* Geforce 500 - midend mobile */ 1967 {"GTX 550 Ti", CARD_NVIDIA_GEFORCE_GTX550}, /* Geforce 500 - midend */ 1968 {"GT 540M", CARD_NVIDIA_GEFORCE_GT540M}, /* Geforce 500 - midend mobile */ 1969 {"GT 525M", CARD_NVIDIA_GEFORCE_GT525M}, /* Geforce 500 - lowend mobile */ 1970 {"GT 520", CARD_NVIDIA_GEFORCE_GT520}, /* Geforce 500 - lowend */ 1971 {"GTX 480", CARD_NVIDIA_GEFORCE_GTX480}, /* Geforce 400 - highend */ 1972 {"GTX 470", CARD_NVIDIA_GEFORCE_GTX470}, /* Geforce 400 - midend high */ 1973 /* Direct 3D 10 */ 1974 {"GTX 465", CARD_NVIDIA_GEFORCE_GTX465}, /* Geforce 400 - midend */ 1975 {"GTX 460M", CARD_NVIDIA_GEFORCE_GTX460M}, /* Geforce 400 - highend mobile */ 1976 {"GTX 460", CARD_NVIDIA_GEFORCE_GTX460}, /* Geforce 400 - midend */ 1977 {"GTS 450", CARD_NVIDIA_GEFORCE_GTS450}, /* Geforce 400 - midend low */ 1978 {"GT 440", CARD_NVIDIA_GEFORCE_GT440}, /* Geforce 400 - lowend */ 1979 {"GT 430", CARD_NVIDIA_GEFORCE_GT430}, /* Geforce 400 - lowend */ 1980 {"GT 425M", CARD_NVIDIA_GEFORCE_GT425M}, /* Geforce 400 - lowend mobile */ 1981 {"GT 420", CARD_NVIDIA_GEFORCE_GT420}, /* Geforce 400 - lowend */ 1982 {"410M", CARD_NVIDIA_GEFORCE_410M}, /* Geforce 400 - lowend mobile */ 1983 {"GT 330", CARD_NVIDIA_GEFORCE_GT330}, /* Geforce 300 - highend */ 1984 {"GTS 360M", CARD_NVIDIA_GEFORCE_GTS350M}, /* Geforce 300 - highend mobile */ 1985 {"GTS 350M", CARD_NVIDIA_GEFORCE_GTS350M}, /* Geforce 300 - highend mobile */ 1986 {"GT 330M", CARD_NVIDIA_GEFORCE_GT325M}, /* Geforce 300 - midend mobile */ 1987 {"GT 325M", CARD_NVIDIA_GEFORCE_GT325M}, /* Geforce 300 - midend mobile */ 1988 {"GT 320M", CARD_NVIDIA_GEFORCE_GT320M}, /* Geforce 300 - midend mobile */ 1989 {"320M", CARD_NVIDIA_GEFORCE_320M}, /* Geforce 300 - midend mobile */ 1990 {"315M", CARD_NVIDIA_GEFORCE_315M}, /* Geforce 300 - midend mobile */ 1991 {"GTX 295", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */ 1992 {"GTX 285", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */ 1993 {"GTX 280", CARD_NVIDIA_GEFORCE_GTX280}, /* Geforce 200 - highend */ 1994 {"GTX 275", CARD_NVIDIA_GEFORCE_GTX275}, /* Geforce 200 - midend high */ 1995 {"GTX 260", CARD_NVIDIA_GEFORCE_GTX260}, /* Geforce 200 - midend */ 1996 {"GTS 250", CARD_NVIDIA_GEFORCE_GTS250}, /* Geforce 200 - midend */ 1997 {"GT 240", CARD_NVIDIA_GEFORCE_GT240}, /* Geforce 200 - midend */ 1998 {"GT 220", CARD_NVIDIA_GEFORCE_GT220}, /* Geforce 200 - lowend */ 1999 {"GeForce 310", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */ 2000 {"GeForce 305", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */ 2001 {"GeForce 210", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */ 2002 {"G 210", CARD_NVIDIA_GEFORCE_210}, /* Geforce 200 - lowend */ 2003 {"GTS 150", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */ 2004 {"9800", CARD_NVIDIA_GEFORCE_9800GT}, /* Geforce 9 - highend / Geforce 200 - midend */ 2005 {"9700M GT", CARD_NVIDIA_GEFORCE_9700MGT}, /* Geforce 9 - midend */ 2006 {"GT 140", CARD_NVIDIA_GEFORCE_9600GT}, /* Geforce 9 - midend */ 2007 {"9600", CARD_NVIDIA_GEFORCE_9600GT}, /* Geforce 9 - midend */ 2008 {"GT 130", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */ 2009 {"GT 120", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */ 2010 {"9500", CARD_NVIDIA_GEFORCE_9500GT}, /* Geforce 9 - midend low / Geforce 200 - low */ 2011 {"9400M", CARD_NVIDIA_GEFORCE_9400M}, /* Geforce 9 - lowend */ 2012 {"9400", CARD_NVIDIA_GEFORCE_9400GT}, /* Geforce 9 - lowend */ 2013 {"9300", CARD_NVIDIA_GEFORCE_9300}, /* Geforce 9 - lowend low */ 2014 {"9200", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */ 2015 {"9100", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */ 2016 {"G 100", CARD_NVIDIA_GEFORCE_9200}, /* Geforce 9 - lowend low */ 2017 {"8800 GTX", CARD_NVIDIA_GEFORCE_8800GTX}, /* Geforce 8 - highend high */ 2018 {"8800", CARD_NVIDIA_GEFORCE_8800GTS}, /* Geforce 8 - highend */ 2019 {"8600M", CARD_NVIDIA_GEFORCE_8600MGT}, /* Geforce 8 - midend mobile */ 2020 {"8600 M", CARD_NVIDIA_GEFORCE_8600MGT}, /* Geforce 8 - midend mobile */ 2021 {"8700", CARD_NVIDIA_GEFORCE_8600GT}, /* Geforce 8 - midend */ 2022 {"8600", CARD_NVIDIA_GEFORCE_8600GT}, /* Geforce 8 - midend */ 2023 {"8500", CARD_NVIDIA_GEFORCE_8500GT}, /* Geforce 8 - mid-lowend */ 2024 {"8400", CARD_NVIDIA_GEFORCE_8400GS}, /* Geforce 8 - mid-lowend */ 2025 {"8300", CARD_NVIDIA_GEFORCE_8300GS}, /* Geforce 8 - lowend */ 2026 {"8200", CARD_NVIDIA_GEFORCE_8200}, /* Geforce 8 - lowend */ 2027 {"8100", CARD_NVIDIA_GEFORCE_8200}, /* Geforce 8 - lowend */ 2028 /* Direct 3D 9 SM3 */ 2029 {"Quadro FX 5", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */ 2030 {"Quadro FX 4", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */ 2031 {"7950", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */ 2032 {"7900", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */ 2033 {"7800", CARD_NVIDIA_GEFORCE_7800GT}, /* Geforce 7 - highend */ 2034 {"7700", CARD_NVIDIA_GEFORCE_7600}, /* Geforce 7 - midend */ 2035 {"7600", CARD_NVIDIA_GEFORCE_7600}, /* Geforce 7 - midend */ 2036 {"7400", CARD_NVIDIA_GEFORCE_7400}, /* Geforce 7 - lower medium */ 2037 {"7300", CARD_NVIDIA_GEFORCE_7300}, /* Geforce 7 - lowend */ 2038 {"6800", CARD_NVIDIA_GEFORCE_6800}, /* Geforce 6 - highend */ 2039 {"6700", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */ 2040 {"6610", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */ 2041 {"6600", CARD_NVIDIA_GEFORCE_6600GT}, /* Geforce 6 - midend */ 2042 /* Direct 3D 9 SM2 */ 2043 {"Quadro FX", CARD_NVIDIA_GEFORCEFX_5800}, /* GeforceFX - highend */ 2044 {"5950", CARD_NVIDIA_GEFORCEFX_5800}, /* GeforceFX - highend */ 2045 {"5900", CARD_NVIDIA_GEFORCEFX_5800}, /* GeforceFX - highend */ 2046 {"5800", CARD_NVIDIA_GEFORCEFX_5800}, /* GeforceFX - highend */ 2047 {"5750", CARD_NVIDIA_GEFORCEFX_5600}, /* GeforceFX - midend */ 2048 {"5700", CARD_NVIDIA_GEFORCEFX_5600}, /* GeforceFX - midend */ 2049 {"5650", CARD_NVIDIA_GEFORCEFX_5600}, /* GeforceFX - midend */ 2050 {"5600", CARD_NVIDIA_GEFORCEFX_5600}, /* GeforceFX - midend */ 2051 {"5500", CARD_NVIDIA_GEFORCEFX_5200}, /* GeforceFX - lowend */ 2052 {"5300", CARD_NVIDIA_GEFORCEFX_5200}, /* GeforceFX - lowend */ 2053 {"5250", CARD_NVIDIA_GEFORCEFX_5200}, /* GeforceFX - lowend */ 2054 {"5200", CARD_NVIDIA_GEFORCEFX_5200}, /* GeforceFX - lowend */ 2055 {"5100", CARD_NVIDIA_GEFORCEFX_5200}, /* GeforceFX - lowend */ 2056 /* Direct 3D 8 */ 2057 {"Quadro4", CARD_NVIDIA_GEFORCE4_TI4200}, 2058 {"GeForce4 Ti", CARD_NVIDIA_GEFORCE4_TI4200}, /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800 */ 2059 /* Direct 3D 7 */ 2060 {"GeForce4 MX", CARD_NVIDIA_GEFORCE4_MX}, /* MX420/MX440/MX460/MX4000 */ 2061 {"Quadro2 MXR", CARD_NVIDIA_GEFORCE2_MX}, 2062 {"GeForce2 MX", CARD_NVIDIA_GEFORCE2_MX}, /* Geforce2 standard/MX100/MX200/MX400 */ 2063 {"Quadro2", CARD_NVIDIA_GEFORCE2}, 2064 {"GeForce2", CARD_NVIDIA_GEFORCE2}, /* Geforce2 GTS/Pro/Ti/Ultra */ 2065 /* Direct 3D 6 */ 2066 {"TNT2", CARD_NVIDIA_RIVA_TNT2}, /* Riva TNT2 standard/M64/Pro/Ultra */ 2067 }, 2068 /* See http://developer.amd.com/resources/hardware-drivers/ati-catalyst-pc-vendor-id-1002-li/ 2069 * 2070 * Beware: renderer string do not match exact card model, 2071 * eg HD 4800 is returned for multiple cards, even for RV790 based ones. */ 2072 cards_amd_binary[] = 2073 { 2074 {"RX 480", CARD_AMD_RADEON_RX_480}, 2075 {"RX 460", CARD_AMD_RADEON_RX_460}, 2076 {"R9 Fury Series", CARD_AMD_RADEON_R9_FURY}, 2077 /* Southern Islands */ 2078 {"HD 7900", CARD_AMD_RADEON_HD7900}, 2079 {"HD 7800", CARD_AMD_RADEON_HD7800}, 2080 {"HD 7700", CARD_AMD_RADEON_HD7700}, 2081 /* Northern Islands */ 2082 {"HD 6970", CARD_AMD_RADEON_HD6900}, 2083 {"HD 6900", CARD_AMD_RADEON_HD6900}, 2084 {"HD 6800", CARD_AMD_RADEON_HD6800}, 2085 {"HD 6770M", CARD_AMD_RADEON_HD6600M}, 2086 {"HD 6750M", CARD_AMD_RADEON_HD6600M}, 2087 {"HD 6700", CARD_AMD_RADEON_HD6700}, 2088 {"HD 6670", CARD_AMD_RADEON_HD6600}, 2089 {"HD 6630M", CARD_AMD_RADEON_HD6600M}, 2090 {"HD 6600M", CARD_AMD_RADEON_HD6600M}, 2091 {"HD 6600", CARD_AMD_RADEON_HD6600}, 2092 {"HD 6570", CARD_AMD_RADEON_HD6600}, 2093 {"HD 6500M", CARD_AMD_RADEON_HD6600M}, 2094 {"HD 6500", CARD_AMD_RADEON_HD6600}, 2095 {"HD 6480G", CARD_AMD_RADEON_HD6480G}, 2096 {"HD 6400", CARD_AMD_RADEON_HD6400}, 2097 {"HD 6300", CARD_AMD_RADEON_HD6300}, 2098 {"HD 6200", CARD_AMD_RADEON_HD6300}, 2099 /* Evergreen */ 2100 {"HD 5870", CARD_AMD_RADEON_HD5800}, /* Radeon EG CYPRESS PRO */ 2101 {"HD 5850", CARD_AMD_RADEON_HD5800}, /* Radeon EG CYPRESS XT */ 2102 {"HD 5800", CARD_AMD_RADEON_HD5800}, /* Radeon EG CYPRESS HD58xx generic renderer string */ 2103 {"HD 5770", CARD_AMD_RADEON_HD5700}, /* Radeon EG JUNIPER XT */ 2104 {"HD 5750", CARD_AMD_RADEON_HD5700}, /* Radeon EG JUNIPER LE */ 2105 {"HD 5700", CARD_AMD_RADEON_HD5700}, /* Radeon EG JUNIPER HD57xx generic renderer string */ 2106 {"HD 5670", CARD_AMD_RADEON_HD5600}, /* Radeon EG REDWOOD XT */ 2107 {"HD 5570", CARD_AMD_RADEON_HD5600}, /* Radeon EG REDWOOD PRO mapped to HD5600 series */ 2108 {"HD 5550", CARD_AMD_RADEON_HD5600}, /* Radeon EG REDWOOD LE mapped to HD5600 series */ 2109 {"HD 5450", CARD_AMD_RADEON_HD5400}, /* Radeon EG CEDAR PRO */ 2110 {"HD 5000", CARD_AMD_RADEON_HD5600}, /* Defaulting to HD 5600 */ 2111 /* R700 */ 2112 {"HD 4890", CARD_AMD_RADEON_HD4800}, /* Radeon RV790 */ 2113 {"HD 4870", CARD_AMD_RADEON_HD4800}, /* Radeon RV770 */ 2114 {"HD 4850", CARD_AMD_RADEON_HD4800}, /* Radeon RV770 */ 2115 {"HD 4830", CARD_AMD_RADEON_HD4800}, /* Radeon RV770 */ 2116 {"HD 4800", CARD_AMD_RADEON_HD4800}, /* Radeon RV7xx HD48xx generic renderer string */ 2117 {"HD 4770", CARD_AMD_RADEON_HD4700}, /* Radeon RV740 */ 2118 {"HD 4700", CARD_AMD_RADEON_HD4700}, /* Radeon RV7xx HD47xx generic renderer string */ 2119 {"HD 4670", CARD_AMD_RADEON_HD4600}, /* Radeon RV730 */ 2120 {"HD 4650", CARD_AMD_RADEON_HD4600}, /* Radeon RV730 */ 2121 {"HD 4600", CARD_AMD_RADEON_HD4600}, /* Radeon RV730 */ 2122 {"HD 4550", CARD_AMD_RADEON_HD4350}, /* Radeon RV710 */ 2123 {"HD 4350", CARD_AMD_RADEON_HD4350}, /* Radeon RV710 */ 2124 /* R600/R700 integrated */ 2125 {"HD 4200M", CARD_AMD_RADEON_HD4200M}, 2126 {"HD 3300", CARD_AMD_RADEON_HD3200}, 2127 {"HD 3200", CARD_AMD_RADEON_HD3200}, 2128 {"HD 3100", CARD_AMD_RADEON_HD3200}, 2129 /* R600 */ 2130 {"HD 3870", CARD_AMD_RADEON_HD2900}, /* HD2900/HD3800 - highend */ 2131 {"HD 3850", CARD_AMD_RADEON_HD2900}, /* HD2900/HD3800 - highend */ 2132 {"HD 2900", CARD_AMD_RADEON_HD2900}, /* HD2900/HD3800 - highend */ 2133 {"HD 3830", CARD_AMD_RADEON_HD2600}, /* China-only midend */ 2134 {"HD 3690", CARD_AMD_RADEON_HD2600}, /* HD2600/HD3600 - midend */ 2135 {"HD 3650", CARD_AMD_RADEON_HD2600}, /* HD2600/HD3600 - midend */ 2136 {"HD 2600", CARD_AMD_RADEON_HD2600}, /* HD2600/HD3600 - midend */ 2137 {"HD 3470", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */ 2138 {"HD 3450", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */ 2139 {"HD 3430", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */ 2140 {"HD 3400", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */ 2141 {"HD 2400", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */ 2142 {"HD 2350", CARD_AMD_RADEON_HD2350}, /* HD2350/HD2400/HD3400 - lowend */ 2143 /* Radeon R5xx */ 2144 {"X1950", CARD_AMD_RADEON_X1600}, 2145 {"X1900", CARD_AMD_RADEON_X1600}, 2146 {"X1800", CARD_AMD_RADEON_X1600}, 2147 {"X1650", CARD_AMD_RADEON_X1600}, 2148 {"X1600", CARD_AMD_RADEON_X1600}, 2149 /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx) 2150 * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */ 2151 {"HD 2300", CARD_AMD_RADEON_X700}, 2152 {"X2500", CARD_AMD_RADEON_X700}, 2153 {"X2300", CARD_AMD_RADEON_X700}, 2154 {"X1550", CARD_AMD_RADEON_X700}, 2155 {"X1450", CARD_AMD_RADEON_X700}, 2156 {"X1400", CARD_AMD_RADEON_X700}, 2157 {"X1300", CARD_AMD_RADEON_X700}, 2158 {"X850", CARD_AMD_RADEON_X700}, 2159 {"X800", CARD_AMD_RADEON_X700}, 2160 {"X700", CARD_AMD_RADEON_X700}, 2161 /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400 MHz */ 2162 {"Radeon Xpress", CARD_AMD_RADEON_XPRESS_200M}, 2163 }, 2164 cards_intel[] = 2165 { 2166 /* Skylake */ 2167 {"Iris Pro Graphics P580", CARD_INTEL_IPP580_1}, 2168 {"Skylake", CARD_INTEL_HD520_1}, 2169 /* Broadwell */ 2170 {"Iris Pro P6300", CARD_INTEL_IPP6300}, 2171 {"Iris Pro 6200", CARD_INTEL_IP6200}, 2172 {"Iris 6100", CARD_INTEL_I6100}, 2173 {"Iris(TM) Graphics 6100", CARD_INTEL_I6100}, /* MacOS */ 2174 /* Haswell */ 2175 {"Iris Pro 5200", CARD_INTEL_IP5200_1}, 2176 {"Iris 5100", CARD_INTEL_I5100_1}, 2177 {"HD Graphics 5000", CARD_INTEL_HD5000}, /* MacOS */ 2178 {"Haswell Mobile", CARD_INTEL_HWM}, 2179 {"Iris OpenGL Engine", CARD_INTEL_HWM}, /* MacOS */ 2180 /* Ivybridge */ 2181 {"Ivybridge Server", CARD_INTEL_IVBS}, 2182 {"Ivybridge Mobile", CARD_INTEL_IVBM}, 2183 {"Ivybridge Desktop", CARD_INTEL_IVBD}, 2184 {"HD Graphics 4000", CARD_INTEL_IVBD}, /* MacOS */ 2185 /* Sandybridge */ 2186 {"Sandybridge Server", CARD_INTEL_SNBS}, 2187 {"Sandybridge Mobile", CARD_INTEL_SNBM}, 2188 {"Sandybridge Desktop", CARD_INTEL_SNBD}, 2189 /* Ironlake */ 2190 {"Ironlake Mobile", CARD_INTEL_ILKM}, 2191 {"Ironlake Desktop", CARD_INTEL_ILKD}, 2192 /* G4x */ 2193 {"B43", CARD_INTEL_B43}, 2194 {"G41", CARD_INTEL_G41}, 2195 {"G45", CARD_INTEL_G45}, 2196 {"Q45", CARD_INTEL_Q45}, 2197 {"Integrated Graphics Device", CARD_INTEL_IGD}, 2198 {"GM45", CARD_INTEL_GM45}, 2199 /* i965 */ 2200 {"965GME", CARD_INTEL_965GME}, 2201 {"965GM", CARD_INTEL_965GM}, 2202 {"X3100", CARD_INTEL_965GM}, /* MacOS */ 2203 {"946GZ", CARD_INTEL_946GZ}, 2204 {"965G", CARD_INTEL_965G}, 2205 {"965Q", CARD_INTEL_965Q}, 2206 /* i945 */ 2207 {"Pineview M", CARD_INTEL_PNVM}, 2208 {"Pineview G", CARD_INTEL_PNVG}, 2209 {"IGD", CARD_INTEL_PNVG}, 2210 {"Q33", CARD_INTEL_Q33}, 2211 {"G33", CARD_INTEL_G33}, 2212 {"Q35", CARD_INTEL_Q35}, 2213 {"945GME", CARD_INTEL_945GME}, 2214 {"945GM", CARD_INTEL_945GM}, 2215 {"GMA 950", CARD_INTEL_945GM}, /* MacOS */ 2216 {"945G", CARD_INTEL_945G}, 2217 /* i915 */ 2218 {"915GM", CARD_INTEL_915GM}, 2219 {"E7221G", CARD_INTEL_E7221G}, 2220 {"915G", CARD_INTEL_915G}, 2221 /* i8xx */ 2222 {"865G", CARD_INTEL_865G}, 2223 {"845G", CARD_INTEL_845G}, 2224 {"855GM", CARD_INTEL_855GM}, 2225 {"830M", CARD_INTEL_830M}, 2226 }, 2227 /* 20101109 - These are never returned by current Gallium radeon 2228 * drivers: R700, RV790, R680, RV535, RV516, R410, RS485, RV360, RV351. 2229 * 2230 * These are returned but not handled: RC410, RV380. */ 2231 cards_amd_mesa[] = 2232 { 2233 /* Polaris 10/11 */ 2234 {"POLARIS10", CARD_AMD_RADEON_RX_480}, 2235 {"POLARIS11", CARD_AMD_RADEON_RX_460}, 2236 /* Volcanic Islands */ 2237 {"FIJI", CARD_AMD_RADEON_R9_FURY}, 2238 {"TONGA", CARD_AMD_RADEON_R9_285}, 2239 /* Sea Islands */ 2240 {"HAWAII", CARD_AMD_RADEON_R9_290}, 2241 {"KAVERI", CARD_AMD_RADEON_R7 }, 2242 {"KABINI", CARD_AMD_RADEON_R3 }, 2243 {"BONAIRE", CARD_AMD_RADEON_HD8770}, 2244 /* Southern Islands */ 2245 {"OLAND", CARD_AMD_RADEON_HD8670}, 2246 {"HAINAN", CARD_AMD_RADEON_HD8600M}, 2247 {"TAHITI", CARD_AMD_RADEON_HD7900}, 2248 {"PITCAIRN", CARD_AMD_RADEON_HD7800}, 2249 {"CAPE VERDE", CARD_AMD_RADEON_HD7700}, 2250 /* Northern Islands */ 2251 {"ARUBA", CARD_AMD_RADEON_HD7660D}, 2252 {"CAYMAN", CARD_AMD_RADEON_HD6900}, 2253 {"BARTS", CARD_AMD_RADEON_HD6800}, 2254 {"TURKS", CARD_AMD_RADEON_HD6600}, 2255 {"SUMO2", CARD_AMD_RADEON_HD6410D}, /* SUMO2 first, because we do a strstr(). */ 2256 {"SUMO", CARD_AMD_RADEON_HD6550D}, 2257 {"CAICOS", CARD_AMD_RADEON_HD6400}, 2258 {"PALM", CARD_AMD_RADEON_HD6300}, 2259 /* Evergreen */ 2260 {"HEMLOCK", CARD_AMD_RADEON_HD5900}, 2261 {"CYPRESS", CARD_AMD_RADEON_HD5800}, 2262 {"JUNIPER", CARD_AMD_RADEON_HD5700}, 2263 {"REDWOOD", CARD_AMD_RADEON_HD5600}, 2264 {"CEDAR", CARD_AMD_RADEON_HD5400}, 2265 /* R700 */ 2266 {"R700", CARD_AMD_RADEON_HD4800}, 2267 {"RV790", CARD_AMD_RADEON_HD4800}, 2268 {"RV770", CARD_AMD_RADEON_HD4800}, 2269 {"RV740", CARD_AMD_RADEON_HD4700}, 2270 {"RV730", CARD_AMD_RADEON_HD4600}, 2271 {"RV710", CARD_AMD_RADEON_HD4350}, 2272 /* R600/R700 integrated */ 2273 {"RS880", CARD_AMD_RADEON_HD4200M}, 2274 {"RS780", CARD_AMD_RADEON_HD3200}, 2275 /* R600 */ 2276 {"R680", CARD_AMD_RADEON_HD2900}, 2277 {"R600", CARD_AMD_RADEON_HD2900}, 2278 {"RV670", CARD_AMD_RADEON_HD3850}, 2279 {"RV635", CARD_AMD_RADEON_HD2600}, 2280 {"RV630", CARD_AMD_RADEON_HD2600}, 2281 {"RV620", CARD_AMD_RADEON_HD2350}, 2282 {"RV610", CARD_AMD_RADEON_HD2350}, 2283 /* R500 */ 2284 {"R580", CARD_AMD_RADEON_X1600}, 2285 {"R520", CARD_AMD_RADEON_X1600}, 2286 {"RV570", CARD_AMD_RADEON_X1600}, 2287 {"RV560", CARD_AMD_RADEON_X1600}, 2288 {"RV535", CARD_AMD_RADEON_X1600}, 2289 {"RV530", CARD_AMD_RADEON_X1600}, 2290 {"RV516", CARD_AMD_RADEON_X700}, 2291 {"RV515", CARD_AMD_RADEON_X700}, 2292 /* R400 */ 2293 {"R481", CARD_AMD_RADEON_X700}, 2294 {"R480", CARD_AMD_RADEON_X700}, 2295 {"R430", CARD_AMD_RADEON_X700}, 2296 {"R423", CARD_AMD_RADEON_X700}, 2297 {"R420", CARD_AMD_RADEON_X700}, 2298 {"R410", CARD_AMD_RADEON_X700}, 2299 {"RV410", CARD_AMD_RADEON_X700}, 2300 /* Radeon Xpress - onboard, DX9b, Shader 2.0, 300-400 MHz */ 2301 {"RS740", CARD_AMD_RADEON_XPRESS_200M}, 2302 {"RS690", CARD_AMD_RADEON_XPRESS_200M}, 2303 {"RS600", CARD_AMD_RADEON_XPRESS_200M}, 2304 {"RS485", CARD_AMD_RADEON_XPRESS_200M}, 2305 {"RS482", CARD_AMD_RADEON_XPRESS_200M}, 2306 {"RS480", CARD_AMD_RADEON_XPRESS_200M}, 2307 {"RS400", CARD_AMD_RADEON_XPRESS_200M}, 2308 /* R300 */ 2309 {"R360", CARD_AMD_RADEON_9500}, 2310 {"R350", CARD_AMD_RADEON_9500}, 2311 {"R300", CARD_AMD_RADEON_9500}, 2312 {"RV370", CARD_AMD_RADEON_9500}, 2313 {"RV360", CARD_AMD_RADEON_9500}, 2314 {"RV351", CARD_AMD_RADEON_9500}, 2315 {"RV350", CARD_AMD_RADEON_9500}, 2316 }, 2317 cards_nvidia_mesa[] = 2318 { 2319 /* Maxwell */ 2320 {"NV124", CARD_NVIDIA_GEFORCE_GTX970}, 2321 {"NV120", CARD_NVIDIA_GEFORCE_GTX980TI}, 2322 {"NV118", CARD_NVIDIA_GEFORCE_840M}, 2323 {"NV117", CARD_NVIDIA_GEFORCE_GTX750}, 2324 /* Kepler */ 2325 {"NV108", CARD_NVIDIA_GEFORCE_GT740M}, 2326 {"NVF1", CARD_NVIDIA_GEFORCE_GTX780TI}, 2327 {"NVF0", CARD_NVIDIA_GEFORCE_GTX780}, 2328 {"NVE6", CARD_NVIDIA_GEFORCE_GTX770M}, 2329 {"NVE4", CARD_NVIDIA_GEFORCE_GTX680}, /* 690 / 675MX / 760TI */ 2330 /* Fermi */ 2331 {"NVD9", CARD_NVIDIA_GEFORCE_GT520}, 2332 {"NVD7", CARD_NVIDIA_GEFORCE_820M}, 2333 {"NVCF", CARD_NVIDIA_GEFORCE_GTX550}, 2334 {"NVCE", CARD_NVIDIA_GEFORCE_GTX560}, 2335 {"NVC8", CARD_NVIDIA_GEFORCE_GTX570}, 2336 {"NVC4", CARD_NVIDIA_GEFORCE_GTX460}, 2337 {"NVC3", CARD_NVIDIA_GEFORCE_GT440}, 2338 {"NVC1", CARD_NVIDIA_GEFORCE_GT420}, 2339 {"NVC0", CARD_NVIDIA_GEFORCE_GTX480}, 2340 /* Tesla */ 2341 {"NVAF", CARD_NVIDIA_GEFORCE_GT320M}, 2342 {"NVAC", CARD_NVIDIA_GEFORCE_8200}, 2343 {"NVAA", CARD_NVIDIA_GEFORCE_8200}, /* 8100 */ 2344 {"NVA8", CARD_NVIDIA_GEFORCE_210}, 2345 {"NVA5", CARD_NVIDIA_GEFORCE_GT220}, 2346 {"NVA3", CARD_NVIDIA_GEFORCE_GT240}, 2347 {"NVA0", CARD_NVIDIA_GEFORCE_GTX280}, 2348 {"NV98", CARD_NVIDIA_GEFORCE_9200}, 2349 {"NV96", CARD_NVIDIA_GEFORCE_9400GT}, 2350 {"NV94", CARD_NVIDIA_GEFORCE_9600GT}, 2351 {"NV92", CARD_NVIDIA_GEFORCE_9800GT}, 2352 {"NV86", CARD_NVIDIA_GEFORCE_8500GT}, 2353 {"NV84", CARD_NVIDIA_GEFORCE_8600GT}, 2354 {"NV50", CARD_NVIDIA_GEFORCE_8800GTX}, 2355 /* Curie */ 2356 {"NV68", CARD_NVIDIA_GEFORCE_6200}, /* 7050 */ 2357 {"NV67", CARD_NVIDIA_GEFORCE_6200}, /* 7000M */ 2358 {"NV63", CARD_NVIDIA_GEFORCE_6200}, /* 7100 */ 2359 {"NV4E", CARD_NVIDIA_GEFORCE_6200}, /* 6100 Go / 6150 Go */ 2360 {"NV4C", CARD_NVIDIA_GEFORCE_6200}, /* 6150SE */ 2361 {"NV4B", CARD_NVIDIA_GEFORCE_7600}, 2362 {"NV4A", CARD_NVIDIA_GEFORCE_6200}, 2363 {"NV49", CARD_NVIDIA_GEFORCE_7800GT}, /* 7900 */ 2364 {"NV47", CARD_NVIDIA_GEFORCE_7800GT}, 2365 {"NV46", CARD_NVIDIA_GEFORCE_7400}, 2366 {"NV45", CARD_NVIDIA_GEFORCE_6800}, 2367 {"NV44", CARD_NVIDIA_GEFORCE_6200}, 2368 {"NV43", CARD_NVIDIA_GEFORCE_6600GT}, 2369 {"NV42", CARD_NVIDIA_GEFORCE_6800}, 2370 {"NV41", CARD_NVIDIA_GEFORCE_6800}, 2371 {"NV40", CARD_NVIDIA_GEFORCE_6800}, 2372 /* Rankine */ 2373 {"NV38", CARD_NVIDIA_GEFORCEFX_5800}, /* FX 5950 Ultra */ 2374 {"NV36", CARD_NVIDIA_GEFORCEFX_5800}, /* FX 5700/5750 */ 2375 {"NV35", CARD_NVIDIA_GEFORCEFX_5800}, /* FX 5900 */ 2376 {"NV34", CARD_NVIDIA_GEFORCEFX_5200}, 2377 {"NV31", CARD_NVIDIA_GEFORCEFX_5600}, 2378 {"NV30", CARD_NVIDIA_GEFORCEFX_5800}, 2379 /* Kelvin */ 2380 {"nv28", CARD_NVIDIA_GEFORCE4_TI4200}, 2381 {"nv25", CARD_NVIDIA_GEFORCE4_TI4200}, 2382 {"nv20", CARD_NVIDIA_GEFORCE3}, 2383 /* Celsius */ 2384 {"nv1F", CARD_NVIDIA_GEFORCE4_MX}, /* GF4 MX IGP */ 2385 {"nv1A", CARD_NVIDIA_GEFORCE2}, /* GF2 IGP */ 2386 {"nv18", CARD_NVIDIA_GEFORCE4_MX}, 2387 {"nv17", CARD_NVIDIA_GEFORCE4_MX}, 2388 {"nv16", CARD_NVIDIA_GEFORCE2}, 2389 {"nv15", CARD_NVIDIA_GEFORCE2}, 2390 {"nv11", CARD_NVIDIA_GEFORCE2_MX}, 2391 {"nv10", CARD_NVIDIA_GEFORCE}, 2392 /* Fahrenheit */ 2393 {"nv05", CARD_NVIDIA_RIVA_TNT2}, 2394 {"nv04", CARD_NVIDIA_RIVA_TNT}, 2395 {"nv03", CARD_NVIDIA_RIVA_128}, 2396 }, 2397 cards_vmware[] = 2398 { 2399 {"SVGA3D", CARD_VMWARE_SVGA3D}, 2400 }; 2401 2402 static const struct gl_vendor_selection 2403 { 2404 enum wined3d_gl_vendor gl_vendor; 2405 const char *description; /* Description of the card selector i.e. Apple OS/X Intel */ 2406 const struct wined3d_renderer_table *cards; /* To be used as cards[], pointer to the first member in an array */ 2407 size_t cards_size; /* Number of entries in the array above */ 2408 } 2409 amd_gl_vendor_table[] = 2410 { 2411 {GL_VENDOR_APPLE, "Apple OSX AMD/ATI binary driver", cards_amd_binary, ARRAY_SIZE(cards_amd_binary)}, 2412 {GL_VENDOR_FGLRX, "AMD/ATI binary driver", cards_amd_binary, ARRAY_SIZE(cards_amd_binary)}, 2413 {GL_VENDOR_MESA, "Mesa AMD/ATI driver", cards_amd_mesa, ARRAY_SIZE(cards_amd_mesa)}, 2414 }, 2415 nvidia_gl_vendor_table[] = 2416 { 2417 {GL_VENDOR_APPLE, "Apple OSX NVidia binary driver", cards_nvidia_binary, ARRAY_SIZE(cards_nvidia_binary)}, 2418 {GL_VENDOR_MESA, "Mesa Nouveau driver", cards_nvidia_mesa, ARRAY_SIZE(cards_nvidia_mesa)}, 2419 {GL_VENDOR_NVIDIA, "Nvidia binary driver", cards_nvidia_binary, ARRAY_SIZE(cards_nvidia_binary)}, 2420 }, 2421 vmware_gl_vendor_table[] = 2422 { 2423 {GL_VENDOR_MESA, "VMware driver", cards_vmware, ARRAY_SIZE(cards_vmware)}, 2424 }, 2425 intel_gl_vendor_table[] = 2426 { 2427 {GL_VENDOR_APPLE, "Apple OSX Intel binary driver", cards_intel, ARRAY_SIZE(cards_intel)}, 2428 {GL_VENDOR_MESA, "Mesa Intel driver", cards_intel, ARRAY_SIZE(cards_intel)}, 2429 }; 2430 2431 static const enum wined3d_pci_device 2432 card_fallback_nvidia[] = 2433 { 2434 CARD_NVIDIA_RIVA_128, /* D3D5 */ 2435 CARD_NVIDIA_RIVA_TNT, /* D3D6 */ 2436 CARD_NVIDIA_GEFORCE, /* D3D7 */ 2437 CARD_NVIDIA_GEFORCE3, /* D3D8 */ 2438 CARD_NVIDIA_GEFORCEFX_5800, /* D3D9_SM2 */ 2439 CARD_NVIDIA_GEFORCE_6800, /* D3D9_SM3 */ 2440 CARD_NVIDIA_GEFORCE_8800GTX, /* D3D10 */ 2441 CARD_NVIDIA_GEFORCE_GTX470, /* D3D11 */ 2442 }, 2443 card_fallback_amd[] = 2444 { 2445 CARD_AMD_RAGE_128PRO, /* D3D5 */ 2446 CARD_AMD_RAGE_128PRO, /* D3D6 */ 2447 CARD_AMD_RADEON_7200, /* D3D7 */ 2448 CARD_AMD_RADEON_8500, /* D3D8 */ 2449 CARD_AMD_RADEON_9500, /* D3D9_SM2 */ 2450 CARD_AMD_RADEON_X1600, /* D3D9_SM3 */ 2451 CARD_AMD_RADEON_HD2900, /* D3D10 */ 2452 CARD_AMD_RADEON_HD5600, /* D3D11 */ 2453 }, 2454 card_fallback_intel[] = 2455 { 2456 CARD_INTEL_845G, /* D3D5 */ 2457 CARD_INTEL_845G, /* D3D6 */ 2458 CARD_INTEL_845G, /* D3D7 */ 2459 CARD_INTEL_915G, /* D3D8 */ 2460 CARD_INTEL_915G, /* D3D9_SM2 */ 2461 CARD_INTEL_945G, /* D3D9_SM3 */ 2462 CARD_INTEL_G45, /* D3D10 */ 2463 CARD_INTEL_IVBD, /* D3D11 */ 2464 }; 2465 C_ASSERT(ARRAY_SIZE(card_fallback_nvidia) == WINED3D_D3D_LEVEL_COUNT); 2466 C_ASSERT(ARRAY_SIZE(card_fallback_amd) == WINED3D_D3D_LEVEL_COUNT); 2467 C_ASSERT(ARRAY_SIZE(card_fallback_intel) == WINED3D_D3D_LEVEL_COUNT); 2468 2469 static enum wined3d_pci_device select_card_handler(const struct gl_vendor_selection *table, 2470 unsigned int table_size, enum wined3d_gl_vendor gl_vendor, const char *gl_renderer) 2471 { 2472 unsigned int i, j; 2473 2474 for (i = 0; i < table_size; ++i) 2475 { 2476 if (table[i].gl_vendor != gl_vendor) 2477 continue; 2478 2479 TRACE("Applying card selector \"%s\".\n", table[i].description); 2480 2481 for (j = 0; j < table[i].cards_size; ++j) 2482 { 2483 if (strstr(gl_renderer, table[i].cards[j].renderer)) 2484 return table[i].cards[j].id; 2485 } 2486 return PCI_DEVICE_NONE; 2487 } 2488 FIXME("Couldn't find a suitable card selector for GL vendor %04x (using GL_RENDERER %s)\n", 2489 gl_vendor, debugstr_a(gl_renderer)); 2490 2491 return PCI_DEVICE_NONE; 2492 } 2493 2494 static const struct 2495 { 2496 enum wined3d_pci_vendor card_vendor; 2497 const char *description; /* Description of the card selector i.e. Apple OS/X Intel */ 2498 const struct gl_vendor_selection *gl_vendor_selection; 2499 unsigned int gl_vendor_count; 2500 const enum wined3d_pci_device *card_fallback; /* An array with D3D_LEVEL_COUNT elements */ 2501 } 2502 card_vendor_table[] = 2503 { 2504 {HW_VENDOR_AMD, "AMD", amd_gl_vendor_table, 2505 ARRAY_SIZE(amd_gl_vendor_table), 2506 card_fallback_amd}, 2507 {HW_VENDOR_NVIDIA, "Nvidia", nvidia_gl_vendor_table, 2508 ARRAY_SIZE(nvidia_gl_vendor_table), 2509 card_fallback_nvidia}, 2510 {HW_VENDOR_VMWARE, "VMware", vmware_gl_vendor_table, 2511 ARRAY_SIZE(vmware_gl_vendor_table), 2512 card_fallback_amd}, 2513 {HW_VENDOR_INTEL, "Intel", intel_gl_vendor_table, 2514 ARRAY_SIZE(intel_gl_vendor_table), 2515 card_fallback_intel}, 2516 }; 2517 2518 2519 static enum wined3d_pci_device wined3d_guess_card(const struct shader_caps *shader_caps, const struct fragment_caps *fragment_caps, 2520 DWORD glsl_version, const char *gl_renderer, enum wined3d_gl_vendor *gl_vendor, enum wined3d_pci_vendor *card_vendor) 2521 { 2522 /* A Direct3D device object contains the PCI id (vendor + device) of the 2523 * videocard which is used for rendering. Various applications use this 2524 * information to get a rough estimation of the features of the card and 2525 * some might use it for enabling 3d effects only on certain types of 2526 * videocards. In some cases games might even use it to work around bugs 2527 * which happen on certain videocards/driver combinations. The problem is 2528 * that OpenGL only exposes a rendering string containing the name of the 2529 * videocard and not the PCI id. 2530 * 2531 * Various games depend on the PCI id, so somehow we need to provide one. 2532 * A simple option is to parse the renderer string and translate this to 2533 * the right PCI id. This is a lot of work because there are more than 200 2534 * GPUs just for Nvidia. Various cards share the same renderer string, so 2535 * the amount of code might be 'small' but there are quite a number of 2536 * exceptions which would make this a pain to maintain. Another way would 2537 * be to query the PCI id from the operating system (assuming this is the 2538 * videocard which is used for rendering which is not always the case). 2539 * This would work but it is not very portable. Second it would not work 2540 * well in, let's say, a remote X situation in which the amount of 3d 2541 * features which can be used is limited. 2542 * 2543 * As said most games only use the PCI id to get an indication of the 2544 * capabilities of the card. It doesn't really matter if the given id is 2545 * the correct one if we return the id of a card with similar 3d features. 2546 * 2547 * The code below checks the OpenGL capabilities of a videocard and matches 2548 * that to a certain level of Direct3D functionality. Once a card passes 2549 * the Direct3D9 check, we know that the card (in case of Nvidia) is at 2550 * least a GeforceFX. To give a better estimate we do a basic check on the 2551 * renderer string but if that won't pass we return a default card. This 2552 * way is better than maintaining a full card database as even without a 2553 * full database we can return a card with similar features. Second the 2554 * size of the database can be made quite small because when you know what 2555 * type of 3d functionality a card has, you know to which GPU family the 2556 * GPU must belong. Because of this you only have to check a small part of 2557 * the renderer string to distinguish between different models from that 2558 * family. 2559 * 2560 * The code also selects a default amount of video memory which we will 2561 * use for an estimation of the amount of free texture memory. In case of 2562 * real D3D the amount of texture memory includes video memory and system 2563 * memory (to be specific AGP memory or in case of PCIE TurboCache / 2564 * HyperMemory). We don't know how much system memory can be addressed by 2565 * the system but we can make a reasonable estimation about the amount of 2566 * video memory. If the value is slightly wrong it doesn't matter as we 2567 * didn't include AGP-like memory which makes the amount of addressable 2568 * memory higher and second OpenGL isn't that critical it moves to system 2569 * memory behind our backs if really needed. Note that the amount of video 2570 * memory can be overruled using a registry setting. */ 2571 2572 unsigned int i; 2573 enum wined3d_d3d_level d3d_level = d3d_level_from_caps(shader_caps, fragment_caps, glsl_version); 2574 enum wined3d_pci_device device; 2575 2576 for (i = 0; i < ARRAY_SIZE(card_vendor_table); ++i) 2577 { 2578 if (card_vendor_table[i].card_vendor != *card_vendor) 2579 continue; 2580 2581 TRACE("Applying card selector \"%s\".\n", card_vendor_table[i].description); 2582 device = select_card_handler(card_vendor_table[i].gl_vendor_selection, 2583 card_vendor_table[i].gl_vendor_count, *gl_vendor, gl_renderer); 2584 if (device != PCI_DEVICE_NONE) 2585 return device; 2586 2587 TRACE("Unrecognized renderer %s, falling back to default.\n", debugstr_a(gl_renderer)); 2588 return card_vendor_table[i].card_fallback[d3d_level]; 2589 } 2590 2591 FIXME("No card selector available for card vendor %04x (using GL_RENDERER %s).\n", 2592 *card_vendor, debugstr_a(gl_renderer)); 2593 2594 /* Default to generic Nvidia hardware based on the supported OpenGL extensions. */ 2595 *card_vendor = HW_VENDOR_NVIDIA; 2596 return card_fallback_nvidia[d3d_level]; 2597 } 2598 2599 static const struct wined3d_vertex_pipe_ops *select_vertex_implementation(const struct wined3d_gl_info *gl_info, 2600 const struct wined3d_shader_backend_ops *shader_backend_ops) 2601 { 2602 if (shader_backend_ops == &glsl_shader_backend && gl_info->supported[ARB_VERTEX_SHADER]) 2603 return &glsl_vertex_pipe; 2604 return &ffp_vertex_pipe; 2605 } 2606 2607 static const struct fragment_pipeline *select_fragment_implementation(const struct wined3d_gl_info *gl_info, 2608 const struct wined3d_shader_backend_ops *shader_backend_ops) 2609 { 2610 if (shader_backend_ops == &glsl_shader_backend && gl_info->supported[ARB_FRAGMENT_SHADER]) 2611 return &glsl_fragment_pipe; 2612 if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) 2613 return &arbfp_fragment_pipeline; 2614 if (gl_info->supported[ATI_FRAGMENT_SHADER]) 2615 return &atifs_fragment_pipeline; 2616 if (gl_info->supported[NV_REGISTER_COMBINERS] && gl_info->supported[NV_TEXTURE_SHADER2]) 2617 return &nvts_fragment_pipeline; 2618 if (gl_info->supported[NV_REGISTER_COMBINERS]) 2619 return &nvrc_fragment_pipeline; 2620 return &ffp_fragment_pipeline; 2621 } 2622 2623 static const struct wined3d_shader_backend_ops *select_shader_backend(const struct wined3d_gl_info *gl_info) 2624 { 2625 BOOL glsl = wined3d_settings.glslRequested && gl_info->glsl_version >= MAKEDWORD_VERSION(1, 20); 2626 2627 if (glsl && gl_info->supported[ARB_VERTEX_SHADER] && gl_info->supported[ARB_FRAGMENT_SHADER]) 2628 return &glsl_shader_backend; 2629 if (gl_info->supported[ARB_VERTEX_PROGRAM] && gl_info->supported[ARB_FRAGMENT_PROGRAM]) 2630 return &arb_program_shader_backend; 2631 if (glsl && (gl_info->supported[ARB_VERTEX_SHADER] || gl_info->supported[ARB_FRAGMENT_SHADER])) 2632 return &glsl_shader_backend; 2633 if (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_FRAGMENT_PROGRAM]) 2634 return &arb_program_shader_backend; 2635 return &none_shader_backend; 2636 } 2637 2638 static void parse_extension_string(struct wined3d_gl_info *gl_info, const char *extensions, 2639 const struct wined3d_extension_map *map, UINT entry_count) 2640 { 2641 while (*extensions) 2642 { 2643 const char *start; 2644 size_t len; 2645 UINT i; 2646 2647 while (isspace(*extensions)) 2648 ++extensions; 2649 start = extensions; 2650 while (!isspace(*extensions) && *extensions) 2651 ++extensions; 2652 2653 len = extensions - start; 2654 if (!len) 2655 continue; 2656 2657 TRACE("- %s.\n", debugstr_an(start, len)); 2658 2659 for (i = 0; i < entry_count; ++i) 2660 { 2661 if (len == strlen(map[i].extension_string) 2662 && !memcmp(start, map[i].extension_string, len)) 2663 { 2664 TRACE(" FOUND: %s support.\n", map[i].extension_string); 2665 gl_info->supported[map[i].extension] = TRUE; 2666 break; 2667 } 2668 } 2669 } 2670 } 2671 2672 static void enumerate_gl_extensions(struct wined3d_gl_info *gl_info, 2673 const struct wined3d_extension_map *map, unsigned int map_entries_count) 2674 { 2675 const char *gl_extension_name; 2676 unsigned int i, j; 2677 GLint extensions_count; 2678 2679 gl_info->gl_ops.gl.p_glGetIntegerv(GL_NUM_EXTENSIONS, &extensions_count); 2680 for (i = 0; i < extensions_count; ++i) 2681 { 2682 gl_extension_name = (const char *)GL_EXTCALL(glGetStringi(GL_EXTENSIONS, i)); 2683 TRACE("- %s.\n", debugstr_a(gl_extension_name)); 2684 for (j = 0; j < map_entries_count; ++j) 2685 { 2686 if (!strcmp(gl_extension_name, map[j].extension_string)) 2687 { 2688 TRACE("FOUND: %s support.\n", map[j].extension_string); 2689 gl_info->supported[map[j].extension] = TRUE; 2690 break; 2691 } 2692 } 2693 } 2694 } 2695 2696 static void load_gl_funcs(struct wined3d_gl_info *gl_info) 2697 { 2698 #define USE_GL_FUNC(pfn) gl_info->gl_ops.ext.p_##pfn = (void *)wglGetProcAddress(#pfn); 2699 /* GL_APPLE_fence */ 2700 USE_GL_FUNC(glDeleteFencesAPPLE) 2701 USE_GL_FUNC(glFinishFenceAPPLE) 2702 USE_GL_FUNC(glFinishObjectAPPLE) 2703 USE_GL_FUNC(glGenFencesAPPLE) 2704 USE_GL_FUNC(glIsFenceAPPLE) 2705 USE_GL_FUNC(glSetFenceAPPLE) 2706 USE_GL_FUNC(glTestFenceAPPLE) 2707 USE_GL_FUNC(glTestObjectAPPLE) 2708 /* GL_APPLE_flush_buffer_range */ 2709 USE_GL_FUNC(glBufferParameteriAPPLE) 2710 USE_GL_FUNC(glFlushMappedBufferRangeAPPLE) 2711 /* GL_ARB_base_instance */ 2712 USE_GL_FUNC(glDrawArraysInstancedBaseInstance) 2713 USE_GL_FUNC(glDrawElementsInstancedBaseVertexBaseInstance) 2714 /* GL_ARB_blend_func_extended */ 2715 USE_GL_FUNC(glBindFragDataLocationIndexed) 2716 USE_GL_FUNC(glGetFragDataIndex) 2717 /* GL_ARB_clear_buffer_object */ 2718 USE_GL_FUNC(glClearBufferData) 2719 USE_GL_FUNC(glClearBufferSubData) 2720 /* GL_ARB_clear_texture */ 2721 USE_GL_FUNC(glClearTexImage) 2722 USE_GL_FUNC(glClearTexSubImage) 2723 /* GL_ARB_clip_control */ 2724 USE_GL_FUNC(glClipControl) 2725 /* GL_ARB_color_buffer_float */ 2726 USE_GL_FUNC(glClampColorARB) 2727 /* GL_ARB_compute_shader */ 2728 USE_GL_FUNC(glDispatchCompute) 2729 USE_GL_FUNC(glDispatchComputeIndirect) 2730 /* GL_ARB_copy_buffer */ 2731 USE_GL_FUNC(glCopyBufferSubData) 2732 /* GL_ARB_copy_image */ 2733 USE_GL_FUNC(glCopyImageSubData) 2734 /* GL_ARB_debug_output */ 2735 USE_GL_FUNC(glDebugMessageCallbackARB) 2736 USE_GL_FUNC(glDebugMessageControlARB) 2737 USE_GL_FUNC(glDebugMessageInsertARB) 2738 USE_GL_FUNC(glGetDebugMessageLogARB) 2739 /* GL_ARB_draw_buffers */ 2740 USE_GL_FUNC(glDrawBuffersARB) 2741 /* GL_ARB_draw_elements_base_vertex */ 2742 USE_GL_FUNC(glDrawElementsBaseVertex) 2743 USE_GL_FUNC(glDrawElementsInstancedBaseVertex) 2744 USE_GL_FUNC(glDrawRangeElementsBaseVertex) 2745 USE_GL_FUNC(glMultiDrawElementsBaseVertex) 2746 /* GL_ARB_draw_indirect */ 2747 USE_GL_FUNC(glDrawArraysIndirect) 2748 USE_GL_FUNC(glDrawElementsIndirect) 2749 /* GL_ARB_draw_instanced */ 2750 USE_GL_FUNC(glDrawArraysInstancedARB) 2751 USE_GL_FUNC(glDrawElementsInstancedARB) 2752 /* GL_ARB_ES2_compatibility */ 2753 USE_GL_FUNC(glReleaseShaderCompiler) 2754 USE_GL_FUNC(glShaderBinary) 2755 USE_GL_FUNC(glGetShaderPrecisionFormat) 2756 USE_GL_FUNC(glDepthRangef) 2757 USE_GL_FUNC(glClearDepthf) 2758 /* GL_ARB_framebuffer_no_attachments */ 2759 USE_GL_FUNC(glFramebufferParameteri) 2760 /* GL_ARB_framebuffer_object */ 2761 USE_GL_FUNC(glBindFramebuffer) 2762 USE_GL_FUNC(glBindRenderbuffer) 2763 USE_GL_FUNC(glBlitFramebuffer) 2764 USE_GL_FUNC(glCheckFramebufferStatus) 2765 USE_GL_FUNC(glDeleteFramebuffers) 2766 USE_GL_FUNC(glDeleteRenderbuffers) 2767 USE_GL_FUNC(glFramebufferRenderbuffer) 2768 USE_GL_FUNC(glFramebufferTexture) 2769 USE_GL_FUNC(glFramebufferTexture1D) 2770 USE_GL_FUNC(glFramebufferTexture2D) 2771 USE_GL_FUNC(glFramebufferTexture3D) 2772 USE_GL_FUNC(glFramebufferTextureLayer) 2773 USE_GL_FUNC(glGenFramebuffers) 2774 USE_GL_FUNC(glGenRenderbuffers) 2775 USE_GL_FUNC(glGenerateMipmap) 2776 USE_GL_FUNC(glGetFramebufferAttachmentParameteriv) 2777 USE_GL_FUNC(glGetRenderbufferParameteriv) 2778 USE_GL_FUNC(glIsFramebuffer) 2779 USE_GL_FUNC(glIsRenderbuffer) 2780 USE_GL_FUNC(glRenderbufferStorage) 2781 USE_GL_FUNC(glRenderbufferStorageMultisample) 2782 /* GL_ARB_geometry_shader4 */ 2783 USE_GL_FUNC(glFramebufferTextureARB) 2784 USE_GL_FUNC(glFramebufferTextureFaceARB) 2785 USE_GL_FUNC(glFramebufferTextureLayerARB) 2786 USE_GL_FUNC(glProgramParameteriARB) 2787 /* GL_ARB_instanced_arrays */ 2788 USE_GL_FUNC(glVertexAttribDivisorARB) 2789 /* GL_ARB_internalformat_query */ 2790 USE_GL_FUNC(glGetInternalformativ) 2791 /* GL_ARB_internalformat_query2 */ 2792 USE_GL_FUNC(glGetInternalformati64v) 2793 /* GL_ARB_map_buffer_range */ 2794 USE_GL_FUNC(glFlushMappedBufferRange) 2795 USE_GL_FUNC(glMapBufferRange) 2796 /* GL_ARB_multisample */ 2797 USE_GL_FUNC(glSampleCoverageARB) 2798 /* GL_ARB_multitexture */ 2799 USE_GL_FUNC(glActiveTextureARB) 2800 USE_GL_FUNC(glClientActiveTextureARB) 2801 USE_GL_FUNC(glMultiTexCoord1fARB) 2802 USE_GL_FUNC(glMultiTexCoord1fvARB) 2803 USE_GL_FUNC(glMultiTexCoord2fARB) 2804 USE_GL_FUNC(glMultiTexCoord2fvARB) 2805 USE_GL_FUNC(glMultiTexCoord2svARB) 2806 USE_GL_FUNC(glMultiTexCoord3fARB) 2807 USE_GL_FUNC(glMultiTexCoord3fvARB) 2808 USE_GL_FUNC(glMultiTexCoord4fARB) 2809 USE_GL_FUNC(glMultiTexCoord4fvARB) 2810 USE_GL_FUNC(glMultiTexCoord4svARB) 2811 /* GL_ARB_occlusion_query */ 2812 USE_GL_FUNC(glBeginQueryARB) 2813 USE_GL_FUNC(glDeleteQueriesARB) 2814 USE_GL_FUNC(glEndQueryARB) 2815 USE_GL_FUNC(glGenQueriesARB) 2816 USE_GL_FUNC(glGetQueryivARB) 2817 USE_GL_FUNC(glGetQueryObjectivARB) 2818 USE_GL_FUNC(glGetQueryObjectuivARB) 2819 USE_GL_FUNC(glIsQueryARB) 2820 /* GL_ARB_point_parameters */ 2821 USE_GL_FUNC(glPointParameterfARB) 2822 USE_GL_FUNC(glPointParameterfvARB) 2823 /* GL_ARB_provoking_vertex */ 2824 USE_GL_FUNC(glProvokingVertex) 2825 /* GL_ARB_sampler_objects */ 2826 USE_GL_FUNC(glGenSamplers) 2827 USE_GL_FUNC(glDeleteSamplers) 2828 USE_GL_FUNC(glIsSampler) 2829 USE_GL_FUNC(glBindSampler) 2830 USE_GL_FUNC(glSamplerParameteri) 2831 USE_GL_FUNC(glSamplerParameterf) 2832 USE_GL_FUNC(glSamplerParameteriv) 2833 USE_GL_FUNC(glSamplerParameterfv) 2834 USE_GL_FUNC(glSamplerParameterIiv) 2835 USE_GL_FUNC(glSamplerParameterIuiv) 2836 USE_GL_FUNC(glGetSamplerParameteriv) 2837 USE_GL_FUNC(glGetSamplerParameterfv) 2838 USE_GL_FUNC(glGetSamplerParameterIiv) 2839 USE_GL_FUNC(glGetSamplerParameterIuiv) 2840 /* GL_ARB_shader_atomic_counters */ 2841 USE_GL_FUNC(glGetActiveAtomicCounterBufferiv) 2842 /* GL_ARB_shader_image_load_store */ 2843 USE_GL_FUNC(glBindImageTexture) 2844 USE_GL_FUNC(glMemoryBarrier) 2845 /* GL_ARB_shader_objects */ 2846 USE_GL_FUNC(glAttachObjectARB) 2847 USE_GL_FUNC(glBindAttribLocationARB) 2848 USE_GL_FUNC(glCompileShaderARB) 2849 USE_GL_FUNC(glCreateProgramObjectARB) 2850 USE_GL_FUNC(glCreateShaderObjectARB) 2851 USE_GL_FUNC(glDeleteObjectARB) 2852 USE_GL_FUNC(glDetachObjectARB) 2853 USE_GL_FUNC(glGetActiveUniformARB) 2854 USE_GL_FUNC(glGetAttachedObjectsARB) 2855 USE_GL_FUNC(glGetAttribLocationARB) 2856 USE_GL_FUNC(glGetHandleARB) 2857 USE_GL_FUNC(glGetInfoLogARB) 2858 USE_GL_FUNC(glGetObjectParameterfvARB) 2859 USE_GL_FUNC(glGetObjectParameterivARB) 2860 USE_GL_FUNC(glGetShaderSourceARB) 2861 USE_GL_FUNC(glGetUniformLocationARB) 2862 USE_GL_FUNC(glGetUniformfvARB) 2863 USE_GL_FUNC(glGetUniformivARB) 2864 USE_GL_FUNC(glLinkProgramARB) 2865 USE_GL_FUNC(glShaderSourceARB) 2866 USE_GL_FUNC(glUniform1fARB) 2867 USE_GL_FUNC(glUniform1fvARB) 2868 USE_GL_FUNC(glUniform1iARB) 2869 USE_GL_FUNC(glUniform1ivARB) 2870 USE_GL_FUNC(glUniform2fARB) 2871 USE_GL_FUNC(glUniform2fvARB) 2872 USE_GL_FUNC(glUniform2iARB) 2873 USE_GL_FUNC(glUniform2ivARB) 2874 USE_GL_FUNC(glUniform3fARB) 2875 USE_GL_FUNC(glUniform3fvARB) 2876 USE_GL_FUNC(glUniform3iARB) 2877 USE_GL_FUNC(glUniform3ivARB) 2878 USE_GL_FUNC(glUniform4fARB) 2879 USE_GL_FUNC(glUniform4fvARB) 2880 USE_GL_FUNC(glUniform4iARB) 2881 USE_GL_FUNC(glUniform4ivARB) 2882 USE_GL_FUNC(glUniformMatrix2fvARB) 2883 USE_GL_FUNC(glUniformMatrix3fvARB) 2884 USE_GL_FUNC(glUniformMatrix4fvARB) 2885 USE_GL_FUNC(glUseProgramObjectARB) 2886 USE_GL_FUNC(glValidateProgramARB) 2887 /* GL_ARB_shader_storage_buffer_object */ 2888 USE_GL_FUNC(glShaderStorageBlockBinding) 2889 /* GL_ARB_sync */ 2890 USE_GL_FUNC(glClientWaitSync) 2891 USE_GL_FUNC(glDeleteSync) 2892 USE_GL_FUNC(glFenceSync) 2893 USE_GL_FUNC(glGetInteger64v) 2894 USE_GL_FUNC(glGetSynciv) 2895 USE_GL_FUNC(glIsSync) 2896 USE_GL_FUNC(glWaitSync) 2897 /* GL_ARB_tessellation_shader */ 2898 USE_GL_FUNC(glPatchParameteri) 2899 USE_GL_FUNC(glPatchParameterfv) 2900 /* GL_ARB_texture_buffer_object */ 2901 USE_GL_FUNC(glTexBufferARB) 2902 /* GL_ARB_texture_buffer_range */ 2903 USE_GL_FUNC(glTexBufferRange) 2904 /* GL_ARB_texture_compression */ 2905 USE_GL_FUNC(glCompressedTexImage2DARB) 2906 USE_GL_FUNC(glCompressedTexImage3DARB) 2907 USE_GL_FUNC(glCompressedTexSubImage2DARB) 2908 USE_GL_FUNC(glCompressedTexSubImage3DARB) 2909 USE_GL_FUNC(glGetCompressedTexImageARB) 2910 /* GL_ARB_texture_multisample */ 2911 USE_GL_FUNC(glGetMultisamplefv); 2912 USE_GL_FUNC(glSampleMaski); 2913 USE_GL_FUNC(glTexImage2DMultisample); 2914 USE_GL_FUNC(glTexImage3DMultisample); 2915 /* GL_ARB_texture_storage */ 2916 USE_GL_FUNC(glTexStorage1D) 2917 USE_GL_FUNC(glTexStorage2D) 2918 USE_GL_FUNC(glTexStorage3D) 2919 /* GL_ARB_texture_storage_multisample */ 2920 USE_GL_FUNC(glTexStorage2DMultisample); 2921 USE_GL_FUNC(glTexStorage3DMultisample); 2922 /* GL_ARB_texture_view */ 2923 USE_GL_FUNC(glTextureView) 2924 /* GL_ARB_timer_query */ 2925 USE_GL_FUNC(glQueryCounter) 2926 USE_GL_FUNC(glGetQueryObjectui64v) 2927 /* GL_ARB_transform_feedback2 */ 2928 USE_GL_FUNC(glBindTransformFeedback); 2929 USE_GL_FUNC(glDeleteTransformFeedbacks); 2930 USE_GL_FUNC(glDrawTransformFeedback); 2931 USE_GL_FUNC(glGenTransformFeedbacks); 2932 USE_GL_FUNC(glIsTransformFeedback); 2933 USE_GL_FUNC(glPauseTransformFeedback); 2934 USE_GL_FUNC(glResumeTransformFeedback); 2935 /* GL_ARB_transform_feedback3 */ 2936 USE_GL_FUNC(glBeginQueryIndexed); 2937 USE_GL_FUNC(glDrawTransformFeedbackStream); 2938 USE_GL_FUNC(glEndQueryIndexed); 2939 USE_GL_FUNC(glGetQueryIndexediv); 2940 /* GL_ARB_uniform_buffer_object */ 2941 USE_GL_FUNC(glBindBufferBase) 2942 USE_GL_FUNC(glBindBufferRange) 2943 USE_GL_FUNC(glGetActiveUniformBlockName) 2944 USE_GL_FUNC(glGetActiveUniformBlockiv) 2945 USE_GL_FUNC(glGetActiveUniformName) 2946 USE_GL_FUNC(glGetActiveUniformsiv) 2947 USE_GL_FUNC(glGetIntegeri_v) 2948 USE_GL_FUNC(glGetUniformBlockIndex) 2949 USE_GL_FUNC(glGetUniformIndices) 2950 USE_GL_FUNC(glUniformBlockBinding) 2951 /* GL_ARB_vertex_blend */ 2952 USE_GL_FUNC(glVertexBlendARB) 2953 USE_GL_FUNC(glWeightPointerARB) 2954 USE_GL_FUNC(glWeightbvARB) 2955 USE_GL_FUNC(glWeightdvARB) 2956 USE_GL_FUNC(glWeightfvARB) 2957 USE_GL_FUNC(glWeightivARB) 2958 USE_GL_FUNC(glWeightsvARB) 2959 USE_GL_FUNC(glWeightubvARB) 2960 USE_GL_FUNC(glWeightuivARB) 2961 USE_GL_FUNC(glWeightusvARB) 2962 /* GL_ARB_vertex_buffer_object */ 2963 USE_GL_FUNC(glBindBufferARB) 2964 USE_GL_FUNC(glBufferDataARB) 2965 USE_GL_FUNC(glBufferSubDataARB) 2966 USE_GL_FUNC(glDeleteBuffersARB) 2967 USE_GL_FUNC(glGenBuffersARB) 2968 USE_GL_FUNC(glGetBufferParameterivARB) 2969 USE_GL_FUNC(glGetBufferPointervARB) 2970 USE_GL_FUNC(glGetBufferSubDataARB) 2971 USE_GL_FUNC(glIsBufferARB) 2972 USE_GL_FUNC(glMapBufferARB) 2973 USE_GL_FUNC(glUnmapBufferARB) 2974 /* GL_ARB_vertex_program */ 2975 USE_GL_FUNC(glBindProgramARB) 2976 USE_GL_FUNC(glDeleteProgramsARB) 2977 USE_GL_FUNC(glDisableVertexAttribArrayARB) 2978 USE_GL_FUNC(glEnableVertexAttribArrayARB) 2979 USE_GL_FUNC(glGenProgramsARB) 2980 USE_GL_FUNC(glGetProgramivARB) 2981 USE_GL_FUNC(glProgramEnvParameter4fvARB) 2982 USE_GL_FUNC(glProgramLocalParameter4fvARB) 2983 USE_GL_FUNC(glProgramStringARB) 2984 USE_GL_FUNC(glVertexAttrib1dARB) 2985 USE_GL_FUNC(glVertexAttrib1dvARB) 2986 USE_GL_FUNC(glVertexAttrib1fARB) 2987 USE_GL_FUNC(glVertexAttrib1fvARB) 2988 USE_GL_FUNC(glVertexAttrib1sARB) 2989 USE_GL_FUNC(glVertexAttrib1svARB) 2990 USE_GL_FUNC(glVertexAttrib2dARB) 2991 USE_GL_FUNC(glVertexAttrib2dvARB) 2992 USE_GL_FUNC(glVertexAttrib2fARB) 2993 USE_GL_FUNC(glVertexAttrib2fvARB) 2994 USE_GL_FUNC(glVertexAttrib2sARB) 2995 USE_GL_FUNC(glVertexAttrib2svARB) 2996 USE_GL_FUNC(glVertexAttrib3dARB) 2997 USE_GL_FUNC(glVertexAttrib3dvARB) 2998 USE_GL_FUNC(glVertexAttrib3fARB) 2999 USE_GL_FUNC(glVertexAttrib3fvARB) 3000 USE_GL_FUNC(glVertexAttrib3sARB) 3001 USE_GL_FUNC(glVertexAttrib3svARB) 3002 USE_GL_FUNC(glVertexAttrib4NbvARB) 3003 USE_GL_FUNC(glVertexAttrib4NivARB) 3004 USE_GL_FUNC(glVertexAttrib4NsvARB) 3005 USE_GL_FUNC(glVertexAttrib4NubARB) 3006 USE_GL_FUNC(glVertexAttrib4NubvARB) 3007 USE_GL_FUNC(glVertexAttrib4NuivARB) 3008 USE_GL_FUNC(glVertexAttrib4NusvARB) 3009 USE_GL_FUNC(glVertexAttrib4bvARB) 3010 USE_GL_FUNC(glVertexAttrib4dARB) 3011 USE_GL_FUNC(glVertexAttrib4dvARB) 3012 USE_GL_FUNC(glVertexAttrib4fARB) 3013 USE_GL_FUNC(glVertexAttrib4fvARB) 3014 USE_GL_FUNC(glVertexAttrib4ivARB) 3015 USE_GL_FUNC(glVertexAttrib4sARB) 3016 USE_GL_FUNC(glVertexAttrib4svARB) 3017 USE_GL_FUNC(glVertexAttrib4ubvARB) 3018 USE_GL_FUNC(glVertexAttrib4uivARB) 3019 USE_GL_FUNC(glVertexAttrib4usvARB) 3020 USE_GL_FUNC(glVertexAttribPointerARB) 3021 /* GL_ARB_viewport_array */ 3022 USE_GL_FUNC(glDepthRangeArrayv) 3023 USE_GL_FUNC(glDepthRangeIndexed) 3024 USE_GL_FUNC(glGetDoublei_v) 3025 USE_GL_FUNC(glGetFloati_v) 3026 USE_GL_FUNC(glScissorArrayv) 3027 USE_GL_FUNC(glScissorIndexed) 3028 USE_GL_FUNC(glScissorIndexedv) 3029 USE_GL_FUNC(glViewportArrayv) 3030 USE_GL_FUNC(glViewportIndexedf) 3031 USE_GL_FUNC(glViewportIndexedfv) 3032 /* GL_ATI_fragment_shader */ 3033 USE_GL_FUNC(glAlphaFragmentOp1ATI) 3034 USE_GL_FUNC(glAlphaFragmentOp2ATI) 3035 USE_GL_FUNC(glAlphaFragmentOp3ATI) 3036 USE_GL_FUNC(glBeginFragmentShaderATI) 3037 USE_GL_FUNC(glBindFragmentShaderATI) 3038 USE_GL_FUNC(glColorFragmentOp1ATI) 3039 USE_GL_FUNC(glColorFragmentOp2ATI) 3040 USE_GL_FUNC(glColorFragmentOp3ATI) 3041 USE_GL_FUNC(glDeleteFragmentShaderATI) 3042 USE_GL_FUNC(glEndFragmentShaderATI) 3043 USE_GL_FUNC(glGenFragmentShadersATI) 3044 USE_GL_FUNC(glPassTexCoordATI) 3045 USE_GL_FUNC(glSampleMapATI) 3046 USE_GL_FUNC(glSetFragmentShaderConstantATI) 3047 /* GL_ATI_separate_stencil */ 3048 USE_GL_FUNC(glStencilOpSeparateATI) 3049 USE_GL_FUNC(glStencilFuncSeparateATI) 3050 /* GL_EXT_blend_color */ 3051 USE_GL_FUNC(glBlendColorEXT) 3052 /* GL_EXT_blend_equation_separate */ 3053 USE_GL_FUNC(glBlendFuncSeparateEXT) 3054 /* GL_EXT_blend_func_separate */ 3055 USE_GL_FUNC(glBlendEquationSeparateEXT) 3056 /* GL_EXT_blend_minmax */ 3057 USE_GL_FUNC(glBlendEquationEXT) 3058 /* GL_EXT_depth_bounds_test */ 3059 USE_GL_FUNC(glDepthBoundsEXT) 3060 /* GL_EXT_draw_buffers2 */ 3061 USE_GL_FUNC(glColorMaskIndexedEXT) 3062 USE_GL_FUNC(glDisableIndexedEXT) 3063 USE_GL_FUNC(glEnableIndexedEXT) 3064 USE_GL_FUNC(glGetBooleanIndexedvEXT) 3065 USE_GL_FUNC(glGetIntegerIndexedvEXT) 3066 USE_GL_FUNC(glIsEnabledIndexedEXT) 3067 /* GL_EXT_fog_coord */ 3068 USE_GL_FUNC(glFogCoordPointerEXT) 3069 USE_GL_FUNC(glFogCoorddEXT) 3070 USE_GL_FUNC(glFogCoorddvEXT) 3071 USE_GL_FUNC(glFogCoordfEXT) 3072 USE_GL_FUNC(glFogCoordfvEXT) 3073 /* GL_EXT_framebuffer_blit */ 3074 USE_GL_FUNC(glBlitFramebufferEXT) 3075 /* GL_EXT_framebuffer_multisample */ 3076 USE_GL_FUNC(glRenderbufferStorageMultisampleEXT) 3077 /* GL_EXT_framebuffer_object */ 3078 USE_GL_FUNC(glBindFramebufferEXT) 3079 USE_GL_FUNC(glBindRenderbufferEXT) 3080 USE_GL_FUNC(glCheckFramebufferStatusEXT) 3081 USE_GL_FUNC(glDeleteFramebuffersEXT) 3082 USE_GL_FUNC(glDeleteRenderbuffersEXT) 3083 USE_GL_FUNC(glFramebufferRenderbufferEXT) 3084 USE_GL_FUNC(glFramebufferTexture1DEXT) 3085 USE_GL_FUNC(glFramebufferTexture2DEXT) 3086 USE_GL_FUNC(glFramebufferTexture3DEXT) 3087 USE_GL_FUNC(glGenFramebuffersEXT) 3088 USE_GL_FUNC(glGenRenderbuffersEXT) 3089 USE_GL_FUNC(glGenerateMipmapEXT) 3090 USE_GL_FUNC(glGetFramebufferAttachmentParameterivEXT) 3091 USE_GL_FUNC(glGetRenderbufferParameterivEXT) 3092 USE_GL_FUNC(glIsFramebufferEXT) 3093 USE_GL_FUNC(glIsRenderbufferEXT) 3094 USE_GL_FUNC(glRenderbufferStorageEXT) 3095 /* GL_EXT_gpu_program_parameters */ 3096 USE_GL_FUNC(glProgramEnvParameters4fvEXT) 3097 USE_GL_FUNC(glProgramLocalParameters4fvEXT) 3098 /* GL_EXT_gpu_shader4 */ 3099 USE_GL_FUNC(glBindFragDataLocationEXT) 3100 USE_GL_FUNC(glGetFragDataLocationEXT) 3101 USE_GL_FUNC(glGetUniformuivEXT) 3102 USE_GL_FUNC(glGetVertexAttribIivEXT) 3103 USE_GL_FUNC(glGetVertexAttribIuivEXT) 3104 USE_GL_FUNC(glUniform1uiEXT) 3105 USE_GL_FUNC(glUniform1uivEXT) 3106 USE_GL_FUNC(glUniform2uiEXT) 3107 USE_GL_FUNC(glUniform2uivEXT) 3108 USE_GL_FUNC(glUniform3uiEXT) 3109 USE_GL_FUNC(glUniform3uivEXT) 3110 USE_GL_FUNC(glUniform4uiEXT) 3111 USE_GL_FUNC(glUniform4uivEXT) 3112 USE_GL_FUNC(glVertexAttribI1iEXT) 3113 USE_GL_FUNC(glVertexAttribI1ivEXT) 3114 USE_GL_FUNC(glVertexAttribI1uiEXT) 3115 USE_GL_FUNC(glVertexAttribI1uivEXT) 3116 USE_GL_FUNC(glVertexAttribI2iEXT) 3117 USE_GL_FUNC(glVertexAttribI2ivEXT) 3118 USE_GL_FUNC(glVertexAttribI2uiEXT) 3119 USE_GL_FUNC(glVertexAttribI2uivEXT) 3120 USE_GL_FUNC(glVertexAttribI3iEXT) 3121 USE_GL_FUNC(glVertexAttribI3ivEXT) 3122 USE_GL_FUNC(glVertexAttribI3uiEXT) 3123 USE_GL_FUNC(glVertexAttribI3uivEXT) 3124 USE_GL_FUNC(glVertexAttribI4bvEXT) 3125 USE_GL_FUNC(glVertexAttribI4iEXT) 3126 USE_GL_FUNC(glVertexAttribI4ivEXT) 3127 USE_GL_FUNC(glVertexAttribI4svEXT) 3128 USE_GL_FUNC(glVertexAttribI4ubvEXT) 3129 USE_GL_FUNC(glVertexAttribI4uiEXT) 3130 USE_GL_FUNC(glVertexAttribI4uivEXT) 3131 USE_GL_FUNC(glVertexAttribI4usvEXT) 3132 USE_GL_FUNC(glVertexAttribIPointerEXT) 3133 /* GL_EXT_point_parameters */ 3134 USE_GL_FUNC(glPointParameterfEXT) 3135 USE_GL_FUNC(glPointParameterfvEXT) 3136 /* GL_EXT_polygon_offset_clamp */ 3137 USE_GL_FUNC(glPolygonOffsetClampEXT) 3138 /* GL_EXT_provoking_vertex */ 3139 USE_GL_FUNC(glProvokingVertexEXT) 3140 /* GL_EXT_secondary_color */ 3141 USE_GL_FUNC(glSecondaryColor3fEXT) 3142 USE_GL_FUNC(glSecondaryColor3fvEXT) 3143 USE_GL_FUNC(glSecondaryColor3ubEXT) 3144 USE_GL_FUNC(glSecondaryColor3ubvEXT) 3145 USE_GL_FUNC(glSecondaryColorPointerEXT) 3146 /* GL_EXT_stencil_two_side */ 3147 USE_GL_FUNC(glActiveStencilFaceEXT) 3148 /* GL_EXT_texture3D */ 3149 USE_GL_FUNC(glTexImage3D) 3150 USE_GL_FUNC(glTexImage3DEXT) 3151 USE_GL_FUNC(glTexSubImage3D) 3152 USE_GL_FUNC(glTexSubImage3DEXT) 3153 /* GL_NV_fence */ 3154 USE_GL_FUNC(glDeleteFencesNV) 3155 USE_GL_FUNC(glFinishFenceNV) 3156 USE_GL_FUNC(glGenFencesNV) 3157 USE_GL_FUNC(glGetFenceivNV) 3158 USE_GL_FUNC(glIsFenceNV) 3159 USE_GL_FUNC(glSetFenceNV) 3160 USE_GL_FUNC(glTestFenceNV) 3161 /* GL_NV_half_float */ 3162 USE_GL_FUNC(glColor3hNV) 3163 USE_GL_FUNC(glColor3hvNV) 3164 USE_GL_FUNC(glColor4hNV) 3165 USE_GL_FUNC(glColor4hvNV) 3166 USE_GL_FUNC(glFogCoordhNV) 3167 USE_GL_FUNC(glFogCoordhvNV) 3168 USE_GL_FUNC(glMultiTexCoord1hNV) 3169 USE_GL_FUNC(glMultiTexCoord1hvNV) 3170 USE_GL_FUNC(glMultiTexCoord2hNV) 3171 USE_GL_FUNC(glMultiTexCoord2hvNV) 3172 USE_GL_FUNC(glMultiTexCoord3hNV) 3173 USE_GL_FUNC(glMultiTexCoord3hvNV) 3174 USE_GL_FUNC(glMultiTexCoord4hNV) 3175 USE_GL_FUNC(glMultiTexCoord4hvNV) 3176 USE_GL_FUNC(glNormal3hNV) 3177 USE_GL_FUNC(glNormal3hvNV) 3178 USE_GL_FUNC(glSecondaryColor3hNV) 3179 USE_GL_FUNC(glSecondaryColor3hvNV) 3180 USE_GL_FUNC(glTexCoord1hNV) 3181 USE_GL_FUNC(glTexCoord1hvNV) 3182 USE_GL_FUNC(glTexCoord2hNV) 3183 USE_GL_FUNC(glTexCoord2hvNV) 3184 USE_GL_FUNC(glTexCoord3hNV) 3185 USE_GL_FUNC(glTexCoord3hvNV) 3186 USE_GL_FUNC(glTexCoord4hNV) 3187 USE_GL_FUNC(glTexCoord4hvNV) 3188 USE_GL_FUNC(glVertex2hNV) 3189 USE_GL_FUNC(glVertex2hvNV) 3190 USE_GL_FUNC(glVertex3hNV) 3191 USE_GL_FUNC(glVertex3hvNV) 3192 USE_GL_FUNC(glVertex4hNV) 3193 USE_GL_FUNC(glVertex4hvNV) 3194 USE_GL_FUNC(glVertexAttrib1hNV) 3195 USE_GL_FUNC(glVertexAttrib1hvNV) 3196 USE_GL_FUNC(glVertexAttrib2hNV) 3197 USE_GL_FUNC(glVertexAttrib2hvNV) 3198 USE_GL_FUNC(glVertexAttrib3hNV) 3199 USE_GL_FUNC(glVertexAttrib3hvNV) 3200 USE_GL_FUNC(glVertexAttrib4hNV) 3201 USE_GL_FUNC(glVertexAttrib4hvNV) 3202 USE_GL_FUNC(glVertexAttribs1hvNV) 3203 USE_GL_FUNC(glVertexAttribs2hvNV) 3204 USE_GL_FUNC(glVertexAttribs3hvNV) 3205 USE_GL_FUNC(glVertexAttribs4hvNV) 3206 USE_GL_FUNC(glVertexWeighthNV) 3207 USE_GL_FUNC(glVertexWeighthvNV) 3208 /* GL_NV_point_sprite */ 3209 USE_GL_FUNC(glPointParameteriNV) 3210 USE_GL_FUNC(glPointParameterivNV) 3211 /* GL_NV_register_combiners */ 3212 USE_GL_FUNC(glCombinerInputNV) 3213 USE_GL_FUNC(glCombinerOutputNV) 3214 USE_GL_FUNC(glCombinerParameterfNV) 3215 USE_GL_FUNC(glCombinerParameterfvNV) 3216 USE_GL_FUNC(glCombinerParameteriNV) 3217 USE_GL_FUNC(glCombinerParameterivNV) 3218 USE_GL_FUNC(glFinalCombinerInputNV) 3219 /* WGL extensions */ 3220 USE_GL_FUNC(wglChoosePixelFormatARB) 3221 USE_GL_FUNC(wglGetExtensionsStringARB) 3222 USE_GL_FUNC(wglGetPixelFormatAttribfvARB) 3223 USE_GL_FUNC(wglGetPixelFormatAttribivARB) 3224 USE_GL_FUNC(wglQueryCurrentRendererIntegerWINE) 3225 USE_GL_FUNC(wglQueryCurrentRendererStringWINE) 3226 USE_GL_FUNC(wglQueryRendererIntegerWINE) 3227 USE_GL_FUNC(wglQueryRendererStringWINE) 3228 USE_GL_FUNC(wglSetPixelFormatWINE) 3229 USE_GL_FUNC(wglSwapIntervalEXT) 3230 3231 /* Newer core functions */ 3232 USE_GL_FUNC(glActiveTexture) /* OpenGL 1.3 */ 3233 USE_GL_FUNC(glAttachShader) /* OpenGL 2.0 */ 3234 USE_GL_FUNC(glBeginQuery) /* OpenGL 1.5 */ 3235 USE_GL_FUNC(glBeginTransformFeedback) /* OpenGL 3.0 */ 3236 USE_GL_FUNC(glBindAttribLocation) /* OpenGL 2.0 */ 3237 USE_GL_FUNC(glBindBuffer) /* OpenGL 1.5 */ 3238 USE_GL_FUNC(glBindFragDataLocation) /* OpenGL 3.0 */ 3239 USE_GL_FUNC(glBindVertexArray) /* OpenGL 3.0 */ 3240 USE_GL_FUNC(glBlendColor) /* OpenGL 1.4 */ 3241 USE_GL_FUNC(glBlendEquation) /* OpenGL 1.4 */ 3242 USE_GL_FUNC(glBlendEquationSeparate) /* OpenGL 2.0 */ 3243 USE_GL_FUNC(glBlendFuncSeparate) /* OpenGL 1.4 */ 3244 USE_GL_FUNC(glBufferData) /* OpenGL 1.5 */ 3245 USE_GL_FUNC(glBufferSubData) /* OpenGL 1.5 */ 3246 USE_GL_FUNC(glColorMaski) /* OpenGL 3.0 */ 3247 USE_GL_FUNC(glCompileShader) /* OpenGL 2.0 */ 3248 USE_GL_FUNC(glCompressedTexImage2D) /* OpenGL 1.3 */ 3249 USE_GL_FUNC(glCompressedTexImage3D) /* OpenGL 1.3 */ 3250 USE_GL_FUNC(glCompressedTexSubImage2D) /* OpenGL 1.3 */ 3251 USE_GL_FUNC(glCompressedTexSubImage3D) /* OpenGL 1.3 */ 3252 USE_GL_FUNC(glCreateProgram) /* OpenGL 2.0 */ 3253 USE_GL_FUNC(glCreateShader) /* OpenGL 2.0 */ 3254 USE_GL_FUNC(glDebugMessageCallback) /* OpenGL 4.3 */ 3255 USE_GL_FUNC(glDebugMessageControl) /* OpenGL 4.3 */ 3256 USE_GL_FUNC(glDebugMessageInsert) /* OpenGL 4.3 */ 3257 USE_GL_FUNC(glDeleteBuffers) /* OpenGL 1.5 */ 3258 USE_GL_FUNC(glDeleteProgram) /* OpenGL 2.0 */ 3259 USE_GL_FUNC(glDeleteQueries) /* OpenGL 1.5 */ 3260 USE_GL_FUNC(glDeleteShader) /* OpenGL 2.0 */ 3261 USE_GL_FUNC(glDeleteVertexArrays) /* OpenGL 3.0 */ 3262 USE_GL_FUNC(glDetachShader) /* OpenGL 2.0 */ 3263 USE_GL_FUNC(glDisablei) /* OpenGL 3.0 */ 3264 USE_GL_FUNC(glDisableVertexAttribArray) /* OpenGL 2.0 */ 3265 USE_GL_FUNC(glDrawArraysInstanced) /* OpenGL 3.1 */ 3266 USE_GL_FUNC(glDrawBuffers) /* OpenGL 2.0 */ 3267 USE_GL_FUNC(glDrawElementsInstanced) /* OpenGL 3.1 */ 3268 USE_GL_FUNC(glEnablei) /* OpenGL 3.0 */ 3269 USE_GL_FUNC(glEnableVertexAttribArray) /* OpenGL 2.0 */ 3270 USE_GL_FUNC(glEndQuery) /* OpenGL 1.5 */ 3271 USE_GL_FUNC(glEndTransformFeedback) /* OpenGL 3.0 */ 3272 USE_GL_FUNC(glFramebufferTexture) /* OpenGL 3.2 */ 3273 USE_GL_FUNC(glGenBuffers) /* OpenGL 1.5 */ 3274 USE_GL_FUNC(glGenQueries) /* OpenGL 1.5 */ 3275 USE_GL_FUNC(glGenVertexArrays) /* OpenGL 3.0 */ 3276 USE_GL_FUNC(glGetActiveUniform) /* OpenGL 2.0 */ 3277 USE_GL_FUNC(glGetAttachedShaders) /* OpenGL 2.0 */ 3278 USE_GL_FUNC(glGetAttribLocation) /* OpenGL 2.0 */ 3279 USE_GL_FUNC(glGetBooleani_v) /* OpenGL 3.0 */ 3280 USE_GL_FUNC(glGetBufferSubData) /* OpenGL 1.5 */ 3281 USE_GL_FUNC(glGetCompressedTexImage) /* OpenGL 1.3 */ 3282 USE_GL_FUNC(glGetDebugMessageLog) /* OpenGL 4.3 */ 3283 USE_GL_FUNC(glGetIntegeri_v) /* OpenGL 3.0 */ 3284 USE_GL_FUNC(glGetProgramInfoLog) /* OpenGL 2.0 */ 3285 USE_GL_FUNC(glGetProgramiv) /* OpenGL 2.0 */ 3286 USE_GL_FUNC(glGetQueryiv) /* OpenGL 1.5 */ 3287 USE_GL_FUNC(glGetQueryObjectuiv) /* OpenGL 1.5 */ 3288 USE_GL_FUNC(glGetShaderInfoLog) /* OpenGL 2.0 */ 3289 USE_GL_FUNC(glGetShaderiv) /* OpenGL 2.0 */ 3290 USE_GL_FUNC(glGetShaderSource) /* OpenGL 2.0 */ 3291 USE_GL_FUNC(glGetStringi) /* OpenGL 3.0 */ 3292 USE_GL_FUNC(glGetTextureLevelParameteriv) /* OpenGL 4.5 */ 3293 USE_GL_FUNC(glGetTextureParameteriv) /* OpenGL 4.5 */ 3294 USE_GL_FUNC(glGetUniformfv) /* OpenGL 2.0 */ 3295 USE_GL_FUNC(glGetUniformiv) /* OpenGL 2.0 */ 3296 USE_GL_FUNC(glGetUniformLocation) /* OpenGL 2.0 */ 3297 USE_GL_FUNC(glIsEnabledi) /* OpenGL 3.0 */ 3298 USE_GL_FUNC(glLinkProgram) /* OpenGL 2.0 */ 3299 USE_GL_FUNC(glMapBuffer) /* OpenGL 1.5 */ 3300 USE_GL_FUNC(glPointParameteri) /* OpenGL 1.4 */ 3301 USE_GL_FUNC(glPointParameteriv) /* OpenGL 1.4 */ 3302 USE_GL_FUNC(glShaderSource) /* OpenGL 2.0 */ 3303 USE_GL_FUNC(glStencilFuncSeparate) /* OpenGL 2.0 */ 3304 USE_GL_FUNC(glStencilOpSeparate) /* OpenGL 2.0 */ 3305 USE_GL_FUNC(glTexBuffer) /* OpenGL 3.1 */ 3306 USE_GL_FUNC(glTexImage3D) /* OpenGL 1.2 */ 3307 USE_GL_FUNC(glTexSubImage3D) /* OpenGL 1.2 */ 3308 USE_GL_FUNC(glTransformFeedbackVaryings) /* OpenGL 3.0 */ 3309 USE_GL_FUNC(glUniform1f) /* OpenGL 2.0 */ 3310 USE_GL_FUNC(glUniform1fv) /* OpenGL 2.0 */ 3311 USE_GL_FUNC(glUniform1i) /* OpenGL 2.0 */ 3312 USE_GL_FUNC(glUniform1iv) /* OpenGL 2.0 */ 3313 USE_GL_FUNC(glUniform2f) /* OpenGL 2.0 */ 3314 USE_GL_FUNC(glUniform2fv) /* OpenGL 2.0 */ 3315 USE_GL_FUNC(glUniform2i) /* OpenGL 2.0 */ 3316 USE_GL_FUNC(glUniform2iv) /* OpenGL 2.0 */ 3317 USE_GL_FUNC(glUniform3f) /* OpenGL 2.0 */ 3318 USE_GL_FUNC(glUniform3fv) /* OpenGL 2.0 */ 3319 USE_GL_FUNC(glUniform3i) /* OpenGL 2.0 */ 3320 USE_GL_FUNC(glUniform3iv) /* OpenGL 2.0 */ 3321 USE_GL_FUNC(glUniform4f) /* OpenGL 2.0 */ 3322 USE_GL_FUNC(glUniform4fv) /* OpenGL 2.0 */ 3323 USE_GL_FUNC(glUniform4i) /* OpenGL 2.0 */ 3324 USE_GL_FUNC(glUniform4iv) /* OpenGL 2.0 */ 3325 USE_GL_FUNC(glUniformMatrix2fv) /* OpenGL 2.0 */ 3326 USE_GL_FUNC(glUniformMatrix3fv) /* OpenGL 2.0 */ 3327 USE_GL_FUNC(glUniformMatrix4fv) /* OpenGL 2.0 */ 3328 USE_GL_FUNC(glUnmapBuffer) /* OpenGL 1.5 */ 3329 USE_GL_FUNC(glUseProgram) /* OpenGL 2.0 */ 3330 USE_GL_FUNC(glValidateProgram) /* OpenGL 2.0 */ 3331 USE_GL_FUNC(glVertexAttrib1f) /* OpenGL 2.0 */ 3332 USE_GL_FUNC(glVertexAttrib1fv) /* OpenGL 2.0 */ 3333 USE_GL_FUNC(glVertexAttrib2f) /* OpenGL 2.0 */ 3334 USE_GL_FUNC(glVertexAttrib2fv) /* OpenGL 2.0 */ 3335 USE_GL_FUNC(glVertexAttrib3f) /* OpenGL 2.0 */ 3336 USE_GL_FUNC(glVertexAttrib3fv) /* OpenGL 2.0 */ 3337 USE_GL_FUNC(glVertexAttrib4f) /* OpenGL 2.0 */ 3338 USE_GL_FUNC(glVertexAttrib4fv) /* OpenGL 2.0 */ 3339 USE_GL_FUNC(glVertexAttrib4Nsv) /* OpenGL 2.0 */ 3340 USE_GL_FUNC(glVertexAttrib4Nub) /* OpenGL 2.0 */ 3341 USE_GL_FUNC(glVertexAttrib4Nubv) /* OpenGL 2.0 */ 3342 USE_GL_FUNC(glVertexAttrib4Nusv) /* OpenGL 2.0 */ 3343 USE_GL_FUNC(glVertexAttrib4sv) /* OpenGL 2.0 */ 3344 USE_GL_FUNC(glVertexAttrib4ubv) /* OpenGL 2.0 */ 3345 USE_GL_FUNC(glVertexAttribDivisor) /* OpenGL 3.3 */ 3346 USE_GL_FUNC(glVertexAttribIPointer) /* OpenGL 3.0 */ 3347 USE_GL_FUNC(glVertexAttribPointer) /* OpenGL 2.0 */ 3348 #undef USE_GL_FUNC 3349 3350 #ifndef USE_WIN32_OPENGL 3351 /* hack: use the functions directly from the TEB table to bypass the thunks */ 3352 /* note that we still need the above wglGetProcAddress calls to initialize the table */ 3353 gl_info->gl_ops.ext = ((struct opengl_funcs *)NtCurrentTeb()->glTable)->ext; 3354 #endif 3355 3356 #define MAP_GL_FUNCTION(core_func, ext_func) \ 3357 do \ 3358 { \ 3359 if (!gl_info->gl_ops.ext.p_##core_func) \ 3360 gl_info->gl_ops.ext.p_##core_func = gl_info->gl_ops.ext.p_##ext_func; \ 3361 } while (0) 3362 #define MAP_GL_FUNCTION_CAST(core_func, ext_func) \ 3363 do \ 3364 { \ 3365 if (!gl_info->gl_ops.ext.p_##core_func) \ 3366 gl_info->gl_ops.ext.p_##core_func = (void *)gl_info->gl_ops.ext.p_##ext_func; \ 3367 } while (0) 3368 3369 MAP_GL_FUNCTION(glActiveTexture, glActiveTextureARB); 3370 MAP_GL_FUNCTION(glAttachShader, glAttachObjectARB); 3371 MAP_GL_FUNCTION(glBeginQuery, glBeginQueryARB); 3372 MAP_GL_FUNCTION(glBindAttribLocation, glBindAttribLocationARB); 3373 MAP_GL_FUNCTION(glBindBuffer, glBindBufferARB); 3374 MAP_GL_FUNCTION(glBindFragDataLocation, glBindFragDataLocationEXT); 3375 MAP_GL_FUNCTION(glBlendColor, glBlendColorEXT); 3376 MAP_GL_FUNCTION(glBlendEquation, glBlendEquationEXT); 3377 MAP_GL_FUNCTION(glBlendEquationSeparate, glBlendEquationSeparateEXT); 3378 MAP_GL_FUNCTION(glBlendFuncSeparate, glBlendFuncSeparateEXT); 3379 MAP_GL_FUNCTION(glBufferData, glBufferDataARB); 3380 MAP_GL_FUNCTION(glBufferSubData, glBufferSubDataARB); 3381 MAP_GL_FUNCTION(glColorMaski, glColorMaskIndexedEXT); 3382 MAP_GL_FUNCTION(glCompileShader, glCompileShaderARB); 3383 MAP_GL_FUNCTION(glCompressedTexImage2D, glCompressedTexImage2DARB); 3384 MAP_GL_FUNCTION(glCompressedTexImage3D, glCompressedTexImage3DARB); 3385 MAP_GL_FUNCTION(glCompressedTexSubImage2D, glCompressedTexSubImage2DARB); 3386 MAP_GL_FUNCTION(glCompressedTexSubImage3D, glCompressedTexSubImage3DARB); 3387 MAP_GL_FUNCTION(glCreateProgram, glCreateProgramObjectARB); 3388 MAP_GL_FUNCTION(glCreateShader, glCreateShaderObjectARB); 3389 MAP_GL_FUNCTION(glDebugMessageCallback, glDebugMessageCallbackARB); 3390 MAP_GL_FUNCTION(glDebugMessageControl, glDebugMessageControlARB); 3391 MAP_GL_FUNCTION(glDebugMessageInsert, glDebugMessageInsertARB); 3392 MAP_GL_FUNCTION(glDeleteBuffers, glDeleteBuffersARB); 3393 MAP_GL_FUNCTION(glDeleteProgram, glDeleteObjectARB); 3394 MAP_GL_FUNCTION(glDeleteQueries, glDeleteQueriesARB); 3395 MAP_GL_FUNCTION(glDeleteShader, glDeleteObjectARB); 3396 MAP_GL_FUNCTION(glDetachShader, glDetachObjectARB); 3397 MAP_GL_FUNCTION(glDisablei, glDisableIndexedEXT); 3398 MAP_GL_FUNCTION(glDisableVertexAttribArray, glDisableVertexAttribArrayARB); 3399 MAP_GL_FUNCTION(glDrawArraysInstanced, glDrawArraysInstancedARB); 3400 MAP_GL_FUNCTION(glDrawBuffers, glDrawBuffersARB); 3401 MAP_GL_FUNCTION(glDrawElementsInstanced, glDrawElementsInstancedARB); 3402 MAP_GL_FUNCTION(glEnablei, glEnableIndexedEXT); 3403 MAP_GL_FUNCTION(glEnableVertexAttribArray, glEnableVertexAttribArrayARB); 3404 MAP_GL_FUNCTION(glEndQuery, glEndQueryARB); 3405 MAP_GL_FUNCTION(glFramebufferTexture, glFramebufferTextureARB); 3406 MAP_GL_FUNCTION(glGenBuffers, glGenBuffersARB); 3407 MAP_GL_FUNCTION(glGenQueries, glGenQueriesARB); 3408 MAP_GL_FUNCTION(glGetActiveUniform, glGetActiveUniformARB); 3409 MAP_GL_FUNCTION(glGetAttachedShaders, glGetAttachedObjectsARB); 3410 MAP_GL_FUNCTION(glGetAttribLocation, glGetAttribLocationARB); 3411 MAP_GL_FUNCTION(glGetBooleani_v, glGetBooleanIndexedvEXT); 3412 MAP_GL_FUNCTION(glGetBufferSubData, glGetBufferSubDataARB); 3413 MAP_GL_FUNCTION(glGetCompressedTexImage, glGetCompressedTexImageARB); 3414 MAP_GL_FUNCTION(glGetDebugMessageLog, glGetDebugMessageLogARB); 3415 MAP_GL_FUNCTION(glGetIntegeri_v, glGetIntegerIndexedvEXT); 3416 MAP_GL_FUNCTION(glGetProgramInfoLog, glGetInfoLogARB); 3417 MAP_GL_FUNCTION(glGetProgramiv, glGetObjectParameterivARB); 3418 MAP_GL_FUNCTION(glGetQueryiv, glGetQueryivARB); 3419 MAP_GL_FUNCTION(glGetQueryObjectuiv, glGetQueryObjectuivARB); 3420 MAP_GL_FUNCTION(glGetShaderInfoLog, glGetInfoLogARB); 3421 MAP_GL_FUNCTION(glGetShaderiv, glGetObjectParameterivARB); 3422 MAP_GL_FUNCTION(glGetShaderSource, glGetShaderSourceARB); 3423 MAP_GL_FUNCTION(glGetUniformfv, glGetUniformfvARB); 3424 MAP_GL_FUNCTION(glGetUniformiv, glGetUniformivARB); 3425 MAP_GL_FUNCTION(glGetUniformLocation, glGetUniformLocationARB); 3426 MAP_GL_FUNCTION(glIsEnabledi, glIsEnabledIndexedEXT); 3427 MAP_GL_FUNCTION(glLinkProgram, glLinkProgramARB); 3428 MAP_GL_FUNCTION(glMapBuffer, glMapBufferARB); 3429 MAP_GL_FUNCTION_CAST(glShaderSource, glShaderSourceARB); 3430 MAP_GL_FUNCTION(glTexBuffer, glTexBufferARB); 3431 MAP_GL_FUNCTION_CAST(glTexImage3D, glTexImage3DEXT); 3432 MAP_GL_FUNCTION(glTexSubImage3D, glTexSubImage3DEXT); 3433 MAP_GL_FUNCTION(glUniform1f, glUniform1fARB); 3434 MAP_GL_FUNCTION(glUniform1fv, glUniform1fvARB); 3435 MAP_GL_FUNCTION(glUniform1i, glUniform1iARB); 3436 MAP_GL_FUNCTION(glUniform1iv, glUniform1ivARB); 3437 MAP_GL_FUNCTION(glUniform2f, glUniform2fARB); 3438 MAP_GL_FUNCTION(glUniform2fv, glUniform2fvARB); 3439 MAP_GL_FUNCTION(glUniform2i, glUniform2iARB); 3440 MAP_GL_FUNCTION(glUniform2iv, glUniform2ivARB); 3441 MAP_GL_FUNCTION(glUniform3f, glUniform3fARB); 3442 MAP_GL_FUNCTION(glUniform3fv, glUniform3fvARB); 3443 MAP_GL_FUNCTION(glUniform3i, glUniform3iARB); 3444 MAP_GL_FUNCTION(glUniform3iv, glUniform3ivARB); 3445 MAP_GL_FUNCTION(glUniform4f, glUniform4fARB); 3446 MAP_GL_FUNCTION(glUniform4fv, glUniform4fvARB); 3447 MAP_GL_FUNCTION(glUniform4i, glUniform4iARB); 3448 MAP_GL_FUNCTION(glUniform4iv, glUniform4ivARB); 3449 MAP_GL_FUNCTION(glUniformMatrix2fv, glUniformMatrix2fvARB); 3450 MAP_GL_FUNCTION(glUniformMatrix3fv, glUniformMatrix3fvARB); 3451 MAP_GL_FUNCTION(glUniformMatrix4fv, glUniformMatrix4fvARB); 3452 MAP_GL_FUNCTION(glUnmapBuffer, glUnmapBufferARB); 3453 MAP_GL_FUNCTION(glUseProgram, glUseProgramObjectARB); 3454 MAP_GL_FUNCTION(glValidateProgram, glValidateProgramARB); 3455 MAP_GL_FUNCTION(glVertexAttrib1f, glVertexAttrib1fARB); 3456 MAP_GL_FUNCTION(glVertexAttrib1fv, glVertexAttrib1fvARB); 3457 MAP_GL_FUNCTION(glVertexAttrib2f, glVertexAttrib2fARB); 3458 MAP_GL_FUNCTION(glVertexAttrib2fv, glVertexAttrib2fvARB); 3459 MAP_GL_FUNCTION(glVertexAttrib3f, glVertexAttrib3fARB); 3460 MAP_GL_FUNCTION(glVertexAttrib3fv, glVertexAttrib3fvARB); 3461 MAP_GL_FUNCTION(glVertexAttrib4f, glVertexAttrib4fARB); 3462 MAP_GL_FUNCTION(glVertexAttrib4fv, glVertexAttrib4fvARB); 3463 MAP_GL_FUNCTION(glVertexAttrib4Nsv, glVertexAttrib4NsvARB); 3464 MAP_GL_FUNCTION(glVertexAttrib4Nub, glVertexAttrib4NubARB); 3465 MAP_GL_FUNCTION(glVertexAttrib4Nubv, glVertexAttrib4NubvARB); 3466 MAP_GL_FUNCTION(glVertexAttrib4Nusv, glVertexAttrib4NusvARB); 3467 MAP_GL_FUNCTION(glVertexAttrib4sv, glVertexAttrib4svARB); 3468 MAP_GL_FUNCTION(glVertexAttrib4ubv, glVertexAttrib4ubvARB); 3469 MAP_GL_FUNCTION(glVertexAttribDivisor, glVertexAttribDivisorARB); 3470 MAP_GL_FUNCTION(glVertexAttribIPointer, glVertexAttribIPointerEXT); 3471 MAP_GL_FUNCTION(glVertexAttribPointer, glVertexAttribPointerARB); 3472 #undef MAP_GL_FUNCTION 3473 #undef MAP_GL_FUNCTION_CAST 3474 } 3475 3476 static void wined3d_adapter_init_limits(struct wined3d_gl_info *gl_info) 3477 { 3478 unsigned int i, sampler_count; 3479 GLfloat gl_floatv[2]; 3480 GLint gl_max; 3481 3482 gl_info->limits.blends = 1; 3483 gl_info->limits.buffers = 1; 3484 gl_info->limits.textures = 0; 3485 gl_info->limits.texture_coords = 0; 3486 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i) 3487 { 3488 gl_info->limits.uniform_blocks[i] = 0; 3489 gl_info->limits.samplers[i] = 0; 3490 } 3491 gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] = 1; 3492 gl_info->limits.combined_samplers = gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL]; 3493 gl_info->limits.graphics_samplers = gl_info->limits.combined_samplers; 3494 gl_info->limits.vertex_attribs = 16; 3495 gl_info->limits.texture_buffer_offset_alignment = 1; 3496 gl_info->limits.glsl_vs_float_constants = 0; 3497 gl_info->limits.glsl_ps_float_constants = 0; 3498 gl_info->limits.arb_vs_float_constants = 0; 3499 gl_info->limits.arb_vs_native_constants = 0; 3500 gl_info->limits.arb_vs_instructions = 0; 3501 gl_info->limits.arb_vs_temps = 0; 3502 gl_info->limits.arb_ps_float_constants = 0; 3503 gl_info->limits.arb_ps_local_constants = 0; 3504 gl_info->limits.arb_ps_instructions = 0; 3505 gl_info->limits.arb_ps_temps = 0; 3506 3507 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_CLIP_DISTANCES, &gl_max); 3508 gl_info->limits.user_clip_distances = min(MAX_CLIP_DISTANCES, gl_max); 3509 TRACE("Clip plane support - max planes %d.\n", gl_max); 3510 3511 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT]) 3512 { 3513 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_LIGHTS, &gl_max); 3514 gl_info->limits.lights = gl_max; 3515 TRACE("Light support - max lights %d.\n", gl_max); 3516 } 3517 3518 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max); 3519 gl_info->limits.texture_size = gl_max; 3520 TRACE("Maximum texture size support - max texture size %d.\n", gl_max); 3521 3522 gl_info->gl_ops.gl.p_glGetFloatv(gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] 3523 ? GL_ALIASED_POINT_SIZE_RANGE : GL_POINT_SIZE_RANGE, gl_floatv); 3524 gl_info->limits.pointsize_min = gl_floatv[0]; 3525 gl_info->limits.pointsize_max = gl_floatv[1]; 3526 TRACE("Maximum point size support - max point size %f.\n", gl_floatv[1]); 3527 3528 if (gl_info->supported[ARB_MAP_BUFFER_ALIGNMENT]) 3529 { 3530 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MIN_MAP_BUFFER_ALIGNMENT, &gl_max); 3531 TRACE("Minimum buffer map alignment: %d.\n", gl_max); 3532 } 3533 else 3534 { 3535 WARN_(d3d_perf)("Driver doesn't guarantee a minimum buffer map alignment.\n"); 3536 } 3537 if (gl_info->supported[NV_REGISTER_COMBINERS]) 3538 { 3539 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max); 3540 gl_info->limits.general_combiners = gl_max; 3541 TRACE("Max general combiners: %d.\n", gl_max); 3542 } 3543 if (gl_info->supported[ARB_DRAW_BUFFERS] && wined3d_settings.offscreen_rendering_mode == ORM_FBO) 3544 { 3545 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max); 3546 gl_info->limits.buffers = min(MAX_RENDER_TARGET_VIEWS, gl_max); 3547 TRACE("Max draw buffers: %u.\n", gl_max); 3548 } 3549 if (gl_info->supported[ARB_BLEND_FUNC_EXTENDED]) 3550 { 3551 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_DUAL_SOURCE_DRAW_BUFFERS, &gl_max); 3552 gl_info->limits.dual_buffers = gl_max; 3553 TRACE("Max dual source draw buffers: %u.\n", gl_max); 3554 } 3555 if (gl_info->supported[ARB_MULTITEXTURE]) 3556 { 3557 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT]) 3558 { 3559 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max); 3560 gl_info->limits.textures = min(MAX_TEXTURES, gl_max); 3561 TRACE("Max textures: %d.\n", gl_info->limits.textures); 3562 3563 if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) 3564 { 3565 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_COORDS_ARB, &gl_max); 3566 gl_info->limits.texture_coords = min(MAX_TEXTURES, gl_max); 3567 } 3568 else 3569 { 3570 gl_info->limits.texture_coords = gl_info->limits.textures; 3571 } 3572 TRACE("Max texture coords: %d.\n", gl_info->limits.texture_coords); 3573 } 3574 3575 if (gl_info->supported[ARB_FRAGMENT_PROGRAM] || gl_info->supported[ARB_FRAGMENT_SHADER]) 3576 { 3577 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &gl_max); 3578 gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] = gl_max; 3579 } 3580 else 3581 { 3582 gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] = gl_info->limits.textures; 3583 } 3584 TRACE("Max fragment samplers: %d.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL]); 3585 3586 if (gl_info->supported[ARB_VERTEX_SHADER]) 3587 { 3588 unsigned int vertex_sampler_count; 3589 3590 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &gl_max); 3591 vertex_sampler_count = gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX] = gl_max; 3592 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &gl_max); 3593 gl_info->limits.combined_samplers = gl_max; 3594 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &gl_max); 3595 gl_info->limits.vertex_attribs = gl_max; 3596 3597 /* Loading GLSL sampler uniforms is much simpler if we can assume that the sampler setup 3598 * is known at shader link time. In a vertex shader + pixel shader combination this isn't 3599 * an issue because then the sampler setup only depends on the two shaders. If a pixel 3600 * shader is used with fixed function vertex processing we're fine too because fixed function 3601 * vertex processing doesn't use any samplers. If fixed function fragment processing is 3602 * used we have to make sure that all vertex sampler setups are valid together with all 3603 * possible fixed function fragment processing setups. This is true if vsamplers + MAX_TEXTURES 3604 * <= max_samplers. This is true on all d3d9 cards that support vtf(gf 6 and gf7 cards). 3605 * dx9 radeon cards do not support vertex texture fetch. DX10 cards have 128 samplers, and 3606 * dx9 is limited to 8 fixed function texture stages and 4 vertex samplers. DX10 does not have 3607 * a fixed function pipeline anymore. 3608 * 3609 * So this is just a check to check that our assumption holds true. If not, write a warning 3610 * and reduce the number of vertex samplers or probably disable vertex texture fetch. */ 3611 if (vertex_sampler_count && gl_info->limits.combined_samplers < 12 3612 && MAX_TEXTURES + vertex_sampler_count > gl_info->limits.combined_samplers) 3613 { 3614 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n", 3615 vertex_sampler_count, gl_info->limits.combined_samplers); 3616 FIXME("Expected vertex samplers + MAX_TEXTURES(=8) > combined_samplers.\n"); 3617 if (gl_info->limits.combined_samplers > MAX_TEXTURES) 3618 vertex_sampler_count = gl_info->limits.combined_samplers - MAX_TEXTURES; 3619 else 3620 vertex_sampler_count = 0; 3621 gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX] = vertex_sampler_count; 3622 } 3623 } 3624 else 3625 { 3626 gl_info->limits.combined_samplers = gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL]; 3627 } 3628 TRACE("Max vertex samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX]); 3629 TRACE("Max combined samplers: %u.\n", gl_info->limits.combined_samplers); 3630 TRACE("Max vertex attributes: %u.\n", gl_info->limits.vertex_attribs); 3631 } 3632 else 3633 { 3634 gl_info->limits.textures = 1; 3635 gl_info->limits.texture_coords = 1; 3636 } 3637 3638 if (gl_info->supported[ARB_VERTEX_BLEND]) 3639 { 3640 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_UNITS_ARB, &gl_max); 3641 gl_info->limits.blends = gl_max; 3642 TRACE("Max blends: %u.\n", gl_info->limits.blends); 3643 } 3644 if (gl_info->supported[EXT_TEXTURE3D]) 3645 { 3646 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max); 3647 gl_info->limits.texture3d_size = gl_max; 3648 TRACE("Max texture3D size: %d.\n", gl_info->limits.texture3d_size); 3649 } 3650 if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC]) 3651 { 3652 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY, &gl_max); 3653 gl_info->limits.anisotropy = gl_max; 3654 TRACE("Max anisotropy: %d.\n", gl_info->limits.anisotropy); 3655 } 3656 if (gl_info->supported[ARB_FRAGMENT_PROGRAM]) 3657 { 3658 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max)); 3659 gl_info->limits.arb_ps_float_constants = gl_max; 3660 TRACE("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants); 3661 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max)); 3662 gl_info->limits.arb_ps_native_constants = gl_max; 3663 TRACE("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n", 3664 gl_info->limits.arb_ps_native_constants); 3665 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max)); 3666 gl_info->limits.arb_ps_temps = gl_max; 3667 TRACE("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps); 3668 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max)); 3669 gl_info->limits.arb_ps_instructions = gl_max; 3670 TRACE("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions); 3671 GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max)); 3672 gl_info->limits.arb_ps_local_constants = gl_max; 3673 TRACE("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions); 3674 } 3675 if (gl_info->supported[ARB_VERTEX_PROGRAM]) 3676 { 3677 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max)); 3678 gl_info->limits.arb_vs_float_constants = gl_max; 3679 TRACE("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants); 3680 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max)); 3681 gl_info->limits.arb_vs_native_constants = gl_max; 3682 TRACE("Max ARB_VERTEX_PROGRAM native float constants: %d.\n", 3683 gl_info->limits.arb_vs_native_constants); 3684 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max)); 3685 gl_info->limits.arb_vs_temps = gl_max; 3686 TRACE("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps); 3687 GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max)); 3688 gl_info->limits.arb_vs_instructions = gl_max; 3689 TRACE("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions); 3690 } 3691 if (gl_info->supported[ARB_VERTEX_SHADER]) 3692 { 3693 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max); 3694 gl_info->limits.glsl_vs_float_constants = gl_max / 4; 3695 TRACE("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants); 3696 3697 if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT]) 3698 { 3699 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &gl_max); 3700 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_VERTEX] = min(gl_max, WINED3D_MAX_CBS); 3701 TRACE("Max vertex uniform blocks: %u (%d).\n", 3702 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_VERTEX], gl_max); 3703 } 3704 } 3705 if (gl_info->supported[ARB_TESSELLATION_SHADER]) 3706 { 3707 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS, &gl_max); 3708 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_HULL] = min(gl_max, WINED3D_MAX_CBS); 3709 TRACE("Max hull uniform blocks: %u (%d).\n", 3710 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_HULL], gl_max); 3711 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS, &gl_max); 3712 gl_info->limits.samplers[WINED3D_SHADER_TYPE_HULL] = gl_max; 3713 TRACE("Max hull samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_HULL]); 3714 3715 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS, &gl_max); 3716 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_DOMAIN] = min(gl_max, WINED3D_MAX_CBS); 3717 TRACE("Max domain uniform blocks: %u (%d).\n", 3718 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_DOMAIN], gl_max); 3719 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS, &gl_max); 3720 gl_info->limits.samplers[WINED3D_SHADER_TYPE_DOMAIN] = gl_max; 3721 TRACE("Max domain samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_DOMAIN]); 3722 } 3723 if (gl_info->supported[WINED3D_GL_VERSION_3_2] && gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT]) 3724 { 3725 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_BLOCKS, &gl_max); 3726 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_GEOMETRY] = min(gl_max, WINED3D_MAX_CBS); 3727 TRACE("Max geometry uniform blocks: %u (%d).\n", 3728 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_GEOMETRY], gl_max); 3729 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &gl_max); 3730 gl_info->limits.samplers[WINED3D_SHADER_TYPE_GEOMETRY] = gl_max; 3731 TRACE("Max geometry samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_GEOMETRY]); 3732 } 3733 if (gl_info->supported[ARB_FRAGMENT_SHADER]) 3734 { 3735 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max); 3736 gl_info->limits.glsl_ps_float_constants = gl_max / 4; 3737 TRACE("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants); 3738 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max); 3739 gl_info->limits.glsl_varyings = gl_max; 3740 TRACE("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_max, gl_max / 4); 3741 3742 if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT]) 3743 { 3744 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, &gl_max); 3745 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_PIXEL] = min(gl_max, WINED3D_MAX_CBS); 3746 TRACE("Max fragment uniform blocks: %u (%d).\n", 3747 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_PIXEL], gl_max); 3748 } 3749 } 3750 if (gl_info->supported[ARB_COMPUTE_SHADER]) 3751 { 3752 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMPUTE_UNIFORM_BLOCKS, &gl_max); 3753 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_COMPUTE] = min(gl_max, WINED3D_MAX_CBS); 3754 TRACE("Max compute uniform blocks: %u (%d).\n", 3755 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_COMPUTE], gl_max); 3756 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, &gl_max); 3757 gl_info->limits.samplers[WINED3D_SHADER_TYPE_COMPUTE] = gl_max; 3758 TRACE("Max compute samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_COMPUTE]); 3759 } 3760 if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT]) 3761 { 3762 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMBINED_UNIFORM_BLOCKS, &gl_max); 3763 TRACE("Max combined uniform blocks: %d.\n", gl_max); 3764 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &gl_max); 3765 TRACE("Max uniform buffer bindings: %d.\n", gl_max); 3766 } 3767 if (gl_info->supported[ARB_TEXTURE_BUFFER_RANGE]) 3768 { 3769 gl_info->gl_ops.gl.p_glGetIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &gl_max); 3770 gl_info->limits.texture_buffer_offset_alignment = gl_max; 3771 TRACE("Minimum required texture buffer offset alignment %d.\n", gl_max); 3772 } 3773 if (gl_info->supported[ARB_SHADER_ATOMIC_COUNTERS]) 3774 { 3775 GLint max_fragment_buffers, max_combined_buffers, max_bindings; 3776 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, &max_fragment_buffers); 3777 TRACE("Max fragment atomic counter buffers: %d.\n", max_fragment_buffers); 3778 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS, &max_combined_buffers); 3779 TRACE("Max combined atomic counter buffers: %d.\n", max_combined_buffers); 3780 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &max_bindings); 3781 TRACE("Max atomic counter buffer bindings: %d.\n", max_bindings); 3782 if (max_fragment_buffers < MAX_UNORDERED_ACCESS_VIEWS 3783 || max_combined_buffers < MAX_UNORDERED_ACCESS_VIEWS 3784 || max_bindings < MAX_UNORDERED_ACCESS_VIEWS) 3785 { 3786 WARN("Disabling ARB_shader_atomic_counters.\n"); 3787 gl_info->supported[ARB_SHADER_ATOMIC_COUNTERS] = FALSE; 3788 } 3789 } 3790 if (gl_info->supported[ARB_TRANSFORM_FEEDBACK3]) 3791 { 3792 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_STREAMS, &gl_max); 3793 TRACE("Max vertex streams: %d.\n", gl_max); 3794 } 3795 3796 if (gl_info->supported[NV_LIGHT_MAX_EXPONENT]) 3797 gl_info->gl_ops.gl.p_glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess); 3798 else 3799 gl_info->limits.shininess = 128.0f; 3800 3801 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT] || gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE]) 3802 { 3803 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_SAMPLES, &gl_max); 3804 gl_info->limits.samples = gl_max; 3805 } 3806 3807 if (gl_info->supported[ARB_FRAMEBUFFER_NO_ATTACHMENTS]) 3808 { 3809 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAMEBUFFER_WIDTH, &gl_max); 3810 gl_info->limits.framebuffer_width = gl_max; 3811 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAMEBUFFER_HEIGHT, &gl_max); 3812 gl_info->limits.framebuffer_height = gl_max; 3813 } 3814 else 3815 { 3816 gl_info->limits.framebuffer_width = gl_info->limits.texture_size; 3817 gl_info->limits.framebuffer_height = gl_info->limits.texture_size; 3818 } 3819 3820 gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] = 3821 min(gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL], MAX_GL_FRAGMENT_SAMPLERS); 3822 sampler_count = 0; 3823 for (i = 0; i < WINED3D_SHADER_TYPE_GRAPHICS_COUNT; ++i) 3824 sampler_count += gl_info->limits.samplers[i]; 3825 if (gl_info->supported[WINED3D_GL_VERSION_3_2] && gl_info->limits.combined_samplers < sampler_count) 3826 { 3827 /* The minimum value for GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS in OpenGL 3828 * 3.2 is 48 (16 per stage). When tessellation shaders are supported 3829 * the minimum value is increased to 80. */ 3830 WARN("Graphics pipeline sampler count %u is greater than combined sampler count %u.\n", 3831 sampler_count, gl_info->limits.combined_samplers); 3832 for (i = 0; i < WINED3D_SHADER_TYPE_GRAPHICS_COUNT; ++i) 3833 gl_info->limits.samplers[i] = min(gl_info->limits.samplers[i], 16); 3834 } 3835 3836 /* A majority of OpenGL implementations allow us to statically partition 3837 * the set of texture bindings into six separate sets. */ 3838 gl_info->limits.graphics_samplers = gl_info->limits.combined_samplers; 3839 sampler_count = 0; 3840 for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i) 3841 sampler_count += gl_info->limits.samplers[i]; 3842 if (gl_info->limits.combined_samplers >= sampler_count) 3843 gl_info->limits.graphics_samplers -= gl_info->limits.samplers[WINED3D_SHADER_TYPE_COMPUTE]; 3844 } 3845 3846 /* Context activation is done by the caller. */ 3847 static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter, 3848 struct wined3d_caps_gl_ctx *caps_gl_ctx, DWORD wined3d_creation_flags) 3849 { 3850 static const struct 3851 { 3852 enum wined3d_gl_extension extension; 3853 DWORD min_gl_version; 3854 } 3855 core_extensions[] = 3856 { 3857 {EXT_TEXTURE3D, MAKEDWORD_VERSION(1, 2)}, 3858 {ARB_MULTISAMPLE, MAKEDWORD_VERSION(1, 3)}, 3859 {ARB_MULTITEXTURE, MAKEDWORD_VERSION(1, 3)}, 3860 {ARB_TEXTURE_BORDER_CLAMP, MAKEDWORD_VERSION(1, 3)}, 3861 {ARB_TEXTURE_COMPRESSION, MAKEDWORD_VERSION(1, 3)}, 3862 {ARB_TEXTURE_CUBE_MAP, MAKEDWORD_VERSION(1, 3)}, 3863 {ARB_DEPTH_TEXTURE, MAKEDWORD_VERSION(1, 4)}, 3864 {ARB_POINT_PARAMETERS, MAKEDWORD_VERSION(1, 4)}, 3865 {ARB_SHADOW, MAKEDWORD_VERSION(1, 4)}, 3866 {ARB_TEXTURE_MIRRORED_REPEAT, MAKEDWORD_VERSION(1, 4)}, 3867 {EXT_BLEND_COLOR, MAKEDWORD_VERSION(1, 4)}, 3868 {EXT_BLEND_FUNC_SEPARATE, MAKEDWORD_VERSION(1, 4)}, 3869 {EXT_BLEND_MINMAX, MAKEDWORD_VERSION(1, 4)}, 3870 {EXT_BLEND_SUBTRACT, MAKEDWORD_VERSION(1, 4)}, 3871 {EXT_STENCIL_WRAP, MAKEDWORD_VERSION(1, 4)}, 3872 {NV_POINT_SPRITE, MAKEDWORD_VERSION(1, 4)}, 3873 {ARB_OCCLUSION_QUERY, MAKEDWORD_VERSION(1, 5)}, 3874 {ARB_VERTEX_BUFFER_OBJECT, MAKEDWORD_VERSION(1, 5)}, 3875 {ARB_DRAW_BUFFERS, MAKEDWORD_VERSION(2, 0)}, 3876 {ARB_FRAGMENT_SHADER, MAKEDWORD_VERSION(2, 0)}, 3877 {ARB_SHADING_LANGUAGE_100, MAKEDWORD_VERSION(2, 0)}, 3878 {ARB_TEXTURE_NON_POWER_OF_TWO, MAKEDWORD_VERSION(2, 0)}, 3879 {ARB_VERTEX_SHADER, MAKEDWORD_VERSION(2, 0)}, 3880 {EXT_BLEND_EQUATION_SEPARATE, MAKEDWORD_VERSION(2, 0)}, 3881 {ARB_PIXEL_BUFFER_OBJECT, MAKEDWORD_VERSION(2, 1)}, 3882 {EXT_TEXTURE_SRGB, MAKEDWORD_VERSION(2, 1)}, 3883 {ARB_COLOR_BUFFER_FLOAT, MAKEDWORD_VERSION(3, 0)}, 3884 {ARB_DEPTH_BUFFER_FLOAT, MAKEDWORD_VERSION(3, 0)}, 3885 {ARB_FRAMEBUFFER_OBJECT, MAKEDWORD_VERSION(3, 0)}, 3886 {ARB_FRAMEBUFFER_SRGB, MAKEDWORD_VERSION(3, 0)}, 3887 {ARB_HALF_FLOAT_PIXEL, MAKEDWORD_VERSION(3, 0)}, 3888 {ARB_HALF_FLOAT_VERTEX, MAKEDWORD_VERSION(3, 0)}, 3889 {ARB_MAP_BUFFER_RANGE, MAKEDWORD_VERSION(3, 0)}, 3890 {ARB_TEXTURE_COMPRESSION_RGTC, MAKEDWORD_VERSION(3, 0)}, 3891 {ARB_TEXTURE_FLOAT, MAKEDWORD_VERSION(3, 0)}, 3892 {ARB_TEXTURE_RG, MAKEDWORD_VERSION(3, 0)}, 3893 {EXT_DRAW_BUFFERS2, MAKEDWORD_VERSION(3, 0)}, 3894 {EXT_PACKED_FLOAT, MAKEDWORD_VERSION(3, 0)}, 3895 {EXT_TEXTURE_ARRAY, MAKEDWORD_VERSION(3, 0)}, 3896 {EXT_TEXTURE_INTEGER, MAKEDWORD_VERSION(3, 0)}, 3897 {EXT_TEXTURE_SHARED_EXPONENT, MAKEDWORD_VERSION(3, 0)}, 3898 /* We don't want to enable EXT_GPU_SHADER4: even though similar 3899 * functionality is available in core GL 3.0 / GLSL 1.30, it's different 3900 * enough that reusing the same flag for the new features hurts more 3901 * than it helps. */ 3902 /* EXT_framebuffer_object, EXT_framebuffer_blit, 3903 * EXT_framebuffer_multisample and EXT_packed_depth_stencil 3904 * are integrated into ARB_framebuffer_object. */ 3905 3906 {ARB_COPY_BUFFER, MAKEDWORD_VERSION(3, 1)}, 3907 {ARB_DRAW_INSTANCED, MAKEDWORD_VERSION(3, 1)}, 3908 {ARB_TEXTURE_BUFFER_OBJECT, MAKEDWORD_VERSION(3, 1)}, 3909 {ARB_UNIFORM_BUFFER_OBJECT, MAKEDWORD_VERSION(3, 1)}, 3910 {EXT_TEXTURE_SNORM, MAKEDWORD_VERSION(3, 1)}, 3911 /* We don't need or want GL_ARB_texture_rectangle (core in 3.1). */ 3912 3913 {ARB_DRAW_ELEMENTS_BASE_VERTEX, MAKEDWORD_VERSION(3, 2)}, 3914 /* ARB_geometry_shader4 exposes a somewhat different API compared to 3.2 3915 * core geometry shaders so it's not really correct to expose the 3916 * extension for core-only support. */ 3917 {ARB_FRAGMENT_COORD_CONVENTIONS, MAKEDWORD_VERSION(3, 2)}, 3918 {ARB_PROVOKING_VERTEX, MAKEDWORD_VERSION(3, 2)}, 3919 {ARB_SEAMLESS_CUBE_MAP, MAKEDWORD_VERSION(3, 2)}, 3920 {ARB_SYNC, MAKEDWORD_VERSION(3, 2)}, 3921 {ARB_TEXTURE_MULTISAMPLE, MAKEDWORD_VERSION(3, 2)}, 3922 {ARB_VERTEX_ARRAY_BGRA, MAKEDWORD_VERSION(3, 2)}, 3923 3924 {ARB_BLEND_FUNC_EXTENDED, MAKEDWORD_VERSION(3, 3)}, 3925 {ARB_EXPLICIT_ATTRIB_LOCATION, MAKEDWORD_VERSION(3, 3)}, 3926 {ARB_INSTANCED_ARRAYS, MAKEDWORD_VERSION(3, 3)}, 3927 {ARB_SAMPLER_OBJECTS, MAKEDWORD_VERSION(3, 3)}, 3928 {ARB_SHADER_BIT_ENCODING, MAKEDWORD_VERSION(3, 3)}, 3929 {ARB_TEXTURE_RGB10_A2UI, MAKEDWORD_VERSION(3, 3)}, 3930 {ARB_TEXTURE_SWIZZLE, MAKEDWORD_VERSION(3, 3)}, 3931 {ARB_TIMER_QUERY, MAKEDWORD_VERSION(3, 3)}, 3932 {ARB_VERTEX_TYPE_2_10_10_10_REV, MAKEDWORD_VERSION(3, 3)}, 3933 3934 {ARB_DRAW_INDIRECT, MAKEDWORD_VERSION(4, 0)}, 3935 {ARB_GPU_SHADER5, MAKEDWORD_VERSION(4, 0)}, 3936 {ARB_TESSELLATION_SHADER, MAKEDWORD_VERSION(4, 0)}, 3937 {ARB_TEXTURE_CUBE_MAP_ARRAY, MAKEDWORD_VERSION(4, 0)}, 3938 {ARB_TEXTURE_GATHER, MAKEDWORD_VERSION(4, 0)}, 3939 {ARB_TRANSFORM_FEEDBACK2, MAKEDWORD_VERSION(4, 0)}, 3940 {ARB_TRANSFORM_FEEDBACK3, MAKEDWORD_VERSION(4, 0)}, 3941 3942 {ARB_ES2_COMPATIBILITY, MAKEDWORD_VERSION(4, 1)}, 3943 {ARB_VIEWPORT_ARRAY, MAKEDWORD_VERSION(4, 1)}, 3944 3945 {ARB_BASE_INSTANCE, MAKEDWORD_VERSION(4, 2)}, 3946 {ARB_CONSERVATIVE_DEPTH, MAKEDWORD_VERSION(4, 2)}, 3947 {ARB_INTERNALFORMAT_QUERY, MAKEDWORD_VERSION(4, 2)}, 3948 {ARB_MAP_BUFFER_ALIGNMENT, MAKEDWORD_VERSION(4, 2)}, 3949 {ARB_SHADER_ATOMIC_COUNTERS, MAKEDWORD_VERSION(4, 2)}, 3950 {ARB_SHADER_IMAGE_LOAD_STORE, MAKEDWORD_VERSION(4, 2)}, 3951 {ARB_SHADING_LANGUAGE_420PACK, MAKEDWORD_VERSION(4, 2)}, 3952 {ARB_SHADING_LANGUAGE_PACKING, MAKEDWORD_VERSION(4, 2)}, 3953 {ARB_TEXTURE_COMPRESSION_BPTC, MAKEDWORD_VERSION(4, 2)}, 3954 {ARB_TEXTURE_STORAGE, MAKEDWORD_VERSION(4, 2)}, 3955 3956 {ARB_CLEAR_BUFFER_OBJECT, MAKEDWORD_VERSION(4, 3)}, 3957 {ARB_COMPUTE_SHADER, MAKEDWORD_VERSION(4, 3)}, 3958 {ARB_COPY_IMAGE, MAKEDWORD_VERSION(4, 3)}, 3959 {ARB_DEBUG_OUTPUT, MAKEDWORD_VERSION(4, 3)}, 3960 {ARB_ES3_COMPATIBILITY, MAKEDWORD_VERSION(4, 3)}, 3961 {ARB_FRAGMENT_LAYER_VIEWPORT, MAKEDWORD_VERSION(4, 3)}, 3962 {ARB_FRAMEBUFFER_NO_ATTACHMENTS, MAKEDWORD_VERSION(4, 3)}, 3963 {ARB_INTERNALFORMAT_QUERY2, MAKEDWORD_VERSION(4, 3)}, 3964 {ARB_SHADER_IMAGE_SIZE, MAKEDWORD_VERSION(4, 3)}, 3965 {ARB_SHADER_STORAGE_BUFFER_OBJECT, MAKEDWORD_VERSION(4, 3)}, 3966 {ARB_STENCIL_TEXTURING, MAKEDWORD_VERSION(4, 3)}, 3967 {ARB_TEXTURE_BUFFER_RANGE, MAKEDWORD_VERSION(4, 3)}, 3968 {ARB_TEXTURE_QUERY_LEVELS, MAKEDWORD_VERSION(4, 3)}, 3969 {ARB_TEXTURE_STORAGE_MULTISAMPLE, MAKEDWORD_VERSION(4, 2)}, 3970 {ARB_TEXTURE_VIEW, MAKEDWORD_VERSION(4, 3)}, 3971 3972 {ARB_CLEAR_TEXTURE, MAKEDWORD_VERSION(4, 4)}, 3973 3974 {ARB_CLIP_CONTROL, MAKEDWORD_VERSION(4, 5)}, 3975 {ARB_CULL_DISTANCE, MAKEDWORD_VERSION(4, 5)}, 3976 {ARB_DERIVATIVE_CONTROL, MAKEDWORD_VERSION(4, 5)}, 3977 3978 {ARB_PIPELINE_STATISTICS_QUERY, MAKEDWORD_VERSION(4, 6)}, 3979 {ARB_TEXTURE_FILTER_ANISOTROPIC, MAKEDWORD_VERSION(4, 6)}, 3980 }; 3981 struct wined3d_driver_info *driver_info = &adapter->driver_info; 3982 const char *gl_vendor_str, *gl_renderer_str, *gl_version_str; 3983 struct wined3d_gl_info *gl_info = &adapter->gl_info; 3984 const struct gpu_description *gpu_description; 3985 struct wined3d_vertex_caps vertex_caps; 3986 struct fragment_caps fragment_caps; 3987 struct shader_caps shader_caps; 3988 const char *WGL_Extensions = NULL; 3989 enum wined3d_gl_vendor gl_vendor; 3990 DWORD gl_version, gl_ext_emul_mask; 3991 UINT64 vram_bytes = 0; 3992 HDC hdc; 3993 unsigned int i, j; 3994 GLint context_profile = 0; 3995 3996 TRACE("adapter %p.\n", adapter); 3997 3998 gl_renderer_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_RENDERER); 3999 TRACE("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str)); 4000 if (!gl_renderer_str) 4001 { 4002 ERR("Received a NULL GL_RENDERER.\n"); 4003 return FALSE; 4004 } 4005 4006 gl_vendor_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VENDOR); 4007 TRACE("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str)); 4008 if (!gl_vendor_str) 4009 { 4010 ERR("Received a NULL GL_VENDOR.\n"); 4011 return FALSE; 4012 } 4013 4014 /* Parse the GL_VERSION field into major and minor information */ 4015 gl_version_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VERSION); 4016 TRACE("GL_VERSION: %s.\n", debugstr_a(gl_version_str)); 4017 if (!gl_version_str) 4018 { 4019 ERR("Received a NULL GL_VERSION.\n"); 4020 return FALSE; 4021 } 4022 gl_version = wined3d_parse_gl_version(gl_version_str); 4023 4024 load_gl_funcs(gl_info); 4025 4026 memset(gl_info->supported, 0, sizeof(gl_info->supported)); 4027 gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE; 4028 4029 if (gl_version >= MAKEDWORD_VERSION(3, 2)) 4030 { 4031 gl_info->gl_ops.gl.p_glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &context_profile); 4032 checkGLcall("Querying context profile"); 4033 } 4034 if (context_profile & GL_CONTEXT_CORE_PROFILE_BIT) 4035 TRACE("Got a core profile context.\n"); 4036 else 4037 gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] = TRUE; 4038 4039 TRACE("GL extensions reported:\n"); 4040 if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT]) 4041 { 4042 const char *gl_extensions = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_EXTENSIONS); 4043 4044 if (!gl_extensions) 4045 { 4046 ERR("Received a NULL GL_EXTENSIONS.\n"); 4047 return FALSE; 4048 } 4049 parse_extension_string(gl_info, gl_extensions, gl_extension_map, ARRAY_SIZE(gl_extension_map)); 4050 } 4051 else 4052 { 4053 enumerate_gl_extensions(gl_info, gl_extension_map, ARRAY_SIZE(gl_extension_map)); 4054 } 4055 4056 hdc = wglGetCurrentDC(); 4057 /* Not all GL drivers might offer WGL extensions e.g. VirtualBox. */ 4058 if (GL_EXTCALL(wglGetExtensionsStringARB)) 4059 WGL_Extensions = (const char *)GL_EXTCALL(wglGetExtensionsStringARB(hdc)); 4060 if (!WGL_Extensions) 4061 WARN("WGL extensions not supported.\n"); 4062 else 4063 parse_extension_string(gl_info, WGL_Extensions, wgl_extension_map, ARRAY_SIZE(wgl_extension_map)); 4064 4065 for (i = 0; i < ARRAY_SIZE(core_extensions); ++i) 4066 { 4067 if (!gl_info->supported[core_extensions[i].extension] 4068 && gl_version >= core_extensions[i].min_gl_version) 4069 { 4070 for (j = 0; j < ARRAY_SIZE(gl_extension_map); ++j) 4071 if (gl_extension_map[j].extension == core_extensions[i].extension) 4072 break; 4073 4074 if (j < ARRAY_SIZE(gl_extension_map)) 4075 { 4076 TRACE("GL CORE: %s support.\n", gl_extension_map[j].extension_string); 4077 gl_info->supported[core_extensions[i].extension] = TRUE; 4078 } 4079 else 4080 { 4081 FIXME("GL extension %u not in the GL extensions map.\n", core_extensions[i].extension); 4082 } 4083 } 4084 } 4085 4086 if (gl_info->supported[EXT_BLEND_MINMAX] || gl_info->supported[EXT_BLEND_SUBTRACT]) 4087 gl_info->supported[WINED3D_GL_BLEND_EQUATION] = TRUE; 4088 4089 if (gl_version >= MAKEDWORD_VERSION(2, 0)) 4090 gl_info->supported[WINED3D_GL_VERSION_2_0] = TRUE; 4091 if (gl_version >= MAKEDWORD_VERSION(3, 2)) 4092 gl_info->supported[WINED3D_GL_VERSION_3_2] = TRUE; 4093 4094 /* All the points are actually point sprites in core contexts, the APIs from 4095 * ARB_point_sprite are not supported anymore. */ 4096 if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT]) 4097 gl_info->supported[ARB_POINT_SPRITE] = FALSE; 4098 4099 if (gl_info->supported[APPLE_FENCE]) 4100 { 4101 /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically. 4102 * The apple extension interacts with some other apple exts. Disable the NV 4103 * extension if the apple one is support to prevent confusion in other parts 4104 * of the code. */ 4105 gl_info->supported[NV_FENCE] = FALSE; 4106 } 4107 if (gl_info->supported[APPLE_FLOAT_PIXELS]) 4108 { 4109 /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel 4110 * 4111 * The enums are the same: 4112 * GL_RGBA16F_ARB = GL_RGBA_FLOAT16_APPLE = 0x881a 4113 * GL_RGB16F_ARB = GL_RGB_FLOAT16_APPLE = 0x881b 4114 * GL_RGBA32F_ARB = GL_RGBA_FLOAT32_APPLE = 0x8814 4115 * GL_RGB32F_ARB = GL_RGB_FLOAT32_APPLE = 0x8815 4116 * GL_HALF_FLOAT_ARB = GL_HALF_APPLE = 0x140b 4117 */ 4118 if (!gl_info->supported[ARB_TEXTURE_FLOAT]) 4119 { 4120 TRACE(" IMPLIED: GL_ARB_texture_float support (by GL_APPLE_float_pixels).\n"); 4121 gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE; 4122 } 4123 if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL]) 4124 { 4125 TRACE(" IMPLIED: GL_ARB_half_float_pixel support (by GL_APPLE_float_pixels).\n"); 4126 gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE; 4127 } 4128 } 4129 if (gl_info->supported[ARB_MAP_BUFFER_RANGE]) 4130 { 4131 /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same 4132 * functionality. Prefer the ARB extension */ 4133 gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE; 4134 } 4135 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) 4136 { 4137 TRACE(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n"); 4138 gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE; 4139 } 4140 if (!gl_info->supported[ARB_VERTEX_ARRAY_BGRA] && gl_info->supported[EXT_VERTEX_ARRAY_BGRA]) 4141 { 4142 TRACE(" IMPLIED: ARB_vertex_array_bgra support (by EXT_vertex_array_bgra).\n"); 4143 gl_info->supported[ARB_VERTEX_ARRAY_BGRA] = TRUE; 4144 } 4145 if (!gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC]) 4146 { 4147 TRACE(" IMPLIED: EXT_texture_compression_rgtc support (by ARB_texture_compression_rgtc).\n"); 4148 gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC] = TRUE; 4149 } 4150 if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC]) 4151 { 4152 TRACE(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n"); 4153 gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = TRUE; 4154 } 4155 if (gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && !gl_info->supported[ARB_TEXTURE_RG]) 4156 { 4157 TRACE("ARB_texture_rg not supported, disabling ARB_texture_compression_rgtc.\n"); 4158 gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = FALSE; 4159 } 4160 if (gl_info->supported[NV_TEXTURE_SHADER2]) 4161 { 4162 if (gl_info->supported[NV_REGISTER_COMBINERS]) 4163 { 4164 /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2 4165 * are supported. The nv extensions provide the same functionality as the 4166 * ATI one, and a bit more(signed pixelformats). */ 4167 gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE; 4168 } 4169 } 4170 if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) 4171 { 4172 /* If we have full NP2 texture support, disable 4173 * GL_ARB_texture_rectangle because we will never use it. 4174 * This saves a few redundant glDisable calls. */ 4175 gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE; 4176 } 4177 if (gl_info->supported[ATI_FRAGMENT_SHADER]) 4178 { 4179 /* Disable NV_register_combiners and fragment shader if this is supported. 4180 * generally the NV extensions are preferred over the ATI ones, and this 4181 * extension is disabled if register_combiners and texture_shader2 are both 4182 * supported. So we reach this place only if we have incomplete NV dxlevel 8 4183 * fragment processing support. */ 4184 gl_info->supported[NV_REGISTER_COMBINERS] = FALSE; 4185 gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE; 4186 gl_info->supported[NV_TEXTURE_SHADER] = FALSE; 4187 gl_info->supported[NV_TEXTURE_SHADER2] = FALSE; 4188 } 4189 if (gl_info->supported[NV_HALF_FLOAT]) 4190 { 4191 /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */ 4192 gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE; 4193 } 4194 if (gl_info->supported[ARB_FRAMEBUFFER_SRGB] && !gl_info->supported[EXT_TEXTURE_SRGB_DECODE]) 4195 { 4196 /* Current wined3d sRGB infrastructure requires EXT_texture_sRGB_decode 4197 * for GL_ARB_framebuffer_sRGB support (without EXT_texture_sRGB_decode 4198 * we never render to sRGB surfaces). */ 4199 TRACE("EXT_texture_sRGB_decode is not supported, disabling ARB_framebuffer_sRGB.\n"); 4200 gl_info->supported[ARB_FRAMEBUFFER_SRGB] = FALSE; 4201 } 4202 if (gl_info->supported[ARB_OCCLUSION_QUERY]) 4203 { 4204 GLint counter_bits; 4205 4206 GL_EXTCALL(glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &counter_bits)); 4207 TRACE("Occlusion query counter has %d bits.\n", counter_bits); 4208 if (!counter_bits) 4209 gl_info->supported[ARB_OCCLUSION_QUERY] = FALSE; 4210 } 4211 if (gl_info->supported[ARB_TIMER_QUERY]) 4212 { 4213 GLint counter_bits; 4214 4215 GL_EXTCALL(glGetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &counter_bits)); 4216 TRACE("Timestamp query counter has %d bits.\n", counter_bits); 4217 if (!counter_bits) 4218 gl_info->supported[ARB_TIMER_QUERY] = FALSE; 4219 } 4220 if (gl_version >= MAKEDWORD_VERSION(3, 0)) 4221 { 4222 GLint counter_bits; 4223 4224 gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY] = TRUE; 4225 4226 GL_EXTCALL(glGetQueryiv(GL_PRIMITIVES_GENERATED, GL_QUERY_COUNTER_BITS, &counter_bits)); 4227 TRACE("Primitives query counter has %d bits.\n", counter_bits); 4228 if (!counter_bits) 4229 gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY] = FALSE; 4230 4231 GL_EXTCALL(glGetQueryiv(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_QUERY_COUNTER_BITS, &counter_bits)); 4232 TRACE("Transform feedback primitives query counter has %d bits.\n", counter_bits); 4233 if (!counter_bits) 4234 gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY] = FALSE; 4235 } 4236 if (gl_info->supported[ARB_VIEWPORT_ARRAY]) 4237 { 4238 GLint subpixel_bits; 4239 4240 gl_info->gl_ops.gl.p_glGetIntegerv(GL_VIEWPORT_SUBPIXEL_BITS, &subpixel_bits); 4241 TRACE("Viewport supports %d subpixel bits.\n", subpixel_bits); 4242 if (subpixel_bits < 8 && gl_info->supported[ARB_CLIP_CONTROL]) 4243 { 4244 TRACE("Disabling ARB_clip_control because viewport subpixel bits < 8.\n"); 4245 gl_info->supported[ARB_CLIP_CONTROL] = FALSE; 4246 } 4247 } 4248 if (gl_info->supported[ARB_CLIP_CONTROL] && !gl_info->supported[ARB_VIEWPORT_ARRAY]) 4249 { 4250 /* When using ARB_clip_control we need the float viewport parameters 4251 * introduced by ARB_viewport_array to take care of the shifted pixel 4252 * coordinates. */ 4253 TRACE("Disabling ARB_clip_control because ARB_viewport_array is not supported.\n"); 4254 gl_info->supported[ARB_CLIP_CONTROL] = FALSE; 4255 } 4256 if (gl_info->supported[ARB_STENCIL_TEXTURING] && !gl_info->supported[ARB_TEXTURE_SWIZZLE]) 4257 { 4258 /* The stencil value needs to be placed in the green channel. */ 4259 TRACE("Disabling ARB_stencil_texturing because ARB_texture_swizzle is not supported.\n"); 4260 gl_info->supported[ARB_STENCIL_TEXTURING] = FALSE; 4261 } 4262 if (!gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] && gl_info->supported[EXT_TEXTURE_MIRROR_CLAMP]) 4263 { 4264 TRACE(" IMPLIED: ATI_texture_mirror_once support (by EXT_texture_mirror_clamp).\n"); 4265 gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] = TRUE; 4266 } 4267 if (!gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] && gl_info->supported[ATI_TEXTURE_MIRROR_ONCE]) 4268 { 4269 TRACE(" IMPLIED: ARB_texture_mirror_clamp_to_edge support (by ATI_texture_mirror_once).\n"); 4270 gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] = TRUE; 4271 } 4272 if (gl_info->supported[ARB_TEXTURE_STORAGE] && gl_info->supported[APPLE_YCBCR_422]) 4273 { 4274 /* AFAIK APPLE_ycbcr_422 is only available in legacy contexts so we shouldn't ever hit this. */ 4275 ERR("Disabling APPLE_ycbcr_422 because of ARB_texture_storage.\n"); 4276 gl_info->supported[APPLE_YCBCR_422] = FALSE; 4277 } 4278 if (gl_info->supported[ARB_DRAW_INDIRECT] && !gl_info->supported[ARB_BASE_INSTANCE]) 4279 { 4280 /* If ARB_base_instance is not supported the baseInstance field 4281 * in indirect draw parameters must be 0 or behavior is undefined. 4282 */ 4283 WARN("Disabling ARB_draw_indirect because ARB_base_instance is not supported.\n"); 4284 gl_info->supported[ARB_DRAW_INDIRECT] = FALSE; 4285 } 4286 if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE] && !wined3d_settings.multisample_textures) 4287 gl_info->supported[ARB_TEXTURE_MULTISAMPLE] = FALSE; 4288 if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE] && !gl_info->supported[ARB_TEXTURE_STORAGE_MULTISAMPLE]) 4289 { 4290 WARN("Disabling ARB_texture_multisample because immutable storage is not supported.\n"); 4291 gl_info->supported[ARB_TEXTURE_MULTISAMPLE] = FALSE; 4292 } 4293 4294 wined3d_adapter_init_limits(gl_info); 4295 4296 if (gl_info->supported[ARB_VERTEX_PROGRAM] && test_arb_vs_offset_limit(gl_info)) 4297 gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT; 4298 4299 if (gl_info->supported[ARB_SHADING_LANGUAGE_100]) 4300 { 4301 const char *str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_SHADING_LANGUAGE_VERSION_ARB); 4302 unsigned int major, minor; 4303 4304 TRACE("GLSL version string: %s.\n", debugstr_a(str)); 4305 4306 /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */ 4307 sscanf(str, "%u.%u", &major, &minor); 4308 gl_info->glsl_version = MAKEDWORD_VERSION(major, minor); 4309 if (gl_info->glsl_version >= MAKEDWORD_VERSION(1, 30)) 4310 gl_info->supported[WINED3D_GLSL_130] = TRUE; 4311 } 4312 4313 checkGLcall("extension detection"); 4314 4315 adapter->shader_backend = select_shader_backend(gl_info); 4316 adapter->vertex_pipe = select_vertex_implementation(gl_info, adapter->shader_backend); 4317 adapter->fragment_pipe = select_fragment_implementation(gl_info, adapter->shader_backend); 4318 4319 adapter->shader_backend->shader_get_caps(gl_info, &shader_caps); 4320 adapter->d3d_info.vs_clipping = shader_caps.wined3d_caps & WINED3D_SHADER_CAP_VS_CLIPPING; 4321 adapter->d3d_info.limits.vs_version = shader_caps.vs_version; 4322 adapter->d3d_info.limits.hs_version = shader_caps.hs_version; 4323 adapter->d3d_info.limits.ds_version = shader_caps.ds_version; 4324 adapter->d3d_info.limits.gs_version = shader_caps.gs_version; 4325 adapter->d3d_info.limits.ps_version = shader_caps.ps_version; 4326 adapter->d3d_info.limits.cs_version = shader_caps.cs_version; 4327 adapter->d3d_info.limits.vs_uniform_count = shader_caps.vs_uniform_count; 4328 adapter->d3d_info.limits.ps_uniform_count = shader_caps.ps_uniform_count; 4329 adapter->d3d_info.limits.varying_count = shader_caps.varying_count; 4330 adapter->d3d_info.shader_double_precision = shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION; 4331 4332 adapter->vertex_pipe->vp_get_caps(gl_info, &vertex_caps); 4333 adapter->d3d_info.xyzrhw = vertex_caps.xyzrhw; 4334 adapter->d3d_info.ffp_generic_attributes = vertex_caps.ffp_generic_attributes; 4335 adapter->d3d_info.limits.ffp_vertex_blend_matrices = vertex_caps.max_vertex_blend_matrices; 4336 adapter->d3d_info.limits.active_light_count = vertex_caps.max_active_lights; 4337 adapter->d3d_info.emulated_flatshading = vertex_caps.emulated_flatshading; 4338 4339 adapter->fragment_pipe->get_caps(gl_info, &fragment_caps); 4340 adapter->d3d_info.limits.ffp_blend_stages = fragment_caps.MaxTextureBlendStages; 4341 adapter->d3d_info.limits.ffp_textures = fragment_caps.MaxSimultaneousTextures; 4342 adapter->d3d_info.shader_color_key = fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_COLOR_KEY; 4343 adapter->d3d_info.wined3d_creation_flags = wined3d_creation_flags; 4344 TRACE("Max texture stages: %u.\n", adapter->d3d_info.limits.ffp_blend_stages); 4345 4346 adapter->d3d_info.valid_rt_mask = 0; 4347 for (i = 0; i < gl_info->limits.buffers; ++i) 4348 adapter->d3d_info.valid_rt_mask |= (1u << i); 4349 4350 adapter->d3d_info.valid_dual_rt_mask = 0; 4351 for (i = 0; i < gl_info->limits.dual_buffers; ++i) 4352 adapter->d3d_info.valid_dual_rt_mask |= (1u << i); 4353 4354 if (!adapter->d3d_info.shader_color_key) 4355 { 4356 /* We do not want to deal with re-creating immutable texture storage for color keying emulation. */ 4357 WARN("Disabling ARB_texture_storage because fragment pipe doesn't support color keying.\n"); 4358 gl_info->supported[ARB_TEXTURE_STORAGE] = FALSE; 4359 } 4360 4361 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT]) 4362 { 4363 gl_info->fbo_ops.glIsRenderbuffer = gl_info->gl_ops.ext.p_glIsRenderbuffer; 4364 gl_info->fbo_ops.glBindRenderbuffer = gl_info->gl_ops.ext.p_glBindRenderbuffer; 4365 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->gl_ops.ext.p_glDeleteRenderbuffers; 4366 gl_info->fbo_ops.glGenRenderbuffers = gl_info->gl_ops.ext.p_glGenRenderbuffers; 4367 gl_info->fbo_ops.glRenderbufferStorage = gl_info->gl_ops.ext.p_glRenderbufferStorage; 4368 gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->gl_ops.ext.p_glRenderbufferStorageMultisample; 4369 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->gl_ops.ext.p_glGetRenderbufferParameteriv; 4370 gl_info->fbo_ops.glIsFramebuffer = gl_info->gl_ops.ext.p_glIsFramebuffer; 4371 gl_info->fbo_ops.glBindFramebuffer = gl_info->gl_ops.ext.p_glBindFramebuffer; 4372 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->gl_ops.ext.p_glDeleteFramebuffers; 4373 gl_info->fbo_ops.glGenFramebuffers = gl_info->gl_ops.ext.p_glGenFramebuffers; 4374 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->gl_ops.ext.p_glCheckFramebufferStatus; 4375 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->gl_ops.ext.p_glFramebufferTexture1D; 4376 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->gl_ops.ext.p_glFramebufferTexture2D; 4377 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->gl_ops.ext.p_glFramebufferTexture3D; 4378 gl_info->fbo_ops.glFramebufferTextureLayer = gl_info->gl_ops.ext.p_glFramebufferTextureLayer; 4379 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->gl_ops.ext.p_glFramebufferRenderbuffer; 4380 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv 4381 = gl_info->gl_ops.ext.p_glGetFramebufferAttachmentParameteriv; 4382 gl_info->fbo_ops.glBlitFramebuffer = gl_info->gl_ops.ext.p_glBlitFramebuffer; 4383 gl_info->fbo_ops.glGenerateMipmap = gl_info->gl_ops.ext.p_glGenerateMipmap; 4384 gl_info->fbo_ops.glFramebufferTexture = gl_info->gl_ops.ext.p_glFramebufferTexture; 4385 } 4386 else 4387 { 4388 if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) 4389 { 4390 gl_info->fbo_ops.glIsRenderbuffer = gl_info->gl_ops.ext.p_glIsRenderbufferEXT; 4391 gl_info->fbo_ops.glBindRenderbuffer = gl_info->gl_ops.ext.p_glBindRenderbufferEXT; 4392 gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->gl_ops.ext.p_glDeleteRenderbuffersEXT; 4393 gl_info->fbo_ops.glGenRenderbuffers = gl_info->gl_ops.ext.p_glGenRenderbuffersEXT; 4394 gl_info->fbo_ops.glRenderbufferStorage = gl_info->gl_ops.ext.p_glRenderbufferStorageEXT; 4395 gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->gl_ops.ext.p_glGetRenderbufferParameterivEXT; 4396 gl_info->fbo_ops.glIsFramebuffer = gl_info->gl_ops.ext.p_glIsFramebufferEXT; 4397 gl_info->fbo_ops.glBindFramebuffer = gl_info->gl_ops.ext.p_glBindFramebufferEXT; 4398 gl_info->fbo_ops.glDeleteFramebuffers = gl_info->gl_ops.ext.p_glDeleteFramebuffersEXT; 4399 gl_info->fbo_ops.glGenFramebuffers = gl_info->gl_ops.ext.p_glGenFramebuffersEXT; 4400 gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->gl_ops.ext.p_glCheckFramebufferStatusEXT; 4401 gl_info->fbo_ops.glFramebufferTexture1D = gl_info->gl_ops.ext.p_glFramebufferTexture1DEXT; 4402 gl_info->fbo_ops.glFramebufferTexture2D = gl_info->gl_ops.ext.p_glFramebufferTexture2DEXT; 4403 gl_info->fbo_ops.glFramebufferTexture3D = gl_info->gl_ops.ext.p_glFramebufferTexture3DEXT; 4404 gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->gl_ops.ext.p_glFramebufferRenderbufferEXT; 4405 gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv 4406 = gl_info->gl_ops.ext.p_glGetFramebufferAttachmentParameterivEXT; 4407 gl_info->fbo_ops.glGenerateMipmap = gl_info->gl_ops.ext.p_glGenerateMipmapEXT; 4408 } 4409 else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) 4410 { 4411 WARN_(d3d_perf)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n"); 4412 wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER; 4413 } 4414 4415 if (gl_info->supported[ARB_GEOMETRY_SHADER4]) 4416 { 4417 gl_info->fbo_ops.glFramebufferTexture = gl_info->gl_ops.ext.p_glFramebufferTextureARB; 4418 gl_info->fbo_ops.glFramebufferTextureLayer = gl_info->gl_ops.ext.p_glFramebufferTextureLayerARB; 4419 } 4420 if (gl_info->supported[EXT_FRAMEBUFFER_BLIT]) 4421 { 4422 gl_info->fbo_ops.glBlitFramebuffer = gl_info->gl_ops.ext.p_glBlitFramebufferEXT; 4423 } 4424 if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE]) 4425 { 4426 gl_info->fbo_ops.glRenderbufferStorageMultisample 4427 = gl_info->gl_ops.ext.p_glRenderbufferStorageMultisampleEXT; 4428 } 4429 } 4430 4431 gl_info->wrap_lookup[WINED3D_TADDRESS_WRAP - WINED3D_TADDRESS_WRAP] = GL_REPEAT; 4432 gl_info->wrap_lookup[WINED3D_TADDRESS_MIRROR - WINED3D_TADDRESS_WRAP] = 4433 gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT; 4434 gl_info->wrap_lookup[WINED3D_TADDRESS_CLAMP - WINED3D_TADDRESS_WRAP] = GL_CLAMP_TO_EDGE; 4435 gl_info->wrap_lookup[WINED3D_TADDRESS_BORDER - WINED3D_TADDRESS_WRAP] = 4436 gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT; 4437 gl_info->wrap_lookup[WINED3D_TADDRESS_MIRROR_ONCE - WINED3D_TADDRESS_WRAP] = 4438 gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] ? GL_MIRROR_CLAMP_TO_EDGE : GL_REPEAT; 4439 4440 if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT]) 4441 { 4442 GLuint vao; 4443 4444 GL_EXTCALL(glGenVertexArrays(1, &vao)); 4445 GL_EXTCALL(glBindVertexArray(vao)); 4446 checkGLcall("creating VAO"); 4447 } 4448 4449 gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str, gl_version_str); 4450 TRACE("Guessed GL vendor %#x.\n", gl_vendor); 4451 4452 if (!(gpu_description = query_gpu_description(gl_info, &vram_bytes))) 4453 { 4454 enum wined3d_pci_vendor vendor; 4455 enum wined3d_pci_device device; 4456 4457 vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str); 4458 TRACE("Guessed vendor PCI ID 0x%04x.\n", vendor); 4459 4460 device = wined3d_guess_card(&shader_caps, &fragment_caps, gl_info->glsl_version, 4461 gl_renderer_str, &gl_vendor, &vendor); 4462 TRACE("Guessed device PCI ID 0x%04x.\n", device); 4463 4464 if (!(gpu_description = get_gpu_description(vendor, device))) 4465 { 4466 ERR("Card %04x:%04x not found in driver DB.\n", vendor, device); 4467 return FALSE; 4468 } 4469 } 4470 fixup_extensions(gl_info, caps_gl_ctx, gl_renderer_str, gl_vendor, 4471 gpu_description->vendor, gpu_description->card); 4472 init_driver_info(driver_info, gpu_description, vram_bytes); 4473 4474 gl_ext_emul_mask = adapter->vertex_pipe->vp_get_emul_mask(gl_info) 4475 | adapter->fragment_pipe->get_emul_mask(gl_info); 4476 if (gl_ext_emul_mask & GL_EXT_EMUL_ARB_MULTITEXTURE) 4477 install_gl_compat_wrapper(gl_info, ARB_MULTITEXTURE); 4478 if (gl_ext_emul_mask & GL_EXT_EMUL_EXT_FOG_COORD) 4479 install_gl_compat_wrapper(gl_info, EXT_FOG_COORD); 4480 4481 return TRUE; 4482 } 4483 4484 UINT CDECL wined3d_get_adapter_count(const struct wined3d *wined3d) 4485 { 4486 TRACE("wined3d %p, reporting %u adapters.\n", 4487 wined3d, wined3d->adapter_count); 4488 4489 return wined3d->adapter_count; 4490 } 4491 4492 HRESULT CDECL wined3d_register_software_device(struct wined3d *wined3d, void *init_function) 4493 { 4494 FIXME("wined3d %p, init_function %p stub!\n", wined3d, init_function); 4495 4496 return WINED3D_OK; 4497 } 4498 4499 HRESULT CDECL wined3d_get_output_desc(const struct wined3d *wined3d, unsigned int adapter_idx, 4500 struct wined3d_output_desc *desc) 4501 { 4502 enum wined3d_display_rotation rotation; 4503 const struct wined3d_adapter *adapter; 4504 struct wined3d_display_mode mode; 4505 HMONITOR monitor; 4506 HRESULT hr; 4507 4508 TRACE("wined3d %p, adapter_idx %u, desc %p.\n", wined3d, adapter_idx, desc); 4509 4510 if (adapter_idx >= wined3d->adapter_count) 4511 return WINED3DERR_INVALIDCALL; 4512 4513 adapter = &wined3d->adapters[adapter_idx]; 4514 if (!(monitor = MonitorFromPoint(adapter->monitor_position, MONITOR_DEFAULTTOPRIMARY))) 4515 return WINED3DERR_INVALIDCALL; 4516 4517 if (FAILED(hr = wined3d_get_adapter_display_mode(wined3d, adapter_idx, &mode, &rotation))) 4518 return hr; 4519 4520 memcpy(desc->device_name, adapter->DeviceName, sizeof(desc->device_name)); 4521 SetRect(&desc->desktop_rect, 0, 0, mode.width, mode.height); 4522 OffsetRect(&desc->desktop_rect, adapter->monitor_position.x, adapter->monitor_position.y); 4523 /* FIXME: We should get this from EnumDisplayDevices() when the adapters 4524 * are created. */ 4525 desc->attached_to_desktop = TRUE; 4526 desc->rotation = rotation; 4527 desc->monitor = monitor; 4528 4529 return WINED3D_OK; 4530 } 4531 4532 /* FIXME: GetAdapterModeCount and EnumAdapterModes currently only returns modes 4533 of the same bpp but different resolutions */ 4534 4535 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */ 4536 UINT CDECL wined3d_get_adapter_mode_count(const struct wined3d *wined3d, UINT adapter_idx, 4537 enum wined3d_format_id format_id, enum wined3d_scanline_ordering scanline_ordering) 4538 { 4539 const struct wined3d_adapter *adapter; 4540 const struct wined3d_format *format; 4541 unsigned int i = 0; 4542 unsigned int j = 0; 4543 UINT format_bits; 4544 DEVMODEW mode; 4545 4546 TRACE("wined3d %p, adapter_idx %u, format %s, scanline_ordering %#x.\n", 4547 wined3d, adapter_idx, debug_d3dformat(format_id), scanline_ordering); 4548 4549 if (adapter_idx >= wined3d->adapter_count) 4550 return 0; 4551 4552 adapter = &wined3d->adapters[adapter_idx]; 4553 format = wined3d_get_format(&adapter->gl_info, format_id, WINED3DUSAGE_RENDERTARGET); 4554 format_bits = format->byte_count * CHAR_BIT; 4555 4556 memset(&mode, 0, sizeof(mode)); 4557 mode.dmSize = sizeof(mode); 4558 4559 while (EnumDisplaySettingsExW(adapter->DeviceName, j++, &mode, 0)) 4560 { 4561 if (mode.dmFields & DM_DISPLAYFLAGS) 4562 { 4563 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_PROGRESSIVE 4564 && (mode.u2.dmDisplayFlags & DM_INTERLACED)) 4565 continue; 4566 4567 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_INTERLACED 4568 && !(mode.u2.dmDisplayFlags & DM_INTERLACED)) 4569 continue; 4570 } 4571 4572 if (format_id == WINED3DFMT_UNKNOWN) 4573 { 4574 /* This is for d3d8, do not enumerate P8 here. */ 4575 if (mode.dmBitsPerPel == 32 || mode.dmBitsPerPel == 16) ++i; 4576 } 4577 else if (mode.dmBitsPerPel == format_bits) 4578 { 4579 ++i; 4580 } 4581 } 4582 4583 TRACE("Returning %u matching modes (out of %u total) for adapter %u.\n", i, j, adapter_idx); 4584 4585 return i; 4586 } 4587 4588 /* Note: dx9 supplies a format. Calls from d3d8 supply WINED3DFMT_UNKNOWN */ 4589 HRESULT CDECL wined3d_enum_adapter_modes(const struct wined3d *wined3d, UINT adapter_idx, 4590 enum wined3d_format_id format_id, enum wined3d_scanline_ordering scanline_ordering, 4591 UINT mode_idx, struct wined3d_display_mode *mode) 4592 { 4593 const struct wined3d_adapter *adapter; 4594 const struct wined3d_format *format; 4595 UINT format_bits; 4596 DEVMODEW m; 4597 UINT i = 0; 4598 int j = 0; 4599 4600 TRACE("wined3d %p, adapter_idx %u, format %s, scanline_ordering %#x, mode_idx %u, mode %p.\n", 4601 wined3d, adapter_idx, debug_d3dformat(format_id), scanline_ordering, mode_idx, mode); 4602 4603 if (!mode || adapter_idx >= wined3d->adapter_count) 4604 return WINED3DERR_INVALIDCALL; 4605 4606 adapter = &wined3d->adapters[adapter_idx]; 4607 format = wined3d_get_format(&adapter->gl_info, format_id, WINED3DUSAGE_RENDERTARGET); 4608 format_bits = format->byte_count * CHAR_BIT; 4609 4610 memset(&m, 0, sizeof(m)); 4611 m.dmSize = sizeof(m); 4612 4613 while (i <= mode_idx) 4614 { 4615 if (!EnumDisplaySettingsExW(adapter->DeviceName, j++, &m, 0)) 4616 { 4617 WARN("Invalid mode_idx %u.\n", mode_idx); 4618 return WINED3DERR_INVALIDCALL; 4619 } 4620 4621 if (m.dmFields & DM_DISPLAYFLAGS) 4622 { 4623 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_PROGRESSIVE 4624 && (m.u2.dmDisplayFlags & DM_INTERLACED)) 4625 continue; 4626 4627 if (scanline_ordering == WINED3D_SCANLINE_ORDERING_INTERLACED 4628 && !(m.u2.dmDisplayFlags & DM_INTERLACED)) 4629 continue; 4630 } 4631 4632 if (format_id == WINED3DFMT_UNKNOWN) 4633 { 4634 /* This is for d3d8, do not enumerate P8 here. */ 4635 if (m.dmBitsPerPel == 32 || m.dmBitsPerPel == 16) ++i; 4636 } 4637 else if (m.dmBitsPerPel == format_bits) 4638 { 4639 ++i; 4640 } 4641 } 4642 4643 mode->width = m.dmPelsWidth; 4644 mode->height = m.dmPelsHeight; 4645 mode->refresh_rate = DEFAULT_REFRESH_RATE; 4646 if (m.dmFields & DM_DISPLAYFREQUENCY) 4647 mode->refresh_rate = m.dmDisplayFrequency; 4648 4649 if (format_id == WINED3DFMT_UNKNOWN) 4650 mode->format_id = pixelformat_for_depth(m.dmBitsPerPel); 4651 else 4652 mode->format_id = format_id; 4653 4654 if (!(m.dmFields & DM_DISPLAYFLAGS)) 4655 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN; 4656 else if (m.u2.dmDisplayFlags & DM_INTERLACED) 4657 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_INTERLACED; 4658 else 4659 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_PROGRESSIVE; 4660 4661 TRACE("%ux%u@%u %u bpp, %s %#x.\n", mode->width, mode->height, mode->refresh_rate, 4662 m.dmBitsPerPel, debug_d3dformat(mode->format_id), mode->scanline_ordering); 4663 4664 return WINED3D_OK; 4665 } 4666 4667 HRESULT CDECL wined3d_find_closest_matching_adapter_mode(const struct wined3d *wined3d, 4668 unsigned int adapter_idx, struct wined3d_display_mode *mode) 4669 { 4670 unsigned int i, j, mode_count, matching_mode_count, closest; 4671 struct wined3d_display_mode **matching_modes; 4672 struct wined3d_display_mode *modes; 4673 HRESULT hr; 4674 4675 TRACE("wined3d %p, adapter_idx %u, mode %p.\n", wined3d, adapter_idx, mode); 4676 4677 if (!(mode_count = wined3d_get_adapter_mode_count(wined3d, adapter_idx, 4678 mode->format_id, WINED3D_SCANLINE_ORDERING_UNKNOWN))) 4679 { 4680 WARN("Adapter has 0 matching modes.\n"); 4681 return E_FAIL; 4682 } 4683 4684 if (!(modes = heap_calloc(mode_count, sizeof(*modes)))) 4685 return E_OUTOFMEMORY; 4686 if (!(matching_modes = heap_calloc(mode_count, sizeof(*matching_modes)))) 4687 { 4688 heap_free(modes); 4689 return E_OUTOFMEMORY; 4690 } 4691 4692 for (i = 0; i < mode_count; ++i) 4693 { 4694 if (FAILED(hr = wined3d_enum_adapter_modes(wined3d, adapter_idx, 4695 mode->format_id, WINED3D_SCANLINE_ORDERING_UNKNOWN, i, &modes[i]))) 4696 { 4697 heap_free(matching_modes); 4698 heap_free(modes); 4699 return hr; 4700 } 4701 matching_modes[i] = &modes[i]; 4702 } 4703 4704 matching_mode_count = mode_count; 4705 4706 if (mode->scanline_ordering != WINED3D_SCANLINE_ORDERING_UNKNOWN) 4707 { 4708 for (i = 0, j = 0; i < matching_mode_count; ++i) 4709 { 4710 if (matching_modes[i]->scanline_ordering == mode->scanline_ordering) 4711 matching_modes[j++] = matching_modes[i]; 4712 } 4713 if (j > 0) 4714 matching_mode_count = j; 4715 } 4716 4717 if (mode->refresh_rate) 4718 { 4719 for (i = 0, j = 0; i < matching_mode_count; ++i) 4720 { 4721 if (matching_modes[i]->refresh_rate == mode->refresh_rate) 4722 matching_modes[j++] = matching_modes[i]; 4723 } 4724 if (j > 0) 4725 matching_mode_count = j; 4726 } 4727 4728 if (!mode->width || !mode->height) 4729 { 4730 struct wined3d_display_mode current_mode; 4731 if (FAILED(hr = wined3d_get_adapter_display_mode(wined3d, adapter_idx, 4732 ¤t_mode, NULL))) 4733 { 4734 heap_free(matching_modes); 4735 heap_free(modes); 4736 return hr; 4737 } 4738 mode->width = current_mode.width; 4739 mode->height = current_mode.height; 4740 } 4741 4742 closest = ~0u; 4743 for (i = 0, j = 0; i < matching_mode_count; ++i) 4744 { 4745 unsigned int d = abs(mode->width - matching_modes[i]->width) 4746 + abs(mode->height - matching_modes[i]->height); 4747 4748 if (closest > d) 4749 { 4750 closest = d; 4751 j = i; 4752 } 4753 } 4754 4755 *mode = *matching_modes[j]; 4756 4757 heap_free(matching_modes); 4758 heap_free(modes); 4759 4760 TRACE("Returning %ux%u@%u %s %#x.\n", mode->width, mode->height, 4761 mode->refresh_rate, debug_d3dformat(mode->format_id), 4762 mode->scanline_ordering); 4763 4764 return WINED3D_OK; 4765 } 4766 4767 HRESULT CDECL wined3d_get_adapter_display_mode(const struct wined3d *wined3d, UINT adapter_idx, 4768 struct wined3d_display_mode *mode, enum wined3d_display_rotation *rotation) 4769 { 4770 const struct wined3d_adapter *adapter; 4771 DEVMODEW m; 4772 4773 TRACE("wined3d %p, adapter_idx %u, display_mode %p, rotation %p.\n", 4774 wined3d, adapter_idx, mode, rotation); 4775 4776 if (!mode || adapter_idx >= wined3d->adapter_count) 4777 return WINED3DERR_INVALIDCALL; 4778 4779 adapter = &wined3d->adapters[adapter_idx]; 4780 4781 memset(&m, 0, sizeof(m)); 4782 m.dmSize = sizeof(m); 4783 4784 EnumDisplaySettingsExW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &m, 0); 4785 mode->width = m.dmPelsWidth; 4786 mode->height = m.dmPelsHeight; 4787 mode->refresh_rate = DEFAULT_REFRESH_RATE; 4788 if (m.dmFields & DM_DISPLAYFREQUENCY) 4789 mode->refresh_rate = m.dmDisplayFrequency; 4790 mode->format_id = pixelformat_for_depth(m.dmBitsPerPel); 4791 4792 /* Lie about the format. X11 can't change the color depth, and some apps 4793 * are pretty angry if they SetDisplayMode from 24 to 16 bpp and find out 4794 * that GetDisplayMode still returns 24 bpp. This should probably be 4795 * handled in winex11 instead. */ 4796 if (adapter->screen_format && adapter->screen_format != mode->format_id) 4797 { 4798 WARN("Overriding format %s with stored format %s.\n", 4799 debug_d3dformat(mode->format_id), 4800 debug_d3dformat(adapter->screen_format)); 4801 mode->format_id = adapter->screen_format; 4802 } 4803 4804 if (!(m.dmFields & DM_DISPLAYFLAGS)) 4805 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_UNKNOWN; 4806 else if (m.u2.dmDisplayFlags & DM_INTERLACED) 4807 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_INTERLACED; 4808 else 4809 mode->scanline_ordering = WINED3D_SCANLINE_ORDERING_PROGRESSIVE; 4810 4811 if (rotation) 4812 { 4813 switch (m.u1.s2.dmDisplayOrientation) 4814 { 4815 case DMDO_DEFAULT: 4816 *rotation = WINED3D_DISPLAY_ROTATION_0; 4817 break; 4818 case DMDO_90: 4819 *rotation = WINED3D_DISPLAY_ROTATION_90; 4820 break; 4821 case DMDO_180: 4822 *rotation = WINED3D_DISPLAY_ROTATION_180; 4823 break; 4824 case DMDO_270: 4825 *rotation = WINED3D_DISPLAY_ROTATION_270; 4826 break; 4827 default: 4828 FIXME("Unhandled display rotation %#x.\n", m.u1.s2.dmDisplayOrientation); 4829 *rotation = WINED3D_DISPLAY_ROTATION_UNSPECIFIED; 4830 break; 4831 } 4832 } 4833 4834 TRACE("Returning %ux%u@%u %s %#x.\n", mode->width, mode->height, 4835 mode->refresh_rate, debug_d3dformat(mode->format_id), 4836 mode->scanline_ordering); 4837 return WINED3D_OK; 4838 } 4839 4840 HRESULT CDECL wined3d_set_adapter_display_mode(struct wined3d *wined3d, 4841 UINT adapter_idx, const struct wined3d_display_mode *mode) 4842 { 4843 struct wined3d_adapter *adapter; 4844 DEVMODEW new_mode, current_mode; 4845 RECT clip_rc; 4846 LONG ret; 4847 enum wined3d_format_id new_format_id; 4848 4849 TRACE("wined3d %p, adapter_idx %u, mode %p.\n", wined3d, adapter_idx, mode); 4850 4851 if (adapter_idx >= wined3d->adapter_count) 4852 return WINED3DERR_INVALIDCALL; 4853 adapter = &wined3d->adapters[adapter_idx]; 4854 4855 memset(&new_mode, 0, sizeof(new_mode)); 4856 new_mode.dmSize = sizeof(new_mode); 4857 memset(¤t_mode, 0, sizeof(current_mode)); 4858 current_mode.dmSize = sizeof(current_mode); 4859 if (mode) 4860 { 4861 const struct wined3d_format *format; 4862 4863 TRACE("mode %ux%u@%u %s %#x.\n", mode->width, mode->height, mode->refresh_rate, 4864 debug_d3dformat(mode->format_id), mode->scanline_ordering); 4865 4866 format = wined3d_get_format(&adapter->gl_info, mode->format_id, WINED3DUSAGE_RENDERTARGET); 4867 4868 new_mode.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT; 4869 new_mode.dmBitsPerPel = format->byte_count * CHAR_BIT; 4870 new_mode.dmPelsWidth = mode->width; 4871 new_mode.dmPelsHeight = mode->height; 4872 4873 new_mode.dmDisplayFrequency = mode->refresh_rate; 4874 if (mode->refresh_rate) 4875 new_mode.dmFields |= DM_DISPLAYFREQUENCY; 4876 4877 if (mode->scanline_ordering != WINED3D_SCANLINE_ORDERING_UNKNOWN) 4878 { 4879 new_mode.dmFields |= DM_DISPLAYFLAGS; 4880 if (mode->scanline_ordering == WINED3D_SCANLINE_ORDERING_INTERLACED) 4881 new_mode.u2.dmDisplayFlags |= DM_INTERLACED; 4882 } 4883 new_format_id = mode->format_id; 4884 } 4885 else 4886 { 4887 if (!EnumDisplaySettingsW(adapter->DeviceName, ENUM_REGISTRY_SETTINGS, &new_mode)) 4888 { 4889 ERR("Failed to read mode from registry.\n"); 4890 return WINED3DERR_NOTAVAILABLE; 4891 } 4892 new_format_id = pixelformat_for_depth(new_mode.dmBitsPerPel); 4893 } 4894 4895 /* Only change the mode if necessary. */ 4896 if (!EnumDisplaySettingsW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, ¤t_mode)) 4897 { 4898 ERR("Failed to get current display mode.\n"); 4899 } 4900 else if (current_mode.dmPelsWidth == new_mode.dmPelsWidth 4901 && current_mode.dmPelsHeight == new_mode.dmPelsHeight 4902 && current_mode.dmBitsPerPel == new_mode.dmBitsPerPel 4903 && (current_mode.dmDisplayFrequency == new_mode.dmDisplayFrequency 4904 || !(new_mode.dmFields & DM_DISPLAYFREQUENCY)) 4905 && (current_mode.u2.dmDisplayFlags == new_mode.u2.dmDisplayFlags 4906 || !(new_mode.dmFields & DM_DISPLAYFLAGS))) 4907 { 4908 TRACE("Skipping redundant mode setting call.\n"); 4909 adapter->screen_format = new_format_id; 4910 return WINED3D_OK; 4911 } 4912 4913 ret = ChangeDisplaySettingsExW(adapter->DeviceName, &new_mode, NULL, CDS_FULLSCREEN, NULL); 4914 if (ret != DISP_CHANGE_SUCCESSFUL) 4915 { 4916 if (new_mode.dmFields & DM_DISPLAYFREQUENCY) 4917 { 4918 WARN("ChangeDisplaySettingsExW failed, trying without the refresh rate.\n"); 4919 new_mode.dmFields &= ~DM_DISPLAYFREQUENCY; 4920 new_mode.dmDisplayFrequency = 0; 4921 ret = ChangeDisplaySettingsExW(adapter->DeviceName, &new_mode, NULL, CDS_FULLSCREEN, NULL); 4922 } 4923 if (ret != DISP_CHANGE_SUCCESSFUL) 4924 return WINED3DERR_NOTAVAILABLE; 4925 } 4926 4927 /* Store the new values. */ 4928 adapter->screen_format = new_format_id; 4929 4930 /* And finally clip mouse to our screen. */ 4931 SetRect(&clip_rc, 0, 0, new_mode.dmPelsWidth, new_mode.dmPelsHeight); 4932 ClipCursor(&clip_rc); 4933 4934 return WINED3D_OK; 4935 } 4936 4937 /* NOTE: due to structure differences between dx8 and dx9 D3DADAPTER_IDENTIFIER, 4938 and fields being inserted in the middle, a new structure is used in place */ 4939 HRESULT CDECL wined3d_get_adapter_identifier(const struct wined3d *wined3d, 4940 UINT adapter_idx, DWORD flags, struct wined3d_adapter_identifier *identifier) 4941 { 4942 const struct wined3d_adapter *adapter; 4943 size_t len; 4944 4945 TRACE("wined3d %p, adapter_idx %u, flags %#x, identifier %p.\n", 4946 wined3d, adapter_idx, flags, identifier); 4947 4948 if (adapter_idx >= wined3d->adapter_count) 4949 return WINED3DERR_INVALIDCALL; 4950 4951 adapter = &wined3d->adapters[adapter_idx]; 4952 4953 if (identifier->driver_size) 4954 { 4955 const char *name = adapter->driver_info.name; 4956 len = min(strlen(name), identifier->driver_size - 1); 4957 memcpy(identifier->driver, name, len); 4958 memset(&identifier->driver[len], 0, identifier->driver_size - len); 4959 } 4960 4961 if (identifier->description_size) 4962 { 4963 const char *description = adapter->driver_info.description; 4964 len = min(strlen(description), identifier->description_size - 1); 4965 memcpy(identifier->description, description, len); 4966 memset(&identifier->description[len], 0, identifier->description_size - len); 4967 } 4968 4969 /* Note that d3d8 doesn't supply a device name. */ 4970 if (identifier->device_name_size) 4971 { 4972 if (!WideCharToMultiByte(CP_ACP, 0, adapter->DeviceName, -1, identifier->device_name, 4973 identifier->device_name_size, NULL, NULL)) 4974 { 4975 ERR("Failed to convert device name, last error %#x.\n", GetLastError()); 4976 return WINED3DERR_INVALIDCALL; 4977 } 4978 } 4979 4980 identifier->driver_version.u.HighPart = adapter->driver_info.version_high; 4981 identifier->driver_version.u.LowPart = adapter->driver_info.version_low; 4982 identifier->vendor_id = adapter->driver_info.vendor; 4983 identifier->device_id = adapter->driver_info.device; 4984 identifier->subsystem_id = 0; 4985 identifier->revision = 0; 4986 memcpy(&identifier->device_identifier, &IID_D3DDEVICE_D3DUID, sizeof(identifier->device_identifier)); 4987 identifier->whql_level = (flags & WINED3DENUM_NO_WHQL_LEVEL) ? 0 : 1; 4988 memcpy(&identifier->adapter_luid, &adapter->luid, sizeof(identifier->adapter_luid)); 4989 identifier->video_memory = min(~(SIZE_T)0, adapter->vram_bytes); 4990 4991 return WINED3D_OK; 4992 } 4993 4994 HRESULT CDECL wined3d_get_adapter_raster_status(const struct wined3d *wined3d, UINT adapter_idx, 4995 struct wined3d_raster_status *raster_status) 4996 { 4997 LONGLONG freq_per_frame, freq_per_line; 4998 LARGE_INTEGER counter, freq_per_sec; 4999 struct wined3d_display_mode mode; 5000 static UINT once; 5001 5002 if (!once++) 5003 FIXME("wined3d %p, adapter_idx %u, raster_status %p semi-stub!\n", 5004 wined3d, adapter_idx, raster_status); 5005 else 5006 WARN("wined3d %p, adapter_idx %u, raster_status %p semi-stub!\n", 5007 wined3d, adapter_idx, raster_status); 5008 5009 /* Obtaining the raster status is a widely implemented but optional 5010 * feature. When this method returns OK StarCraft 2 expects the 5011 * raster_status->InVBlank value to actually change over time. 5012 * And Endless Alice Crysis doesn't care even if this method fails. 5013 * Thus this method returns OK and fakes raster_status by 5014 * QueryPerformanceCounter. */ 5015 5016 if (!QueryPerformanceCounter(&counter) || !QueryPerformanceFrequency(&freq_per_sec)) 5017 return WINED3DERR_INVALIDCALL; 5018 if (FAILED(wined3d_get_adapter_display_mode(wined3d, adapter_idx, &mode, NULL))) 5019 return WINED3DERR_INVALIDCALL; 5020 if (mode.refresh_rate == DEFAULT_REFRESH_RATE) 5021 mode.refresh_rate = 60; 5022 5023 freq_per_frame = freq_per_sec.QuadPart / mode.refresh_rate; 5024 /* Assume 20 scan lines in the vertical blank. */ 5025 freq_per_line = freq_per_frame / (mode.height + 20); 5026 raster_status->scan_line = (counter.QuadPart % freq_per_frame) / freq_per_line; 5027 if (raster_status->scan_line < mode.height) 5028 raster_status->in_vblank = FALSE; 5029 else 5030 { 5031 raster_status->scan_line = 0; 5032 raster_status->in_vblank = TRUE; 5033 } 5034 5035 TRACE("Returning fake value, in_vblank %u, scan_line %u.\n", 5036 raster_status->in_vblank, raster_status->scan_line); 5037 5038 return WINED3D_OK; 5039 } 5040 5041 static BOOL wined3d_check_pixel_format_color(const struct wined3d_gl_info *gl_info, 5042 const struct wined3d_pixel_format *cfg, const struct wined3d_format *format) 5043 { 5044 /* Float formats need FBOs. If FBOs are used this function isn't called */ 5045 if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT) 5046 return FALSE; 5047 5048 /* Probably a RGBA_float or color index mode. */ 5049 if (cfg->iPixelType != WGL_TYPE_RGBA_ARB) 5050 return FALSE; 5051 5052 if (cfg->redSize < format->red_size 5053 || cfg->greenSize < format->green_size 5054 || cfg->blueSize < format->blue_size 5055 || cfg->alphaSize < format->alpha_size) 5056 return FALSE; 5057 5058 return TRUE; 5059 } 5060 5061 static BOOL wined3d_check_pixel_format_depth(const struct wined3d_gl_info *gl_info, 5062 const struct wined3d_pixel_format *cfg, const struct wined3d_format *format) 5063 { 5064 BOOL lockable = FALSE; 5065 5066 /* Float formats need FBOs. If FBOs are used this function isn't called */ 5067 if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT) 5068 return FALSE; 5069 5070 if ((format->id == WINED3DFMT_D16_LOCKABLE) || (format->id == WINED3DFMT_D32_FLOAT)) 5071 lockable = TRUE; 5072 5073 /* On some modern cards like the Geforce8/9, GLX doesn't offer some 5074 * depth/stencil formats which D3D9 reports. We can safely report 5075 * "compatible" formats (e.g. D24 can be used for D16) as long as we 5076 * aren't dealing with a lockable format. This also helps D3D <= 7 as they 5077 * expect D16 which isn't offered without this on Geforce8 cards. */ 5078 if (!(cfg->depthSize == format->depth_size || (!lockable && cfg->depthSize > format->depth_size))) 5079 return FALSE; 5080 5081 /* Some cards like Intel i915 ones only offer D24S8 but lots of games also 5082 * need a format without stencil. We can allow a mismatch if the format 5083 * doesn't have any stencil bits. If it does have stencil bits the size 5084 * must match, or stencil wrapping would break. */ 5085 if (format->stencil_size && cfg->stencilSize != format->stencil_size) 5086 return FALSE; 5087 5088 return TRUE; 5089 } 5090 5091 HRESULT CDECL wined3d_check_depth_stencil_match(const struct wined3d *wined3d, 5092 UINT adapter_idx, enum wined3d_device_type device_type, enum wined3d_format_id adapter_format_id, 5093 enum wined3d_format_id render_target_format_id, enum wined3d_format_id depth_stencil_format_id) 5094 { 5095 const struct wined3d_format *rt_format; 5096 const struct wined3d_format *ds_format; 5097 const struct wined3d_adapter *adapter; 5098 5099 TRACE("wined3d %p, adapter_idx %u, device_type %s,\n" 5100 "adapter_format %s, render_target_format %s, depth_stencil_format %s.\n", 5101 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(adapter_format_id), 5102 debug_d3dformat(render_target_format_id), debug_d3dformat(depth_stencil_format_id)); 5103 5104 if (adapter_idx >= wined3d->adapter_count) 5105 return WINED3DERR_INVALIDCALL; 5106 5107 adapter = &wined3d->adapters[adapter_idx]; 5108 rt_format = wined3d_get_format(&adapter->gl_info, render_target_format_id, WINED3DUSAGE_RENDERTARGET); 5109 ds_format = wined3d_get_format(&adapter->gl_info, depth_stencil_format_id, WINED3DUSAGE_DEPTHSTENCIL); 5110 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) 5111 { 5112 if ((rt_format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_RENDERTARGET) 5113 && (ds_format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL))) 5114 { 5115 TRACE("Formats match.\n"); 5116 return WINED3D_OK; 5117 } 5118 } 5119 else 5120 { 5121 const struct wined3d_pixel_format *cfgs; 5122 unsigned int cfg_count; 5123 unsigned int i; 5124 5125 cfgs = adapter->cfgs; 5126 cfg_count = adapter->cfg_count; 5127 for (i = 0; i < cfg_count; ++i) 5128 { 5129 if (wined3d_check_pixel_format_color(&adapter->gl_info, &cfgs[i], rt_format) 5130 && wined3d_check_pixel_format_depth(&adapter->gl_info, &cfgs[i], ds_format)) 5131 { 5132 TRACE("Formats match.\n"); 5133 return WINED3D_OK; 5134 } 5135 } 5136 } 5137 5138 TRACE("Unsupported format pair: %s and %s.\n", 5139 debug_d3dformat(render_target_format_id), 5140 debug_d3dformat(depth_stencil_format_id)); 5141 5142 return WINED3DERR_NOTAVAILABLE; 5143 } 5144 5145 HRESULT CDECL wined3d_check_device_multisample_type(const struct wined3d *wined3d, UINT adapter_idx, 5146 enum wined3d_device_type device_type, enum wined3d_format_id surface_format_id, BOOL windowed, 5147 enum wined3d_multisample_type multisample_type, DWORD *quality_levels) 5148 { 5149 const struct wined3d_gl_info *gl_info = &wined3d->adapters[adapter_idx].gl_info; 5150 const struct wined3d_format *format = wined3d_get_format(gl_info, surface_format_id, 0); 5151 HRESULT hr = WINED3D_OK; 5152 5153 TRACE("wined3d %p, adapter_idx %u, device_type %s, surface_format %s, " 5154 "windowed %#x, multisample_type %#x, quality_levels %p.\n", 5155 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(surface_format_id), 5156 windowed, multisample_type, quality_levels); 5157 5158 if (adapter_idx >= wined3d->adapter_count) 5159 return WINED3DERR_INVALIDCALL; 5160 if (surface_format_id == WINED3DFMT_UNKNOWN) 5161 return WINED3DERR_INVALIDCALL; 5162 if (multisample_type < WINED3D_MULTISAMPLE_NONE) 5163 return WINED3DERR_INVALIDCALL; 5164 if (multisample_type > WINED3D_MULTISAMPLE_16_SAMPLES) 5165 { 5166 FIXME("multisample_type %u not handled yet.\n", multisample_type); 5167 return WINED3DERR_NOTAVAILABLE; 5168 } 5169 5170 if (multisample_type && !(format->multisample_types & 1u << (multisample_type - 1))) 5171 hr = WINED3DERR_NOTAVAILABLE; 5172 5173 if (SUCCEEDED(hr) || (multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE && format->multisample_types)) 5174 { 5175 if (quality_levels) 5176 { 5177 if (multisample_type == WINED3D_MULTISAMPLE_NON_MASKABLE) 5178 *quality_levels = wined3d_popcount(format->multisample_types); 5179 else 5180 *quality_levels = 1; 5181 } 5182 return WINED3D_OK; 5183 } 5184 5185 TRACE("Returning not supported.\n"); 5186 return hr; 5187 } 5188 5189 /* Check if the given DisplayFormat + DepthStencilFormat combination is valid for the Adapter */ 5190 static BOOL CheckDepthStencilCapability(const struct wined3d_adapter *adapter, 5191 const struct wined3d_format *display_format, const struct wined3d_format *ds_format, 5192 enum wined3d_gl_resource_type gl_type) 5193 { 5194 /* Only allow depth/stencil formats */ 5195 if (!(ds_format->depth_size || ds_format->stencil_size)) return FALSE; 5196 5197 /* Blacklist formats not supported on Windows */ 5198 switch (ds_format->id) 5199 { 5200 case WINED3DFMT_S1_UINT_D15_UNORM: /* Breaks the shadowvol2 dx7 sdk sample */ 5201 case WINED3DFMT_S4X4_UINT_D24_UNORM: 5202 TRACE("[FAILED] - not supported on windows.\n"); 5203 return FALSE; 5204 5205 default: 5206 break; 5207 } 5208 5209 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) 5210 { 5211 /* With FBOs WGL limitations do not apply, but the format needs to be FBO attachable */ 5212 if (ds_format->flags[gl_type] & (WINED3DFMT_FLAG_DEPTH | WINED3DFMT_FLAG_STENCIL)) 5213 return TRUE; 5214 } 5215 else 5216 { 5217 unsigned int i; 5218 5219 /* Walk through all WGL pixel formats to find a match */ 5220 for (i = 0; i < adapter->cfg_count; ++i) 5221 { 5222 const struct wined3d_pixel_format *cfg = &adapter->cfgs[i]; 5223 if (wined3d_check_pixel_format_color(&adapter->gl_info, cfg, display_format) 5224 && wined3d_check_pixel_format_depth(&adapter->gl_info, cfg, ds_format)) 5225 return TRUE; 5226 } 5227 } 5228 5229 return FALSE; 5230 } 5231 5232 /* Check the render target capabilities of a format */ 5233 static BOOL CheckRenderTargetCapability(const struct wined3d_adapter *adapter, 5234 const struct wined3d_format *adapter_format, const struct wined3d_format *check_format, 5235 enum wined3d_gl_resource_type gl_type) 5236 { 5237 /* Filter out non-RT formats */ 5238 if (!(check_format->flags[gl_type] & WINED3DFMT_FLAG_RENDERTARGET)) 5239 return FALSE; 5240 if (wined3d_settings.offscreen_rendering_mode == ORM_FBO) 5241 return TRUE; 5242 if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) 5243 { 5244 const struct wined3d_pixel_format *cfgs = adapter->cfgs; 5245 unsigned int i; 5246 5247 /* In backbuffer mode the front and backbuffer share the same WGL 5248 * pixelformat. The format must match in RGB, alpha is allowed to be 5249 * different. (Only the backbuffer can have alpha.) */ 5250 if (adapter_format->red_size != check_format->red_size 5251 || adapter_format->green_size != check_format->green_size 5252 || adapter_format->blue_size != check_format->blue_size) 5253 { 5254 TRACE("[FAILED]\n"); 5255 return FALSE; 5256 } 5257 5258 /* Check if there is a WGL pixel format matching the requirements, the format should also be window 5259 * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */ 5260 for (i = 0; i < adapter->cfg_count; ++i) 5261 { 5262 if (cfgs[i].windowDrawable 5263 && wined3d_check_pixel_format_color(&adapter->gl_info, &cfgs[i], check_format)) 5264 { 5265 TRACE("Pixel format %d is compatible with format %s.\n", 5266 cfgs[i].iPixelFormat, debug_d3dformat(check_format->id)); 5267 return TRUE; 5268 } 5269 } 5270 } 5271 return FALSE; 5272 } 5273 5274 static BOOL wined3d_check_surface_capability(const struct wined3d_format *format, BOOL no3d) 5275 { 5276 if (no3d) 5277 { 5278 switch (format->id) 5279 { 5280 case WINED3DFMT_B8G8R8_UNORM: 5281 TRACE("[FAILED] - Not enumerated on Windows.\n"); 5282 return FALSE; 5283 case WINED3DFMT_B8G8R8A8_UNORM: 5284 case WINED3DFMT_B8G8R8X8_UNORM: 5285 case WINED3DFMT_B5G6R5_UNORM: 5286 case WINED3DFMT_B5G5R5X1_UNORM: 5287 case WINED3DFMT_B5G5R5A1_UNORM: 5288 case WINED3DFMT_B4G4R4A4_UNORM: 5289 case WINED3DFMT_B2G3R3_UNORM: 5290 case WINED3DFMT_A8_UNORM: 5291 case WINED3DFMT_B2G3R3A8_UNORM: 5292 case WINED3DFMT_B4G4R4X4_UNORM: 5293 case WINED3DFMT_R10G10B10A2_UNORM: 5294 case WINED3DFMT_R8G8B8A8_UNORM: 5295 case WINED3DFMT_R8G8B8X8_UNORM: 5296 case WINED3DFMT_R16G16_UNORM: 5297 case WINED3DFMT_B10G10R10A2_UNORM: 5298 case WINED3DFMT_R16G16B16A16_UNORM: 5299 case WINED3DFMT_P8_UINT: 5300 TRACE("[OK]\n"); 5301 return TRUE; 5302 default: 5303 TRACE("[FAILED] - Not available on GDI surfaces.\n"); 5304 return FALSE; 5305 } 5306 } 5307 5308 if (format->glInternal) 5309 { 5310 TRACE("[OK]\n"); 5311 return TRUE; 5312 } 5313 5314 if ((format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & (WINED3DFMT_FLAG_EXTENSION | WINED3DFMT_FLAG_TEXTURE)) 5315 == (WINED3DFMT_FLAG_EXTENSION | WINED3DFMT_FLAG_TEXTURE)) 5316 { 5317 TRACE("[OK]\n"); 5318 return TRUE; 5319 } 5320 5321 /* Reject other formats */ 5322 TRACE("[FAILED]\n"); 5323 return FALSE; 5324 } 5325 5326 /* OpenGL supports mipmapping on all formats. Wrapping is unsupported, but we 5327 * have to report mipmapping so we cannot reject WRAPANDMIP. Tests show that 5328 * Windows reports WRAPANDMIP on unfilterable surfaces as well, apparently to 5329 * show that wrapping is supported. The lack of filtering will sort out the 5330 * mipmapping capability anyway. 5331 * 5332 * For now lets report this on all formats, but in the future we may want to 5333 * restrict it to some should applications need that. */ 5334 HRESULT CDECL wined3d_check_device_format(const struct wined3d *wined3d, UINT adapter_idx, 5335 enum wined3d_device_type device_type, enum wined3d_format_id adapter_format_id, DWORD usage, 5336 enum wined3d_resource_type resource_type, enum wined3d_format_id check_format_id) 5337 { 5338 const struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx]; 5339 const struct wined3d_gl_info *gl_info = &adapter->gl_info; 5340 const struct wined3d_format *adapter_format, *format; 5341 enum wined3d_gl_resource_type gl_type, gl_type_end; 5342 BOOL mipmap_gen_supported = TRUE; 5343 DWORD format_flags = 0; 5344 DWORD allowed_usage; 5345 5346 TRACE("wined3d %p, adapter_idx %u, device_type %s, adapter_format %s, usage %s, %s, " 5347 "resource_type %s, check_format %s.\n", 5348 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(adapter_format_id), 5349 debug_d3dusage(usage), debug_d3dusagequery(usage), debug_d3dresourcetype(resource_type), 5350 debug_d3dformat(check_format_id)); 5351 5352 if (adapter_idx >= wined3d->adapter_count) 5353 return WINED3DERR_INVALIDCALL; 5354 5355 adapter_format = wined3d_get_format(gl_info, adapter_format_id, WINED3DUSAGE_RENDERTARGET); 5356 format = wined3d_get_format(gl_info, check_format_id, usage); 5357 5358 switch (resource_type) 5359 { 5360 case WINED3D_RTYPE_NONE: 5361 allowed_usage = WINED3DUSAGE_DEPTHSTENCIL 5362 | WINED3DUSAGE_RENDERTARGET; 5363 gl_type = WINED3D_GL_RES_TYPE_TEX_1D; 5364 gl_type_end = WINED3D_GL_RES_TYPE_TEX_3D; 5365 break; 5366 5367 case WINED3D_RTYPE_TEXTURE_1D: 5368 allowed_usage = WINED3DUSAGE_DYNAMIC 5369 | WINED3DUSAGE_SOFTWAREPROCESSING 5370 | WINED3DUSAGE_TEXTURE 5371 | WINED3DUSAGE_QUERY_FILTER 5372 | WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING 5373 | WINED3DUSAGE_QUERY_SRGBREAD 5374 | WINED3DUSAGE_QUERY_SRGBWRITE 5375 | WINED3DUSAGE_QUERY_VERTEXTEXTURE 5376 | WINED3DUSAGE_QUERY_WRAPANDMIP; 5377 gl_type = gl_type_end = WINED3D_GL_RES_TYPE_TEX_1D; 5378 break; 5379 5380 case WINED3D_RTYPE_TEXTURE_2D: 5381 allowed_usage = WINED3DUSAGE_DEPTHSTENCIL 5382 | WINED3DUSAGE_RENDERTARGET 5383 | WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING; 5384 if (usage & WINED3DUSAGE_RENDERTARGET) 5385 allowed_usage |= WINED3DUSAGE_QUERY_SRGBWRITE; 5386 if (!(usage & WINED3DUSAGE_TEXTURE)) 5387 { 5388 if (!wined3d_check_surface_capability(format, wined3d->flags & WINED3D_NO3D)) 5389 { 5390 TRACE("[FAILED] - Not supported for plain surfaces.\n"); 5391 return WINED3DERR_NOTAVAILABLE; 5392 } 5393 5394 gl_type = gl_type_end = WINED3D_GL_RES_TYPE_RB; 5395 break; 5396 } 5397 allowed_usage |= WINED3DUSAGE_DYNAMIC 5398 | WINED3DUSAGE_LEGACY_CUBEMAP 5399 | WINED3DUSAGE_SOFTWAREPROCESSING 5400 | WINED3DUSAGE_TEXTURE 5401 | WINED3DUSAGE_QUERY_FILTER 5402 | WINED3DUSAGE_QUERY_GENMIPMAP 5403 | WINED3DUSAGE_QUERY_LEGACYBUMPMAP 5404 | WINED3DUSAGE_QUERY_SRGBREAD 5405 | WINED3DUSAGE_QUERY_SRGBWRITE 5406 | WINED3DUSAGE_QUERY_VERTEXTEXTURE 5407 | WINED3DUSAGE_QUERY_WRAPANDMIP; 5408 gl_type = gl_type_end = WINED3D_GL_RES_TYPE_TEX_2D; 5409 if (usage & WINED3DUSAGE_LEGACY_CUBEMAP) 5410 { 5411 allowed_usage &= ~(WINED3DUSAGE_DEPTHSTENCIL | WINED3DUSAGE_QUERY_LEGACYBUMPMAP); 5412 gl_type = gl_type_end = WINED3D_GL_RES_TYPE_TEX_CUBE; 5413 } 5414 else if ((usage & WINED3DUSAGE_DEPTHSTENCIL) 5415 && (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_SHADOW) 5416 && !gl_info->supported[ARB_SHADOW]) 5417 { 5418 TRACE("[FAILED] - No shadow sampler support.\n"); 5419 return WINED3DERR_NOTAVAILABLE; 5420 } 5421 break; 5422 5423 case WINED3D_RTYPE_TEXTURE_3D: 5424 allowed_usage = WINED3DUSAGE_DYNAMIC 5425 | WINED3DUSAGE_SOFTWAREPROCESSING 5426 | WINED3DUSAGE_TEXTURE 5427 | WINED3DUSAGE_QUERY_FILTER 5428 | WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING 5429 | WINED3DUSAGE_QUERY_SRGBREAD 5430 | WINED3DUSAGE_QUERY_SRGBWRITE 5431 | WINED3DUSAGE_QUERY_VERTEXTEXTURE 5432 | WINED3DUSAGE_QUERY_WRAPANDMIP; 5433 gl_type = gl_type_end = WINED3D_GL_RES_TYPE_TEX_3D; 5434 break; 5435 5436 case WINED3D_RTYPE_BUFFER: 5437 allowed_usage = WINED3DUSAGE_DYNAMIC 5438 | WINED3DUSAGE_QUERY_VERTEXTEXTURE; 5439 gl_type = gl_type_end = WINED3D_GL_RES_TYPE_BUFFER; 5440 break; 5441 5442 default: 5443 FIXME("Unhandled resource type %s.\n", debug_d3dresourcetype(resource_type)); 5444 return WINED3DERR_NOTAVAILABLE; 5445 } 5446 5447 if ((usage & allowed_usage) != usage) 5448 { 5449 TRACE("Requested usage %#x, but resource type %s only allows %#x.\n", 5450 usage, debug_d3dresourcetype(resource_type), allowed_usage); 5451 return WINED3DERR_NOTAVAILABLE; 5452 } 5453 5454 if (usage & WINED3DUSAGE_TEXTURE) 5455 format_flags |= WINED3DFMT_FLAG_TEXTURE; 5456 if (usage & WINED3DUSAGE_QUERY_FILTER) 5457 format_flags |= WINED3DFMT_FLAG_FILTERING; 5458 if (usage & WINED3DUSAGE_QUERY_POSTPIXELSHADER_BLENDING) 5459 format_flags |= WINED3DFMT_FLAG_POSTPIXELSHADER_BLENDING; 5460 if (usage & WINED3DUSAGE_QUERY_SRGBREAD) 5461 format_flags |= WINED3DFMT_FLAG_SRGB_READ; 5462 if (usage & WINED3DUSAGE_QUERY_SRGBWRITE) 5463 format_flags |= WINED3DFMT_FLAG_SRGB_WRITE; 5464 if (usage & WINED3DUSAGE_QUERY_VERTEXTEXTURE) 5465 format_flags |= WINED3DFMT_FLAG_VTF; 5466 if (usage & WINED3DUSAGE_QUERY_LEGACYBUMPMAP) 5467 format_flags |= WINED3DFMT_FLAG_BUMPMAP; 5468 5469 if ((format_flags & WINED3DFMT_FLAG_TEXTURE) && (wined3d->flags & WINED3D_NO3D)) 5470 { 5471 TRACE("Requested texturing support, but wined3d was created with WINED3D_NO3D.\n"); 5472 return WINED3DERR_NOTAVAILABLE; 5473 } 5474 5475 for (; gl_type <= gl_type_end; ++gl_type) 5476 { 5477 if ((format->flags[gl_type] & format_flags) != format_flags) 5478 { 5479 TRACE("Requested format flags %#x, but format %s only has %#x.\n", 5480 format_flags, debug_d3dformat(check_format_id), format->flags[gl_type]); 5481 return WINED3DERR_NOTAVAILABLE; 5482 } 5483 5484 if ((usage & WINED3DUSAGE_RENDERTARGET) 5485 && !CheckRenderTargetCapability(adapter, adapter_format, format, gl_type)) 5486 { 5487 TRACE("Requested WINED3DUSAGE_RENDERTARGET, but format %s is not supported for render targets.\n", 5488 debug_d3dformat(check_format_id)); 5489 return WINED3DERR_NOTAVAILABLE; 5490 } 5491 5492 /* 3D depth / stencil textures are never supported. */ 5493 if (usage == WINED3DUSAGE_DEPTHSTENCIL && gl_type == WINED3D_GL_RES_TYPE_TEX_3D) 5494 continue; 5495 5496 if ((usage & WINED3DUSAGE_DEPTHSTENCIL) 5497 && !CheckDepthStencilCapability(adapter, adapter_format, format, gl_type)) 5498 { 5499 TRACE("Requested WINED3DUSAGE_DEPTHSTENCIL, but format %s is not supported for depth / stencil buffers.\n", 5500 debug_d3dformat(check_format_id)); 5501 return WINED3DERR_NOTAVAILABLE; 5502 } 5503 5504 if (!(format->flags[gl_type] & WINED3DFMT_FLAG_GEN_MIPMAP)) 5505 mipmap_gen_supported = FALSE; 5506 } 5507 5508 if ((usage & WINED3DUSAGE_QUERY_GENMIPMAP) && !mipmap_gen_supported) 5509 { 5510 TRACE("No WINED3DUSAGE_AUTOGENMIPMAP support, returning WINED3DOK_NOAUTOGEN.\n"); 5511 return WINED3DOK_NOMIPGEN; 5512 } 5513 5514 return WINED3D_OK; 5515 } 5516 5517 UINT CDECL wined3d_calculate_format_pitch(const struct wined3d *wined3d, UINT adapter_idx, 5518 enum wined3d_format_id format_id, UINT width) 5519 { 5520 const struct wined3d_gl_info *gl_info; 5521 unsigned int row_pitch, slice_pitch; 5522 5523 TRACE("wined3d %p, adapter_idx %u, format_id %s, width %u.\n", 5524 wined3d, adapter_idx, debug_d3dformat(format_id), width); 5525 5526 if (adapter_idx >= wined3d->adapter_count) 5527 return ~0u; 5528 5529 gl_info = &wined3d->adapters[adapter_idx].gl_info; 5530 wined3d_format_calculate_pitch(wined3d_get_format(gl_info, format_id, 0), 5531 1, width, 1, &row_pitch, &slice_pitch); 5532 5533 return row_pitch; 5534 } 5535 5536 HRESULT CDECL wined3d_check_device_format_conversion(const struct wined3d *wined3d, UINT adapter_idx, 5537 enum wined3d_device_type device_type, enum wined3d_format_id src_format, enum wined3d_format_id dst_format) 5538 { 5539 FIXME("wined3d %p, adapter_idx %u, device_type %s, src_format %s, dst_format %s stub!\n", 5540 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(src_format), 5541 debug_d3dformat(dst_format)); 5542 5543 return WINED3D_OK; 5544 } 5545 5546 HRESULT CDECL wined3d_check_device_type(const struct wined3d *wined3d, UINT adapter_idx, 5547 enum wined3d_device_type device_type, enum wined3d_format_id display_format, 5548 enum wined3d_format_id backbuffer_format, BOOL windowed) 5549 { 5550 BOOL present_conversion = wined3d->flags & WINED3D_PRESENT_CONVERSION; 5551 5552 TRACE("wined3d %p, adapter_idx %u, device_type %s, display_format %s, backbuffer_format %s, windowed %#x.\n", 5553 wined3d, adapter_idx, debug_d3ddevicetype(device_type), debug_d3dformat(display_format), 5554 debug_d3dformat(backbuffer_format), windowed); 5555 5556 if (adapter_idx >= wined3d->adapter_count) 5557 return WINED3DERR_INVALIDCALL; 5558 5559 /* The task of this function is to check whether a certain display / backbuffer format 5560 * combination is available on the given adapter. In fullscreen mode microsoft specified 5561 * that the display format shouldn't provide alpha and that ignoring alpha the backbuffer 5562 * and display format should match exactly. 5563 * In windowed mode format conversion can occur and this depends on the driver. */ 5564 5565 /* There are only 4 display formats. */ 5566 if (!(display_format == WINED3DFMT_B5G6R5_UNORM 5567 || display_format == WINED3DFMT_B5G5R5X1_UNORM 5568 || display_format == WINED3DFMT_B8G8R8X8_UNORM 5569 || display_format == WINED3DFMT_B10G10R10A2_UNORM)) 5570 { 5571 TRACE("Format %s is not supported as display format.\n", debug_d3dformat(display_format)); 5572 return WINED3DERR_NOTAVAILABLE; 5573 } 5574 5575 if (!windowed) 5576 { 5577 /* If the requested display format is not available, don't continue. */ 5578 if (!wined3d_get_adapter_mode_count(wined3d, adapter_idx, 5579 display_format, WINED3D_SCANLINE_ORDERING_UNKNOWN)) 5580 { 5581 TRACE("No available modes for display format %s.\n", debug_d3dformat(display_format)); 5582 return WINED3DERR_NOTAVAILABLE; 5583 } 5584 5585 present_conversion = FALSE; 5586 } 5587 else if (display_format == WINED3DFMT_B10G10R10A2_UNORM) 5588 { 5589 /* WINED3DFMT_B10G10R10A2_UNORM is only allowed in fullscreen mode. */ 5590 TRACE("Unsupported format combination %s / %s in windowed mode.\n", 5591 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format)); 5592 return WINED3DERR_NOTAVAILABLE; 5593 } 5594 5595 if (present_conversion) 5596 { 5597 /* Use the display format as back buffer format if the latter is 5598 * WINED3DFMT_UNKNOWN. */ 5599 if (backbuffer_format == WINED3DFMT_UNKNOWN) 5600 backbuffer_format = display_format; 5601 5602 if (FAILED(wined3d_check_device_format_conversion(wined3d, adapter_idx, 5603 device_type, backbuffer_format, display_format))) 5604 { 5605 TRACE("Format conversion from %s to %s not supported.\n", 5606 debug_d3dformat(backbuffer_format), debug_d3dformat(display_format)); 5607 return WINED3DERR_NOTAVAILABLE; 5608 } 5609 } 5610 else 5611 { 5612 /* When format conversion from the back buffer format to the display 5613 * format is not allowed, only a limited number of combinations are 5614 * valid. */ 5615 5616 if (display_format == WINED3DFMT_B5G6R5_UNORM && backbuffer_format != WINED3DFMT_B5G6R5_UNORM) 5617 { 5618 TRACE("Unsupported format combination %s / %s.\n", 5619 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format)); 5620 return WINED3DERR_NOTAVAILABLE; 5621 } 5622 5623 if (display_format == WINED3DFMT_B5G5R5X1_UNORM 5624 && !(backbuffer_format == WINED3DFMT_B5G5R5X1_UNORM || backbuffer_format == WINED3DFMT_B5G5R5A1_UNORM)) 5625 { 5626 TRACE("Unsupported format combination %s / %s.\n", 5627 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format)); 5628 return WINED3DERR_NOTAVAILABLE; 5629 } 5630 5631 if (display_format == WINED3DFMT_B8G8R8X8_UNORM 5632 && !(backbuffer_format == WINED3DFMT_B8G8R8X8_UNORM || backbuffer_format == WINED3DFMT_B8G8R8A8_UNORM)) 5633 { 5634 TRACE("Unsupported format combination %s / %s.\n", 5635 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format)); 5636 return WINED3DERR_NOTAVAILABLE; 5637 } 5638 5639 if (display_format == WINED3DFMT_B10G10R10A2_UNORM 5640 && backbuffer_format != WINED3DFMT_B10G10R10A2_UNORM) 5641 { 5642 TRACE("Unsupported format combination %s / %s.\n", 5643 debug_d3dformat(display_format), debug_d3dformat(backbuffer_format)); 5644 return WINED3DERR_NOTAVAILABLE; 5645 } 5646 } 5647 5648 /* Validate that the back buffer format is usable for render targets. */ 5649 if (FAILED(wined3d_check_device_format(wined3d, adapter_idx, device_type, display_format, 5650 WINED3DUSAGE_RENDERTARGET, WINED3D_RTYPE_TEXTURE_2D, backbuffer_format))) 5651 { 5652 TRACE("Format %s not allowed for render targets.\n", debug_d3dformat(backbuffer_format)); 5653 return WINED3DERR_NOTAVAILABLE; 5654 } 5655 5656 return WINED3D_OK; 5657 } 5658 5659 HRESULT CDECL wined3d_get_device_caps(const struct wined3d *wined3d, UINT adapter_idx, 5660 enum wined3d_device_type device_type, WINED3DCAPS *caps) 5661 { 5662 const struct wined3d_adapter *adapter = &wined3d->adapters[adapter_idx]; 5663 const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; 5664 const struct wined3d_gl_info *gl_info = &adapter->gl_info; 5665 struct wined3d_vertex_caps vertex_caps; 5666 DWORD ckey_caps, blit_caps, fx_caps; 5667 struct fragment_caps fragment_caps; 5668 struct shader_caps shader_caps; 5669 5670 TRACE("wined3d %p, adapter_idx %u, device_type %s, caps %p.\n", 5671 wined3d, adapter_idx, debug_d3ddevicetype(device_type), caps); 5672 5673 if (adapter_idx >= wined3d->adapter_count) 5674 return WINED3DERR_INVALIDCALL; 5675 5676 caps->DeviceType = (device_type == WINED3D_DEVICE_TYPE_HAL) ? WINED3D_DEVICE_TYPE_HAL : WINED3D_DEVICE_TYPE_REF; 5677 caps->AdapterOrdinal = adapter_idx; 5678 5679 caps->Caps = 0; 5680 caps->Caps2 = WINED3DCAPS2_CANRENDERWINDOWED | 5681 WINED3DCAPS2_FULLSCREENGAMMA | 5682 WINED3DCAPS2_DYNAMICTEXTURES; 5683 if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT] || gl_info->supported[EXT_FRAMEBUFFER_OBJECT]) 5684 caps->Caps2 |= WINED3DCAPS2_CANGENMIPMAP; 5685 5686 caps->Caps3 = WINED3DCAPS3_ALPHA_FULLSCREEN_FLIP_OR_DISCARD | 5687 WINED3DCAPS3_COPY_TO_VIDMEM | 5688 WINED3DCAPS3_COPY_TO_SYSTEMMEM; 5689 5690 caps->PresentationIntervals = WINED3DPRESENT_INTERVAL_IMMEDIATE | 5691 WINED3DPRESENT_INTERVAL_ONE; 5692 5693 caps->CursorCaps = WINED3DCURSORCAPS_COLOR | 5694 WINED3DCURSORCAPS_LOWRES; 5695 5696 caps->DevCaps = WINED3DDEVCAPS_FLOATTLVERTEX | 5697 WINED3DDEVCAPS_EXECUTESYSTEMMEMORY | 5698 WINED3DDEVCAPS_TLVERTEXSYSTEMMEMORY| 5699 WINED3DDEVCAPS_TLVERTEXVIDEOMEMORY | 5700 WINED3DDEVCAPS_DRAWPRIMTLVERTEX | 5701 WINED3DDEVCAPS_HWTRANSFORMANDLIGHT | 5702 WINED3DDEVCAPS_EXECUTEVIDEOMEMORY | 5703 WINED3DDEVCAPS_PUREDEVICE | 5704 WINED3DDEVCAPS_HWRASTERIZATION | 5705 WINED3DDEVCAPS_TEXTUREVIDEOMEMORY | 5706 WINED3DDEVCAPS_TEXTURESYSTEMMEMORY | 5707 WINED3DDEVCAPS_CANRENDERAFTERFLIP | 5708 WINED3DDEVCAPS_DRAWPRIMITIVES2 | 5709 WINED3DDEVCAPS_DRAWPRIMITIVES2EX; 5710 5711 caps->PrimitiveMiscCaps = WINED3DPMISCCAPS_CULLNONE | 5712 WINED3DPMISCCAPS_CULLCCW | 5713 WINED3DPMISCCAPS_CULLCW | 5714 WINED3DPMISCCAPS_COLORWRITEENABLE | 5715 WINED3DPMISCCAPS_CLIPTLVERTS | 5716 WINED3DPMISCCAPS_CLIPPLANESCALEDPOINTS | 5717 WINED3DPMISCCAPS_MASKZ | 5718 WINED3DPMISCCAPS_MRTPOSTPIXELSHADERBLENDING; 5719 /* TODO: 5720 WINED3DPMISCCAPS_NULLREFERENCE 5721 WINED3DPMISCCAPS_FOGANDSPECULARALPHA 5722 WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS 5723 WINED3DPMISCCAPS_FOGVERTEXCLAMPED */ 5724 5725 if (gl_info->supported[WINED3D_GL_BLEND_EQUATION]) 5726 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_BLENDOP; 5727 if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE]) 5728 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND; 5729 if (gl_info->supported[EXT_DRAW_BUFFERS2]) 5730 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS; 5731 if (gl_info->supported[ARB_FRAMEBUFFER_SRGB]) 5732 caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT; 5733 5734 caps->RasterCaps = WINED3DPRASTERCAPS_DITHER | 5735 WINED3DPRASTERCAPS_PAT | 5736 WINED3DPRASTERCAPS_WFOG | 5737 WINED3DPRASTERCAPS_ZFOG | 5738 WINED3DPRASTERCAPS_FOGVERTEX | 5739 WINED3DPRASTERCAPS_FOGTABLE | 5740 WINED3DPRASTERCAPS_STIPPLE | 5741 WINED3DPRASTERCAPS_SUBPIXEL | 5742 WINED3DPRASTERCAPS_ZTEST | 5743 WINED3DPRASTERCAPS_SCISSORTEST | 5744 WINED3DPRASTERCAPS_SLOPESCALEDEPTHBIAS | 5745 WINED3DPRASTERCAPS_DEPTHBIAS; 5746 5747 if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC]) 5748 { 5749 caps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY | 5750 WINED3DPRASTERCAPS_ZBIAS | 5751 WINED3DPRASTERCAPS_MIPMAPLODBIAS; 5752 } 5753 5754 caps->ZCmpCaps = WINED3DPCMPCAPS_ALWAYS | 5755 WINED3DPCMPCAPS_EQUAL | 5756 WINED3DPCMPCAPS_GREATER | 5757 WINED3DPCMPCAPS_GREATEREQUAL | 5758 WINED3DPCMPCAPS_LESS | 5759 WINED3DPCMPCAPS_LESSEQUAL | 5760 WINED3DPCMPCAPS_NEVER | 5761 WINED3DPCMPCAPS_NOTEQUAL; 5762 5763 /* WINED3DPBLENDCAPS_BOTHINVSRCALPHA and WINED3DPBLENDCAPS_BOTHSRCALPHA 5764 * are legacy settings for srcblend only. */ 5765 caps->SrcBlendCaps = WINED3DPBLENDCAPS_BOTHINVSRCALPHA | 5766 WINED3DPBLENDCAPS_BOTHSRCALPHA | 5767 WINED3DPBLENDCAPS_DESTALPHA | 5768 WINED3DPBLENDCAPS_DESTCOLOR | 5769 WINED3DPBLENDCAPS_INVDESTALPHA | 5770 WINED3DPBLENDCAPS_INVDESTCOLOR | 5771 WINED3DPBLENDCAPS_INVSRCALPHA | 5772 WINED3DPBLENDCAPS_INVSRCCOLOR | 5773 WINED3DPBLENDCAPS_ONE | 5774 WINED3DPBLENDCAPS_SRCALPHA | 5775 WINED3DPBLENDCAPS_SRCALPHASAT | 5776 WINED3DPBLENDCAPS_SRCCOLOR | 5777 WINED3DPBLENDCAPS_ZERO; 5778 5779 caps->DestBlendCaps = WINED3DPBLENDCAPS_DESTALPHA | 5780 WINED3DPBLENDCAPS_DESTCOLOR | 5781 WINED3DPBLENDCAPS_INVDESTALPHA | 5782 WINED3DPBLENDCAPS_INVDESTCOLOR | 5783 WINED3DPBLENDCAPS_INVSRCALPHA | 5784 WINED3DPBLENDCAPS_INVSRCCOLOR | 5785 WINED3DPBLENDCAPS_ONE | 5786 WINED3DPBLENDCAPS_SRCALPHA | 5787 WINED3DPBLENDCAPS_SRCCOLOR | 5788 WINED3DPBLENDCAPS_ZERO; 5789 5790 if (gl_info->supported[ARB_BLEND_FUNC_EXTENDED]) 5791 caps->DestBlendCaps |= WINED3DPBLENDCAPS_SRCALPHASAT; 5792 5793 if (gl_info->supported[EXT_BLEND_COLOR]) 5794 { 5795 caps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR; 5796 caps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR; 5797 } 5798 5799 5800 caps->AlphaCmpCaps = WINED3DPCMPCAPS_ALWAYS | 5801 WINED3DPCMPCAPS_EQUAL | 5802 WINED3DPCMPCAPS_GREATER | 5803 WINED3DPCMPCAPS_GREATEREQUAL | 5804 WINED3DPCMPCAPS_LESS | 5805 WINED3DPCMPCAPS_LESSEQUAL | 5806 WINED3DPCMPCAPS_NEVER | 5807 WINED3DPCMPCAPS_NOTEQUAL; 5808 5809 caps->ShadeCaps = WINED3DPSHADECAPS_SPECULARGOURAUDRGB | 5810 WINED3DPSHADECAPS_COLORGOURAUDRGB | 5811 WINED3DPSHADECAPS_ALPHAFLATBLEND | 5812 WINED3DPSHADECAPS_ALPHAGOURAUDBLEND | 5813 WINED3DPSHADECAPS_COLORFLATRGB | 5814 WINED3DPSHADECAPS_FOGFLAT | 5815 WINED3DPSHADECAPS_FOGGOURAUD | 5816 WINED3DPSHADECAPS_SPECULARFLATRGB; 5817 5818 caps->TextureCaps = WINED3DPTEXTURECAPS_ALPHA | 5819 WINED3DPTEXTURECAPS_ALPHAPALETTE | 5820 WINED3DPTEXTURECAPS_TRANSPARENCY | 5821 WINED3DPTEXTURECAPS_BORDER | 5822 WINED3DPTEXTURECAPS_MIPMAP | 5823 WINED3DPTEXTURECAPS_PROJECTED | 5824 WINED3DPTEXTURECAPS_PERSPECTIVE; 5825 5826 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) 5827 { 5828 caps->TextureCaps |= WINED3DPTEXTURECAPS_POW2; 5829 if (gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] || gl_info->supported[ARB_TEXTURE_RECTANGLE]) 5830 caps->TextureCaps |= WINED3DPTEXTURECAPS_NONPOW2CONDITIONAL; 5831 } 5832 5833 if (gl_info->supported[EXT_TEXTURE3D]) 5834 { 5835 caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP | 5836 WINED3DPTEXTURECAPS_MIPVOLUMEMAP; 5837 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) 5838 { 5839 caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP_POW2; 5840 } 5841 } 5842 5843 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) 5844 { 5845 caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP | 5846 WINED3DPTEXTURECAPS_MIPCUBEMAP; 5847 if (!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO]) 5848 { 5849 caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP_POW2; 5850 } 5851 } 5852 5853 caps->TextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR | 5854 WINED3DPTFILTERCAPS_MAGFPOINT | 5855 WINED3DPTFILTERCAPS_MINFLINEAR | 5856 WINED3DPTFILTERCAPS_MINFPOINT | 5857 WINED3DPTFILTERCAPS_MIPFLINEAR | 5858 WINED3DPTFILTERCAPS_MIPFPOINT | 5859 WINED3DPTFILTERCAPS_LINEAR | 5860 WINED3DPTFILTERCAPS_LINEARMIPLINEAR | 5861 WINED3DPTFILTERCAPS_LINEARMIPNEAREST | 5862 WINED3DPTFILTERCAPS_MIPLINEAR | 5863 WINED3DPTFILTERCAPS_MIPNEAREST | 5864 WINED3DPTFILTERCAPS_NEAREST; 5865 5866 if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC]) 5867 { 5868 caps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC | 5869 WINED3DPTFILTERCAPS_MINFANISOTROPIC; 5870 } 5871 5872 if (gl_info->supported[ARB_TEXTURE_CUBE_MAP]) 5873 { 5874 caps->CubeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR | 5875 WINED3DPTFILTERCAPS_MAGFPOINT | 5876 WINED3DPTFILTERCAPS_MINFLINEAR | 5877 WINED3DPTFILTERCAPS_MINFPOINT | 5878 WINED3DPTFILTERCAPS_MIPFLINEAR | 5879 WINED3DPTFILTERCAPS_MIPFPOINT | 5880 WINED3DPTFILTERCAPS_LINEAR | 5881 WINED3DPTFILTERCAPS_LINEARMIPLINEAR | 5882 WINED3DPTFILTERCAPS_LINEARMIPNEAREST | 5883 WINED3DPTFILTERCAPS_MIPLINEAR | 5884 WINED3DPTFILTERCAPS_MIPNEAREST | 5885 WINED3DPTFILTERCAPS_NEAREST; 5886 5887 if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC]) 5888 { 5889 caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC | 5890 WINED3DPTFILTERCAPS_MINFANISOTROPIC; 5891 } 5892 } 5893 else 5894 { 5895 caps->CubeTextureFilterCaps = 0; 5896 } 5897 5898 if (gl_info->supported[EXT_TEXTURE3D]) 5899 { 5900 caps->VolumeTextureFilterCaps = WINED3DPTFILTERCAPS_MAGFLINEAR | 5901 WINED3DPTFILTERCAPS_MAGFPOINT | 5902 WINED3DPTFILTERCAPS_MINFLINEAR | 5903 WINED3DPTFILTERCAPS_MINFPOINT | 5904 WINED3DPTFILTERCAPS_MIPFLINEAR | 5905 WINED3DPTFILTERCAPS_MIPFPOINT | 5906 WINED3DPTFILTERCAPS_LINEAR | 5907 WINED3DPTFILTERCAPS_LINEARMIPLINEAR | 5908 WINED3DPTFILTERCAPS_LINEARMIPNEAREST | 5909 WINED3DPTFILTERCAPS_MIPLINEAR | 5910 WINED3DPTFILTERCAPS_MIPNEAREST | 5911 WINED3DPTFILTERCAPS_NEAREST; 5912 } 5913 else 5914 { 5915 caps->VolumeTextureFilterCaps = 0; 5916 } 5917 5918 caps->TextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV | 5919 WINED3DPTADDRESSCAPS_CLAMP | 5920 WINED3DPTADDRESSCAPS_WRAP; 5921 5922 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP]) 5923 { 5924 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER; 5925 } 5926 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT]) 5927 { 5928 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR; 5929 } 5930 if (gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE]) 5931 { 5932 caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE; 5933 } 5934 5935 if (gl_info->supported[EXT_TEXTURE3D]) 5936 { 5937 caps->VolumeTextureAddressCaps = WINED3DPTADDRESSCAPS_INDEPENDENTUV | 5938 WINED3DPTADDRESSCAPS_CLAMP | 5939 WINED3DPTADDRESSCAPS_WRAP; 5940 if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP]) 5941 { 5942 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER; 5943 } 5944 if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT]) 5945 { 5946 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR; 5947 } 5948 if (gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE]) 5949 { 5950 caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE; 5951 } 5952 } 5953 else 5954 { 5955 caps->VolumeTextureAddressCaps = 0; 5956 } 5957 5958 caps->LineCaps = WINED3DLINECAPS_TEXTURE | 5959 WINED3DLINECAPS_ZTEST | 5960 WINED3DLINECAPS_BLEND | 5961 WINED3DLINECAPS_ALPHACMP | 5962 WINED3DLINECAPS_FOG; 5963 /* WINED3DLINECAPS_ANTIALIAS is not supported on Windows, and dx and gl seem to have a different 5964 * idea how generating the smoothing alpha values works; the result is different 5965 */ 5966 5967 caps->MaxTextureWidth = gl_info->limits.texture_size; 5968 caps->MaxTextureHeight = gl_info->limits.texture_size; 5969 5970 if (gl_info->supported[EXT_TEXTURE3D]) 5971 caps->MaxVolumeExtent = gl_info->limits.texture3d_size; 5972 else 5973 caps->MaxVolumeExtent = 0; 5974 5975 caps->MaxTextureRepeat = 32768; 5976 caps->MaxTextureAspectRatio = gl_info->limits.texture_size; 5977 caps->MaxVertexW = 1.0f; 5978 5979 caps->GuardBandLeft = 0.0f; 5980 caps->GuardBandTop = 0.0f; 5981 caps->GuardBandRight = 0.0f; 5982 caps->GuardBandBottom = 0.0f; 5983 5984 caps->ExtentsAdjust = 0.0f; 5985 5986 caps->StencilCaps = WINED3DSTENCILCAPS_DECRSAT | 5987 WINED3DSTENCILCAPS_INCRSAT | 5988 WINED3DSTENCILCAPS_INVERT | 5989 WINED3DSTENCILCAPS_KEEP | 5990 WINED3DSTENCILCAPS_REPLACE | 5991 WINED3DSTENCILCAPS_ZERO; 5992 if (gl_info->supported[EXT_STENCIL_WRAP]) 5993 { 5994 caps->StencilCaps |= WINED3DSTENCILCAPS_DECR | 5995 WINED3DSTENCILCAPS_INCR; 5996 } 5997 if (gl_info->supported[WINED3D_GL_VERSION_2_0] || gl_info->supported[EXT_STENCIL_TWO_SIDE] 5998 || gl_info->supported[ATI_SEPARATE_STENCIL]) 5999 { 6000 caps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED; 6001 } 6002 6003 caps->MaxAnisotropy = gl_info->limits.anisotropy; 6004 caps->MaxPointSize = gl_info->limits.pointsize_max; 6005 6006 caps->MaxPrimitiveCount = 0x555555; /* Taken from an AMD Radeon HD 5700 (Evergreen) GPU. */ 6007 caps->MaxVertexIndex = 0xffffff; /* Taken from an AMD Radeon HD 5700 (Evergreen) GPU. */ 6008 caps->MaxStreams = MAX_STREAMS; 6009 caps->MaxStreamStride = 1024; 6010 6011 /* d3d9.dll sets D3DDEVCAPS2_CAN_STRETCHRECT_FROM_TEXTURES here because StretchRects is implemented in d3d9 */ 6012 caps->DevCaps2 = WINED3DDEVCAPS2_STREAMOFFSET | 6013 WINED3DDEVCAPS2_VERTEXELEMENTSCANSHARESTREAMOFFSET; 6014 caps->MaxNpatchTessellationLevel = 0; 6015 caps->MasterAdapterOrdinal = 0; 6016 caps->AdapterOrdinalInGroup = 0; 6017 caps->NumberOfAdaptersInGroup = 1; 6018 6019 caps->NumSimultaneousRTs = gl_info->limits.buffers; 6020 6021 caps->StretchRectFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT | 6022 WINED3DPTFILTERCAPS_MAGFPOINT | 6023 WINED3DPTFILTERCAPS_MINFLINEAR | 6024 WINED3DPTFILTERCAPS_MAGFLINEAR; 6025 caps->VertexTextureFilterCaps = 0; 6026 6027 adapter->shader_backend->shader_get_caps(&adapter->gl_info, &shader_caps); 6028 adapter->fragment_pipe->get_caps(&adapter->gl_info, &fragment_caps); 6029 adapter->vertex_pipe->vp_get_caps(&adapter->gl_info, &vertex_caps); 6030 6031 /* Add shader misc caps. Only some of them belong to the shader parts of the pipeline */ 6032 caps->PrimitiveMiscCaps |= fragment_caps.PrimitiveMiscCaps; 6033 6034 caps->VertexShaderVersion = shader_caps.vs_version; 6035 caps->MaxVertexShaderConst = shader_caps.vs_uniform_count; 6036 6037 caps->PixelShaderVersion = shader_caps.ps_version; 6038 caps->PixelShader1xMaxValue = shader_caps.ps_1x_max_value; 6039 6040 caps->TextureOpCaps = fragment_caps.TextureOpCaps; 6041 caps->MaxTextureBlendStages = fragment_caps.MaxTextureBlendStages; 6042 caps->MaxSimultaneousTextures = fragment_caps.MaxSimultaneousTextures; 6043 6044 caps->MaxUserClipPlanes = vertex_caps.max_user_clip_planes; 6045 caps->MaxActiveLights = vertex_caps.max_active_lights; 6046 caps->MaxVertexBlendMatrices = vertex_caps.max_vertex_blend_matrices; 6047 if (device_type == WINED3D_DEVICE_TYPE_HAL) 6048 caps->MaxVertexBlendMatrixIndex = vertex_caps.max_vertex_blend_matrix_index; 6049 else 6050 caps->MaxVertexBlendMatrixIndex = 255; 6051 caps->VertexProcessingCaps = vertex_caps.vertex_processing_caps; 6052 caps->FVFCaps = vertex_caps.fvf_caps; 6053 caps->RasterCaps |= vertex_caps.raster_caps; 6054 6055 /* The following caps are shader specific, but they are things we cannot detect, or which 6056 * are the same among all shader models. So to avoid code duplication set the shader version 6057 * specific, but otherwise constant caps here 6058 */ 6059 if (caps->VertexShaderVersion >= 3) 6060 { 6061 /* Where possible set the caps based on OpenGL extensions and if they 6062 * aren't set (in case of software rendering) use the VS 3.0 from 6063 * MSDN or else if there's OpenGL spec use a hardcoded value minimum 6064 * VS3.0 value. */ 6065 caps->VS20Caps.caps = WINED3DVS20CAPS_PREDICATION; 6066 /* VS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */ 6067 caps->VS20Caps.dynamic_flow_control_depth = WINED3DVS20_MAX_DYNAMICFLOWCONTROLDEPTH; 6068 caps->VS20Caps.temp_count = max(32, adapter->gl_info.limits.arb_vs_temps); 6069 /* level of nesting in loops / if-statements; VS 3.0 requires MAX (4) */ 6070 caps->VS20Caps.static_flow_control_depth = WINED3DVS20_MAX_STATICFLOWCONTROLDEPTH; 6071 6072 caps->MaxVShaderInstructionsExecuted = 65535; /* VS 3.0 needs at least 65535, some cards even use 2^32-1 */ 6073 caps->MaxVertexShader30InstructionSlots = max(512, adapter->gl_info.limits.arb_vs_instructions); 6074 caps->VertexTextureFilterCaps = WINED3DPTFILTERCAPS_MINFPOINT | WINED3DPTFILTERCAPS_MAGFPOINT; 6075 } 6076 else if (caps->VertexShaderVersion == 2) 6077 { 6078 caps->VS20Caps.caps = 0; 6079 caps->VS20Caps.dynamic_flow_control_depth = WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH; 6080 caps->VS20Caps.temp_count = max(12, adapter->gl_info.limits.arb_vs_temps); 6081 caps->VS20Caps.static_flow_control_depth = 1; 6082 6083 caps->MaxVShaderInstructionsExecuted = 65535; 6084 caps->MaxVertexShader30InstructionSlots = 0; 6085 } 6086 else 6087 { /* VS 1.x */ 6088 caps->VS20Caps.caps = 0; 6089 caps->VS20Caps.dynamic_flow_control_depth = 0; 6090 caps->VS20Caps.temp_count = 0; 6091 caps->VS20Caps.static_flow_control_depth = 0; 6092 6093 caps->MaxVShaderInstructionsExecuted = 0; 6094 caps->MaxVertexShader30InstructionSlots = 0; 6095 } 6096 6097 if (caps->PixelShaderVersion >= 3) 6098 { 6099 /* Where possible set the caps based on OpenGL extensions and if they 6100 * aren't set (in case of software rendering) use the PS 3.0 from 6101 * MSDN or else if there's OpenGL spec use a hardcoded value minimum 6102 * PS 3.0 value. */ 6103 6104 /* Caps is more or less undocumented on MSDN but it appears to be 6105 * used for PS20Caps based on results from R9600/FX5900/Geforce6800 6106 * cards from Windows */ 6107 caps->PS20Caps.caps = WINED3DPS20CAPS_ARBITRARYSWIZZLE | 6108 WINED3DPS20CAPS_GRADIENTINSTRUCTIONS | 6109 WINED3DPS20CAPS_PREDICATION | 6110 WINED3DPS20CAPS_NODEPENDENTREADLIMIT | 6111 WINED3DPS20CAPS_NOTEXINSTRUCTIONLIMIT; 6112 /* PS 3.0 requires MAX_DYNAMICFLOWCONTROLDEPTH (24) */ 6113 caps->PS20Caps.dynamic_flow_control_depth = WINED3DPS20_MAX_DYNAMICFLOWCONTROLDEPTH; 6114 caps->PS20Caps.temp_count = max(32, adapter->gl_info.limits.arb_ps_temps); 6115 /* PS 3.0 requires MAX_STATICFLOWCONTROLDEPTH (4) */ 6116 caps->PS20Caps.static_flow_control_depth = WINED3DPS20_MAX_STATICFLOWCONTROLDEPTH; 6117 /* PS 3.0 requires MAX_NUMINSTRUCTIONSLOTS (512) */ 6118 caps->PS20Caps.instruction_slot_count = WINED3DPS20_MAX_NUMINSTRUCTIONSLOTS; 6119 6120 caps->MaxPShaderInstructionsExecuted = 65535; 6121 caps->MaxPixelShader30InstructionSlots = max(WINED3DMIN30SHADERINSTRUCTIONS, 6122 adapter->gl_info.limits.arb_ps_instructions); 6123 } 6124 else if(caps->PixelShaderVersion == 2) 6125 { 6126 /* Below we assume PS2.0 specs, not extended 2.0a(GeforceFX)/2.0b(Radeon R3xx) ones */ 6127 caps->PS20Caps.caps = 0; 6128 caps->PS20Caps.dynamic_flow_control_depth = 0; /* WINED3DVS20_MIN_DYNAMICFLOWCONTROLDEPTH = 0 */ 6129 caps->PS20Caps.temp_count = max(12, adapter->gl_info.limits.arb_ps_temps); 6130 caps->PS20Caps.static_flow_control_depth = WINED3DPS20_MIN_STATICFLOWCONTROLDEPTH; /* Minimum: 1 */ 6131 /* Minimum number (64 ALU + 32 Texture), a GeforceFX uses 512 */ 6132 caps->PS20Caps.instruction_slot_count = WINED3DPS20_MIN_NUMINSTRUCTIONSLOTS; 6133 6134 caps->MaxPShaderInstructionsExecuted = 512; /* Minimum value, a GeforceFX uses 1024 */ 6135 caps->MaxPixelShader30InstructionSlots = 0; 6136 } 6137 else /* PS 1.x */ 6138 { 6139 caps->PS20Caps.caps = 0; 6140 caps->PS20Caps.dynamic_flow_control_depth = 0; 6141 caps->PS20Caps.temp_count = 0; 6142 caps->PS20Caps.static_flow_control_depth = 0; 6143 caps->PS20Caps.instruction_slot_count = 0; 6144 6145 caps->MaxPShaderInstructionsExecuted = 0; 6146 caps->MaxPixelShader30InstructionSlots = 0; 6147 } 6148 6149 if (caps->VertexShaderVersion >= 2) 6150 { 6151 /* OpenGL supports all the formats below, perhaps not always 6152 * without conversion, but it supports them. 6153 * Further GLSL doesn't seem to have an official unsigned type so 6154 * don't advertise it yet as I'm not sure how we handle it. 6155 * We might need to add some clamping in the shader engine to 6156 * support it. 6157 * TODO: WINED3DDTCAPS_USHORT2N, WINED3DDTCAPS_USHORT4N, WINED3DDTCAPS_UDEC3, WINED3DDTCAPS_DEC3N */ 6158 caps->DeclTypes = WINED3DDTCAPS_UBYTE4 | 6159 WINED3DDTCAPS_UBYTE4N | 6160 WINED3DDTCAPS_SHORT2N | 6161 WINED3DDTCAPS_SHORT4N; 6162 if (gl_info->supported[ARB_HALF_FLOAT_VERTEX]) 6163 { 6164 caps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 | 6165 WINED3DDTCAPS_FLOAT16_4; 6166 } 6167 } 6168 else 6169 { 6170 caps->DeclTypes = 0; 6171 } 6172 6173 /* Set DirectDraw helper Caps */ 6174 ckey_caps = WINEDDCKEYCAPS_DESTBLT | 6175 WINEDDCKEYCAPS_SRCBLT; 6176 fx_caps = WINEDDFXCAPS_BLTALPHA | 6177 WINEDDFXCAPS_BLTMIRRORLEFTRIGHT | 6178 WINEDDFXCAPS_BLTMIRRORUPDOWN | 6179 WINEDDFXCAPS_BLTROTATION90 | 6180 WINEDDFXCAPS_BLTSHRINKX | 6181 WINEDDFXCAPS_BLTSHRINKXN | 6182 WINEDDFXCAPS_BLTSHRINKY | 6183 WINEDDFXCAPS_BLTSHRINKYN | 6184 WINEDDFXCAPS_BLTSTRETCHX | 6185 WINEDDFXCAPS_BLTSTRETCHXN | 6186 WINEDDFXCAPS_BLTSTRETCHY | 6187 WINEDDFXCAPS_BLTSTRETCHYN; 6188 blit_caps = WINEDDCAPS_BLT | 6189 WINEDDCAPS_BLTCOLORFILL | 6190 WINEDDCAPS_BLTDEPTHFILL | 6191 WINEDDCAPS_BLTSTRETCH | 6192 WINEDDCAPS_CANBLTSYSMEM | 6193 WINEDDCAPS_CANCLIP | 6194 WINEDDCAPS_CANCLIPSTRETCHED | 6195 WINEDDCAPS_COLORKEY | 6196 WINEDDCAPS_COLORKEYHWASSIST; 6197 6198 /* Fill the ddraw caps structure */ 6199 caps->ddraw_caps.caps = WINEDDCAPS_GDI | 6200 WINEDDCAPS_PALETTE | 6201 blit_caps; 6202 caps->ddraw_caps.caps2 = WINEDDCAPS2_CERTIFIED | 6203 WINEDDCAPS2_NOPAGELOCKREQUIRED | 6204 WINEDDCAPS2_PRIMARYGAMMA | 6205 WINEDDCAPS2_WIDESURFACES | 6206 WINEDDCAPS2_CANRENDERWINDOWED; 6207 caps->ddraw_caps.color_key_caps = ckey_caps; 6208 caps->ddraw_caps.fx_caps = fx_caps; 6209 caps->ddraw_caps.svb_caps = blit_caps; 6210 caps->ddraw_caps.svb_color_key_caps = ckey_caps; 6211 caps->ddraw_caps.svb_fx_caps = fx_caps; 6212 caps->ddraw_caps.vsb_caps = blit_caps; 6213 caps->ddraw_caps.vsb_color_key_caps = ckey_caps; 6214 caps->ddraw_caps.vsb_fx_caps = fx_caps; 6215 caps->ddraw_caps.ssb_caps = blit_caps; 6216 caps->ddraw_caps.ssb_color_key_caps = ckey_caps; 6217 caps->ddraw_caps.ssb_fx_caps = fx_caps; 6218 6219 caps->ddraw_caps.dds_caps = WINEDDSCAPS_ALPHA | 6220 WINEDDSCAPS_BACKBUFFER | 6221 WINEDDSCAPS_FLIP | 6222 WINEDDSCAPS_FRONTBUFFER | 6223 WINEDDSCAPS_OFFSCREENPLAIN | 6224 WINEDDSCAPS_PALETTE | 6225 WINEDDSCAPS_PRIMARYSURFACE | 6226 WINEDDSCAPS_SYSTEMMEMORY | 6227 WINEDDSCAPS_VIDEOMEMORY | 6228 WINEDDSCAPS_VISIBLE; 6229 6230 if (!(wined3d->flags & WINED3D_NO3D)) 6231 { 6232 caps->ddraw_caps.dds_caps |= WINEDDSCAPS_3DDEVICE | 6233 WINEDDSCAPS_MIPMAP | 6234 WINEDDSCAPS_TEXTURE | 6235 WINEDDSCAPS_ZBUFFER; 6236 caps->ddraw_caps.caps |= WINEDDCAPS_3D; 6237 } 6238 6239 caps->shader_double_precision = d3d_info->shader_double_precision; 6240 6241 return WINED3D_OK; 6242 } 6243 6244 HRESULT CDECL wined3d_device_create(struct wined3d *wined3d, UINT adapter_idx, enum wined3d_device_type device_type, 6245 HWND focus_window, DWORD flags, BYTE surface_alignment, struct wined3d_device_parent *device_parent, 6246 struct wined3d_device **device) 6247 { 6248 struct wined3d_device *object; 6249 HRESULT hr; 6250 6251 TRACE("wined3d %p, adapter_idx %u, device_type %#x, focus_window %p, flags %#x, surface_alignment %u, device_parent %p, device %p.\n", 6252 wined3d, adapter_idx, device_type, focus_window, flags, surface_alignment, device_parent, device); 6253 6254 /* Validate the adapter number. If no adapters are available(no GL), ignore the adapter 6255 * number and create a device without a 3D adapter for 2D only operation. */ 6256 if (wined3d->adapter_count && adapter_idx >= wined3d->adapter_count) 6257 return WINED3DERR_INVALIDCALL; 6258 6259 if (!(object = heap_alloc_zero(sizeof(*object)))) 6260 return E_OUTOFMEMORY; 6261 6262 hr = device_init(object, wined3d, adapter_idx, device_type, 6263 focus_window, flags, surface_alignment, device_parent); 6264 if (FAILED(hr)) 6265 { 6266 WARN("Failed to initialize device, hr %#x.\n", hr); 6267 heap_free(object); 6268 return hr; 6269 } 6270 6271 TRACE("Created device %p.\n", object); 6272 *device = object; 6273 6274 device_parent->ops->wined3d_device_created(device_parent, *device); 6275 6276 return WINED3D_OK; 6277 } 6278 6279 static void WINE_GLAPI invalid_func(const void *data) 6280 { 6281 ERR("Invalid vertex attribute function called.\n"); 6282 DebugBreak(); 6283 } 6284 6285 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data) 6286 { 6287 ERR("Invalid texcoord function called.\n"); 6288 DebugBreak(); 6289 } 6290 6291 static void WINE_GLAPI invalid_generic_attrib_func(GLuint idx, const void *data) 6292 { 6293 ERR("Invalid attribute function called.\n"); 6294 DebugBreak(); 6295 } 6296 6297 /* Helper functions for providing vertex data to OpenGL. The arrays are 6298 * initialised based on the extension detection and are used in 6299 * draw_primitive_immediate_mode(). */ 6300 static void WINE_GLAPI position_d3dcolor(const void *data) 6301 { 6302 DWORD pos = *((const DWORD *)data); 6303 6304 FIXME("Add a test for fixed function position from d3dcolor type.\n"); 6305 context_get_current()->gl_info->gl_ops.gl.p_glVertex4s(D3DCOLOR_B_R(pos), 6306 D3DCOLOR_B_G(pos), 6307 D3DCOLOR_B_B(pos), 6308 D3DCOLOR_B_A(pos)); 6309 } 6310 6311 static void WINE_GLAPI position_float4(const void *data) 6312 { 6313 const GLfloat *pos = data; 6314 6315 if (pos[3] != 0.0f && pos[3] != 1.0f) 6316 { 6317 float w = 1.0f / pos[3]; 6318 6319 context_get_current()->gl_info->gl_ops.gl.p_glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w); 6320 } 6321 else 6322 { 6323 context_get_current()->gl_info->gl_ops.gl.p_glVertex3fv(pos); 6324 } 6325 } 6326 6327 static void WINE_GLAPI diffuse_d3dcolor(const void *data) 6328 { 6329 DWORD diffuseColor = *((const DWORD *)data); 6330 6331 context_get_current()->gl_info->gl_ops.gl.p_glColor4ub(D3DCOLOR_B_R(diffuseColor), 6332 D3DCOLOR_B_G(diffuseColor), 6333 D3DCOLOR_B_B(diffuseColor), 6334 D3DCOLOR_B_A(diffuseColor)); 6335 } 6336 6337 static void WINE_GLAPI specular_d3dcolor(const void *data) 6338 { 6339 DWORD specularColor = *((const DWORD *)data); 6340 GLubyte d[] = 6341 { 6342 D3DCOLOR_B_R(specularColor), 6343 D3DCOLOR_B_G(specularColor), 6344 D3DCOLOR_B_B(specularColor) 6345 }; 6346 6347 context_get_current()->gl_info->gl_ops.ext.p_glSecondaryColor3ubvEXT(d); 6348 } 6349 6350 static void WINE_GLAPI warn_no_specular_func(const void *data) 6351 { 6352 WARN("GL_EXT_secondary_color not supported.\n"); 6353 } 6354 6355 static void WINE_GLAPI generic_d3dcolor(GLuint idx, const void *data) 6356 { 6357 DWORD color = *((const DWORD *)data); 6358 6359 context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4Nub(idx, 6360 D3DCOLOR_B_R(color), D3DCOLOR_B_G(color), 6361 D3DCOLOR_B_B(color), D3DCOLOR_B_A(color)); 6362 } 6363 6364 static void WINE_GLAPI generic_short2n(GLuint idx, const void *data) 6365 { 6366 const GLshort s[] = {((const GLshort *)data)[0], ((const GLshort *)data)[1], 0, 1}; 6367 6368 context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4Nsv(idx, s); 6369 } 6370 6371 static void WINE_GLAPI generic_ushort2n(GLuint idx, const void *data) 6372 { 6373 const GLushort s[] = {((const GLushort *)data)[0], ((const GLushort *)data)[1], 0, 1}; 6374 6375 context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4Nusv(idx, s); 6376 } 6377 6378 static void WINE_GLAPI generic_float16_2(GLuint idx, const void *data) 6379 { 6380 float x = float_16_to_32(((const unsigned short *)data) + 0); 6381 float y = float_16_to_32(((const unsigned short *)data) + 1); 6382 6383 context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib2f(idx, x, y); 6384 } 6385 6386 static void WINE_GLAPI generic_float16_4(GLuint idx, const void *data) 6387 { 6388 float x = float_16_to_32(((const unsigned short *)data) + 0); 6389 float y = float_16_to_32(((const unsigned short *)data) + 1); 6390 float z = float_16_to_32(((const unsigned short *)data) + 2); 6391 float w = float_16_to_32(((const unsigned short *)data) + 3); 6392 6393 context_get_current()->gl_info->gl_ops.ext.p_glVertexAttrib4f(idx, x, y, z, w); 6394 } 6395 6396 static void wined3d_adapter_init_ffp_attrib_ops(struct wined3d_adapter *adapter) 6397 { 6398 const struct wined3d_gl_info *gl_info = &adapter->gl_info; 6399 struct wined3d_d3d_info *d3d_info = &adapter->d3d_info; 6400 struct wined3d_ffp_attrib_ops *ops = &d3d_info->ffp_attrib_ops; 6401 unsigned int i; 6402 6403 for (i = 0; i < WINED3D_FFP_EMIT_COUNT; ++i) 6404 { 6405 ops->position[i] = invalid_func; 6406 ops->diffuse[i] = invalid_func; 6407 ops->specular[i] = invalid_func; 6408 ops->normal[i] = invalid_func; 6409 ops->texcoord[i] = invalid_texcoord_func; 6410 ops->generic[i] = invalid_generic_attrib_func; 6411 } 6412 6413 ops->position[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex3fv; 6414 if (!d3d_info->xyzrhw) 6415 ops->position[WINED3D_FFP_EMIT_FLOAT4] = position_float4; 6416 else 6417 ops->position[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex4fv; 6418 ops->position[WINED3D_FFP_EMIT_D3DCOLOR] = position_d3dcolor; 6419 ops->position[WINED3D_FFP_EMIT_SHORT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex2sv; 6420 6421 ops->diffuse[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor3fv; 6422 ops->diffuse[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4fv; 6423 ops->diffuse[WINED3D_FFP_EMIT_D3DCOLOR] = diffuse_d3dcolor; 6424 ops->diffuse[WINED3D_FFP_EMIT_UBYTE4N] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4ubv; 6425 ops->diffuse[WINED3D_FFP_EMIT_SHORT4N] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4sv; 6426 ops->diffuse[WINED3D_FFP_EMIT_USHORT4N] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4usv; 6427 6428 /* No 4 component entry points here. */ 6429 if (gl_info->supported[EXT_SECONDARY_COLOR]) 6430 ops->specular[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)GL_EXTCALL(glSecondaryColor3fvEXT); 6431 else 6432 ops->specular[WINED3D_FFP_EMIT_FLOAT3] = warn_no_specular_func; 6433 if (gl_info->supported[EXT_SECONDARY_COLOR]) 6434 ops->specular[WINED3D_FFP_EMIT_D3DCOLOR] = specular_d3dcolor; 6435 else 6436 ops->specular[WINED3D_FFP_EMIT_D3DCOLOR] = warn_no_specular_func; 6437 6438 /* Only 3 component entry points here. Test how others behave. Float4 6439 * normals are used by one of our tests, trying to pass it to the pixel 6440 * shader, which fails on Windows. */ 6441 ops->normal[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glNormal3fv; 6442 /* Just ignore the 4th value. */ 6443 ops->normal[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glNormal3fv; 6444 6445 ops->texcoord[WINED3D_FFP_EMIT_FLOAT1] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord1fvARB; 6446 ops->texcoord[WINED3D_FFP_EMIT_FLOAT2] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2fvARB; 6447 ops->texcoord[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord3fvARB; 6448 ops->texcoord[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4fvARB; 6449 ops->texcoord[WINED3D_FFP_EMIT_SHORT2] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2svARB; 6450 ops->texcoord[WINED3D_FFP_EMIT_SHORT4] = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4svARB; 6451 if (gl_info->supported[NV_HALF_FLOAT]) 6452 { 6453 /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT. */ 6454 ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_2] = 6455 (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2hvNV; 6456 ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_4] = 6457 (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4hvNV; 6458 } 6459 6460 ops->generic[WINED3D_FFP_EMIT_FLOAT1] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib1fv; 6461 ops->generic[WINED3D_FFP_EMIT_FLOAT2] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib2fv; 6462 ops->generic[WINED3D_FFP_EMIT_FLOAT3] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib3fv; 6463 ops->generic[WINED3D_FFP_EMIT_FLOAT4] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4fv; 6464 if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA]) 6465 ops->generic[WINED3D_FFP_EMIT_D3DCOLOR] = generic_d3dcolor; 6466 else 6467 ops->generic[WINED3D_FFP_EMIT_D3DCOLOR] = 6468 (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nubv; 6469 ops->generic[WINED3D_FFP_EMIT_UBYTE4] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4ubv; 6470 ops->generic[WINED3D_FFP_EMIT_SHORT2] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib2sv; 6471 ops->generic[WINED3D_FFP_EMIT_SHORT4] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4sv; 6472 ops->generic[WINED3D_FFP_EMIT_UBYTE4N] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nubv; 6473 ops->generic[WINED3D_FFP_EMIT_SHORT2N] = generic_short2n; 6474 ops->generic[WINED3D_FFP_EMIT_SHORT4N] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nsv; 6475 ops->generic[WINED3D_FFP_EMIT_USHORT2N] = generic_ushort2n; 6476 ops->generic[WINED3D_FFP_EMIT_USHORT4N] = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nusv; 6477 if (gl_info->supported[NV_HALF_FLOAT] && gl_info->supported[NV_VERTEX_PROGRAM]) 6478 { 6479 ops->generic[WINED3D_FFP_EMIT_FLOAT16_2] = 6480 (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib2hvNV; 6481 ops->generic[WINED3D_FFP_EMIT_FLOAT16_4] = 6482 (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4hvNV; 6483 } 6484 else 6485 { 6486 ops->generic[WINED3D_FFP_EMIT_FLOAT16_2] = generic_float16_2; 6487 ops->generic[WINED3D_FFP_EMIT_FLOAT16_4] = generic_float16_4; 6488 } 6489 } 6490 6491 static void wined3d_adapter_init_fb_cfgs(struct wined3d_adapter *adapter, HDC dc) 6492 { 6493 const struct wined3d_gl_info *gl_info = &adapter->gl_info; 6494 int i; 6495 6496 if (gl_info->supported[WGL_ARB_PIXEL_FORMAT]) 6497 { 6498 UINT attrib_count = 0; 6499 GLint cfg_count; 6500 int attribs[11]; 6501 int values[11]; 6502 int attribute; 6503 6504 attribute = WGL_NUMBER_PIXEL_FORMATS_ARB; 6505 GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, 0, 0, 1, &attribute, &cfg_count)); 6506 6507 adapter->cfgs = heap_calloc(cfg_count, sizeof(*adapter->cfgs)); 6508 attribs[attrib_count++] = WGL_RED_BITS_ARB; 6509 attribs[attrib_count++] = WGL_GREEN_BITS_ARB; 6510 attribs[attrib_count++] = WGL_BLUE_BITS_ARB; 6511 attribs[attrib_count++] = WGL_ALPHA_BITS_ARB; 6512 attribs[attrib_count++] = WGL_COLOR_BITS_ARB; 6513 attribs[attrib_count++] = WGL_DEPTH_BITS_ARB; 6514 attribs[attrib_count++] = WGL_STENCIL_BITS_ARB; 6515 attribs[attrib_count++] = WGL_DRAW_TO_WINDOW_ARB; 6516 attribs[attrib_count++] = WGL_PIXEL_TYPE_ARB; 6517 attribs[attrib_count++] = WGL_DOUBLE_BUFFER_ARB; 6518 attribs[attrib_count++] = WGL_AUX_BUFFERS_ARB; 6519 6520 for (i = 0, adapter->cfg_count = 0; i < cfg_count; ++i) 6521 { 6522 struct wined3d_pixel_format *cfg = &adapter->cfgs[adapter->cfg_count]; 6523 int format_id = i + 1; 6524 6525 if (!GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, format_id, 0, attrib_count, attribs, values))) 6526 continue; 6527 6528 cfg->iPixelFormat = format_id; 6529 cfg->redSize = values[0]; 6530 cfg->greenSize = values[1]; 6531 cfg->blueSize = values[2]; 6532 cfg->alphaSize = values[3]; 6533 cfg->colorSize = values[4]; 6534 cfg->depthSize = values[5]; 6535 cfg->stencilSize = values[6]; 6536 cfg->windowDrawable = values[7]; 6537 cfg->iPixelType = values[8]; 6538 cfg->doubleBuffer = values[9]; 6539 cfg->auxBuffers = values[10]; 6540 6541 cfg->numSamples = 0; 6542 /* Check multisample support. */ 6543 if (gl_info->supported[ARB_MULTISAMPLE]) 6544 { 6545 int attribs[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB}; 6546 int values[2]; 6547 6548 if (GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, format_id, 0, 2, attribs, values))) 6549 { 6550 /* values[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether 6551 * multisampling is supported. values[1] = number of 6552 * multisample buffers. */ 6553 if (values[0]) 6554 cfg->numSamples = values[1]; 6555 } 6556 } 6557 6558 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, " 6559 "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n", 6560 cfg->iPixelFormat, cfg->iPixelType, cfg->doubleBuffer, 6561 cfg->redSize, cfg->greenSize, cfg->blueSize, cfg->alphaSize, 6562 cfg->depthSize, cfg->stencilSize, cfg->numSamples, cfg->windowDrawable); 6563 6564 ++adapter->cfg_count; 6565 } 6566 } 6567 else 6568 { 6569 int cfg_count; 6570 6571 cfg_count = DescribePixelFormat(dc, 0, 0, 0); 6572 adapter->cfgs = heap_calloc(cfg_count, sizeof(*adapter->cfgs)); 6573 6574 for (i = 0, adapter->cfg_count = 0; i < cfg_count; ++i) 6575 { 6576 struct wined3d_pixel_format *cfg = &adapter->cfgs[adapter->cfg_count]; 6577 PIXELFORMATDESCRIPTOR pfd; 6578 int format_id = i + 1; 6579 6580 if (!DescribePixelFormat(dc, format_id, sizeof(pfd), &pfd)) 6581 continue; 6582 6583 /* We only want HW acceleration using an OpenGL ICD driver. 6584 * PFD_GENERIC_FORMAT = slow opengl 1.1 gdi software rendering. 6585 * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD 6586 * driver (e.g. 3dfx minigl). */ 6587 if (pfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED)) 6588 { 6589 TRACE("Skipping format %d because it isn't ICD accelerated.\n", format_id); 6590 continue; 6591 } 6592 6593 cfg->iPixelFormat = format_id; 6594 cfg->redSize = pfd.cRedBits; 6595 cfg->greenSize = pfd.cGreenBits; 6596 cfg->blueSize = pfd.cBlueBits; 6597 cfg->alphaSize = pfd.cAlphaBits; 6598 cfg->colorSize = pfd.cColorBits; 6599 cfg->depthSize = pfd.cDepthBits; 6600 cfg->stencilSize = pfd.cStencilBits; 6601 cfg->windowDrawable = (pfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0; 6602 cfg->iPixelType = (pfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB; 6603 cfg->doubleBuffer = (pfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0; 6604 cfg->auxBuffers = pfd.cAuxBuffers; 6605 cfg->numSamples = 0; 6606 6607 TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, " 6608 "depth=%d, stencil=%d, windowDrawable=%d\n", 6609 cfg->iPixelFormat, cfg->iPixelType, cfg->doubleBuffer, 6610 cfg->redSize, cfg->greenSize, cfg->blueSize, cfg->alphaSize, 6611 cfg->depthSize, cfg->stencilSize, cfg->windowDrawable); 6612 6613 ++adapter->cfg_count; 6614 } 6615 } 6616 } 6617 6618 static DWORD get_max_gl_version(const struct wined3d_gl_info *gl_info, DWORD flags) 6619 { 6620 const char *gl_vendor, *gl_renderer; 6621 6622 if (wined3d_settings.explicit_gl_version || (flags & WINED3D_PIXEL_CENTER_INTEGER)) 6623 return wined3d_settings.max_gl_version; 6624 6625 gl_vendor = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VENDOR); 6626 gl_renderer = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_RENDERER); 6627 if (!gl_vendor || !gl_renderer 6628 || wined3d_guess_card_vendor(gl_vendor, gl_renderer) == HW_VENDOR_NVIDIA) 6629 return wined3d_settings.max_gl_version; 6630 6631 return MAKEDWORD_VERSION(4, 4); 6632 } 6633 6634 static BOOL has_extension(const char *list, const char *ext) 6635 { 6636 size_t len = strlen(ext); 6637 while (list) 6638 { 6639 while (*list == ' ') list++; 6640 if (!strncmp(list, ext, len) && (!list[len] || list[len] == ' ')) return TRUE; 6641 list = strchr(list, ' '); 6642 } 6643 return FALSE; 6644 } 6645 6646 static BOOL wined3d_adapter_init(struct wined3d_adapter *adapter, UINT ordinal, DWORD wined3d_creation_flags) 6647 { 6648 static const DWORD supported_gl_versions[] = 6649 { 6650 MAKEDWORD_VERSION(4, 4), 6651 MAKEDWORD_VERSION(3, 2), 6652 MAKEDWORD_VERSION(1, 0), 6653 }; 6654 struct wined3d_gl_info *gl_info = &adapter->gl_info; 6655 struct wined3d_caps_gl_ctx caps_gl_ctx = {0}; 6656 unsigned int i; 6657 DISPLAY_DEVICEW display_device; 6658 DWORD max_gl_version; 6659 6660 TRACE("adapter %p, ordinal %u.\n", adapter, ordinal); 6661 6662 adapter->ordinal = ordinal; 6663 6664 /* Dynamically load all GL core functions */ 6665 #ifdef USE_WIN32_OPENGL 6666 { 6667 HMODULE mod_gl = GetModuleHandleA("opengl32.dll"); 6668 #define USE_GL_FUNC(f) gl_info->gl_ops.gl.p_##f = (void *)GetProcAddress(mod_gl, #f); 6669 ALL_WGL_FUNCS 6670 #undef USE_GL_FUNC 6671 gl_info->gl_ops.wgl.p_wglSwapBuffers = (void *)GetProcAddress(mod_gl, "wglSwapBuffers"); 6672 gl_info->gl_ops.wgl.p_wglGetPixelFormat = (void *)GetProcAddress(mod_gl, "wglGetPixelFormat"); 6673 } 6674 #else 6675 /* To bypass the opengl32 thunks retrieve functions from the WGL driver instead of opengl32 */ 6676 { 6677 HDC hdc = GetDC( 0 ); 6678 const struct opengl_funcs *wgl_driver = __wine_get_wgl_driver( hdc, WINE_WGL_DRIVER_VERSION ); 6679 ReleaseDC( 0, hdc ); 6680 if (!wgl_driver || wgl_driver == (void *)-1) return FALSE; 6681 gl_info->gl_ops.wgl = wgl_driver->wgl; 6682 gl_info->gl_ops.gl = wgl_driver->gl; 6683 } 6684 #endif 6685 6686 glEnableWINE = gl_info->gl_ops.gl.p_glEnable; 6687 glDisableWINE = gl_info->gl_ops.gl.p_glDisable; 6688 6689 if (!AllocateLocallyUniqueId(&adapter->luid)) 6690 { 6691 ERR("Failed to set adapter LUID (%#x).\n", GetLastError()); 6692 return FALSE; 6693 } 6694 TRACE("Allocated LUID %08x:%08x for adapter %p.\n", 6695 adapter->luid.HighPart, adapter->luid.LowPart, adapter); 6696 6697 if (!wined3d_caps_gl_ctx_create(adapter, &caps_gl_ctx)) 6698 { 6699 ERR("Failed to get a GL context for adapter %p.\n", adapter); 6700 return FALSE; 6701 } 6702 6703 max_gl_version = get_max_gl_version(gl_info, wined3d_creation_flags); 6704 6705 if (wined3d_creation_flags & WINED3D_REQUEST_D3D10) 6706 { 6707 const char *gl_extensions = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_EXTENSIONS); 6708 if (!has_extension(gl_extensions, "GL_ARB_compatibility")) 6709 { 6710 ERR_(winediag)("GL_ARB_compatibility not supported, requesting context with GL version 3.2.\n"); 6711 max_gl_version = MAKEDWORD_VERSION(3, 2); 6712 } 6713 } 6714 6715 for (i = 0; i < ARRAY_SIZE(supported_gl_versions); ++i) 6716 { 6717 if (supported_gl_versions[i] <= max_gl_version) 6718 break; 6719 } 6720 if (i == ARRAY_SIZE(supported_gl_versions)) 6721 { 6722 ERR_(winediag)("Requested invalid GL version %u.%u.\n", 6723 max_gl_version >> 16, max_gl_version & 0xffff); 6724 i = ARRAY_SIZE(supported_gl_versions) - 1; 6725 } 6726 6727 for (; i < ARRAY_SIZE(supported_gl_versions); ++i) 6728 { 6729 gl_info->selected_gl_version = supported_gl_versions[i]; 6730 6731 if (wined3d_caps_gl_ctx_create_attribs(&caps_gl_ctx, gl_info)) 6732 break; 6733 6734 WARN("Couldn't create an OpenGL %u.%u context, trying fallback to a lower version.\n", 6735 supported_gl_versions[i] >> 16, supported_gl_versions[i] & 0xffff); 6736 } 6737 6738 if (!wined3d_adapter_init_gl_caps(adapter, &caps_gl_ctx, wined3d_creation_flags)) 6739 { 6740 ERR("Failed to initialize GL caps for adapter %p.\n", adapter); 6741 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx); 6742 return FALSE; 6743 } 6744 6745 if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER) 6746 ERR_(winediag)("You are using the backbuffer for offscreen rendering. " 6747 "This is unsupported, and will be removed in a future version.\n"); 6748 6749 wined3d_adapter_init_fb_cfgs(adapter, caps_gl_ctx.dc); 6750 /* We haven't found any suitable formats. This should only happen in 6751 * case of GDI software rendering, which is pretty useless anyway. */ 6752 if (!adapter->cfg_count) 6753 { 6754 WARN("No suitable pixel formats found.\n"); 6755 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx); 6756 heap_free(adapter->cfgs); 6757 return FALSE; 6758 } 6759 6760 if (!wined3d_adapter_init_format_info(adapter, &caps_gl_ctx)) 6761 { 6762 ERR("Failed to initialize GL format info.\n"); 6763 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx); 6764 heap_free(adapter->cfgs); 6765 return FALSE; 6766 } 6767 6768 adapter->vram_bytes = adapter->driver_info.vram_bytes; 6769 adapter->vram_bytes_used = 0; 6770 TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(adapter->vram_bytes)); 6771 6772 display_device.cb = sizeof(display_device); 6773 EnumDisplayDevicesW(NULL, ordinal, &display_device, 0); 6774 TRACE("DeviceName: %s\n", debugstr_w(display_device.DeviceName)); 6775 strcpyW(adapter->DeviceName, display_device.DeviceName); 6776 6777 wined3d_caps_gl_ctx_destroy(&caps_gl_ctx); 6778 6779 wined3d_adapter_init_ffp_attrib_ops(adapter); 6780 6781 return TRUE; 6782 } 6783 6784 static BOOL wined3d_adapter_init_nogl(struct wined3d_adapter *adapter, UINT ordinal) 6785 { 6786 DISPLAY_DEVICEW display_device; 6787 6788 memset(adapter, 0, sizeof(*adapter)); 6789 adapter->ordinal = ordinal; 6790 6791 adapter->driver_info.name = "Display"; 6792 adapter->driver_info.description = "WineD3D DirectDraw Emulation"; 6793 if (wined3d_settings.emulated_textureram) 6794 adapter->vram_bytes = wined3d_settings.emulated_textureram; 6795 else 6796 adapter->vram_bytes = 128 * 1024 * 1024; 6797 6798 if (!wined3d_adapter_init_format_info(adapter, NULL)) 6799 return FALSE; 6800 6801 adapter->vertex_pipe = &none_vertex_pipe; 6802 adapter->fragment_pipe = &none_fragment_pipe; 6803 adapter->shader_backend = &none_shader_backend; 6804 6805 display_device.cb = sizeof(display_device); 6806 EnumDisplayDevicesW(NULL, ordinal, &display_device, 0); 6807 TRACE("DeviceName: %s\n", debugstr_w(display_device.DeviceName)); 6808 strcpyW(adapter->DeviceName, display_device.DeviceName); 6809 6810 return TRUE; 6811 } 6812 6813 static void STDMETHODCALLTYPE wined3d_null_wined3d_object_destroyed(void *parent) {} 6814 6815 const struct wined3d_parent_ops wined3d_null_parent_ops = 6816 { 6817 wined3d_null_wined3d_object_destroyed, 6818 }; 6819 6820 HRESULT wined3d_init(struct wined3d *wined3d, DWORD flags) 6821 { 6822 BOOL ret; 6823 6824 wined3d->ref = 1; 6825 wined3d->flags = flags; 6826 6827 TRACE("Initializing adapters.\n"); 6828 6829 if (flags & WINED3D_NO3D) 6830 ret = wined3d_adapter_init_nogl(&wined3d->adapters[0], 0); 6831 else 6832 ret = wined3d_adapter_init(&wined3d->adapters[0], 0, flags); 6833 if (!ret) 6834 { 6835 WARN("Failed to initialize adapter.\n"); 6836 return E_FAIL; 6837 } 6838 wined3d->adapter_count = 1; 6839 6840 return WINED3D_OK; 6841 } 6842