dlls/wined3d/adapter_gl.c

   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, 2018 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
  31 WINE_DEFAULT_DEBUG_CHANNEL(d3d);
  32 WINE_DECLARE_DEBUG_CHANNEL(d3d_perf);
  33 WINE_DECLARE_DEBUG_CHANNEL(winediag);
  34
  35 enum wined3d_gl_vendor
  36 {
  37     GL_VENDOR_UNKNOWN,
  38     GL_VENDOR_APPLE,
  39     GL_VENDOR_FGLRX,
  40     GL_VENDOR_MESA,
  41     GL_VENDOR_NVIDIA,
  42 };
  43
  44 struct wined3d_extension_map
  45 {
  46     const char *extension_string;
  47     enum wined3d_gl_extension extension;
  48 };
  49
  50 static const struct wined3d_extension_map gl_extension_map[] =
  51 {
  52     /* APPLE */
  53     {"GL_APPLE_fence",                      APPLE_FENCE                   },
  54     {"GL_APPLE_float_pixels",               APPLE_FLOAT_PIXELS            },
  55     {"GL_APPLE_flush_buffer_range",         APPLE_FLUSH_BUFFER_RANGE      },
  56     {"GL_APPLE_flush_render",               APPLE_FLUSH_RENDER            },
  57     {"GL_APPLE_rgb_422",                    APPLE_RGB_422                 },
  58     {"GL_APPLE_ycbcr_422",                  APPLE_YCBCR_422               },
  59
  60     /* ARB */
  61     {"GL_ARB_base_instance",                ARB_BASE_INSTANCE             },
  62     {"GL_ARB_blend_func_extended",          ARB_BLEND_FUNC_EXTENDED       },
  63     {"GL_ARB_buffer_storage",               ARB_BUFFER_STORAGE            },
  64     {"GL_ARB_clear_buffer_object",          ARB_CLEAR_BUFFER_OBJECT       },
  65     {"GL_ARB_clear_texture",                ARB_CLEAR_TEXTURE             },
  66     {"GL_ARB_clip_control",                 ARB_CLIP_CONTROL              },
  67     {"GL_ARB_color_buffer_float",           ARB_COLOR_BUFFER_FLOAT        },
  68     {"GL_ARB_compute_shader",               ARB_COMPUTE_SHADER            },
  69     {"GL_ARB_conservative_depth",           ARB_CONSERVATIVE_DEPTH        },
  70     {"GL_ARB_copy_buffer",                  ARB_COPY_BUFFER               },
  71     {"GL_ARB_copy_image",                   ARB_COPY_IMAGE                },
  72     {"GL_ARB_cull_distance",                ARB_CULL_DISTANCE             },
  73     {"GL_ARB_debug_output",                 ARB_DEBUG_OUTPUT              },
  74     {"GL_ARB_depth_buffer_float",           ARB_DEPTH_BUFFER_FLOAT        },
  75     {"GL_ARB_depth_clamp",                  ARB_DEPTH_CLAMP               },
  76     {"GL_ARB_depth_texture",                ARB_DEPTH_TEXTURE             },
  77     {"GL_ARB_derivative_control",           ARB_DERIVATIVE_CONTROL        },
  78     {"GL_ARB_draw_buffers",                 ARB_DRAW_BUFFERS              },
  79     {"GL_ARB_draw_buffers_blend",           ARB_DRAW_BUFFERS_BLEND        },
  80     {"GL_ARB_draw_elements_base_vertex",    ARB_DRAW_ELEMENTS_BASE_VERTEX },
  81     {"GL_ARB_draw_indirect",                ARB_DRAW_INDIRECT             },
  82     {"GL_ARB_draw_instanced",               ARB_DRAW_INSTANCED            },
  83     {"GL_ARB_ES2_compatibility",            ARB_ES2_COMPATIBILITY         },
  84     {"GL_ARB_ES3_compatibility",            ARB_ES3_COMPATIBILITY         },
  85     {"GL_ARB_explicit_attrib_location",     ARB_EXPLICIT_ATTRIB_LOCATION  },
  86     {"GL_ARB_fragment_coord_conventions",   ARB_FRAGMENT_COORD_CONVENTIONS},
  87     {"GL_ARB_fragment_layer_viewport",      ARB_FRAGMENT_LAYER_VIEWPORT   },
  88     {"GL_ARB_fragment_program",             ARB_FRAGMENT_PROGRAM          },
  89     {"GL_ARB_fragment_shader",              ARB_FRAGMENT_SHADER           },
  90     {"GL_ARB_framebuffer_no_attachments",   ARB_FRAMEBUFFER_NO_ATTACHMENTS},
  91     {"GL_ARB_framebuffer_object",           ARB_FRAMEBUFFER_OBJECT        },
  92     {"GL_ARB_framebuffer_sRGB",             ARB_FRAMEBUFFER_SRGB          },
  93     {"GL_ARB_geometry_shader4",             ARB_GEOMETRY_SHADER4          },
  94     {"GL_ARB_gpu_shader5",                  ARB_GPU_SHADER5               },
  95     {"GL_ARB_half_float_pixel",             ARB_HALF_FLOAT_PIXEL          },
  96     {"GL_ARB_half_float_vertex",            ARB_HALF_FLOAT_VERTEX         },
  97     {"GL_ARB_instanced_arrays",             ARB_INSTANCED_ARRAYS          },
  98     {"GL_ARB_internalformat_query",         ARB_INTERNALFORMAT_QUERY      },
  99     {"GL_ARB_internalformat_query2",        ARB_INTERNALFORMAT_QUERY2     },
 100     {"GL_ARB_map_buffer_alignment",         ARB_MAP_BUFFER_ALIGNMENT      },
 101     {"GL_ARB_map_buffer_range",             ARB_MAP_BUFFER_RANGE          },
 102     {"GL_ARB_multisample",                  ARB_MULTISAMPLE               },
 103     {"GL_ARB_multitexture",                 ARB_MULTITEXTURE              },
 104     {"GL_ARB_occlusion_query",              ARB_OCCLUSION_QUERY           },
 105     {"GL_ARB_pipeline_statistics_query",    ARB_PIPELINE_STATISTICS_QUERY },
 106     {"GL_ARB_pixel_buffer_object",          ARB_PIXEL_BUFFER_OBJECT       },
 107     {"GL_ARB_point_parameters",             ARB_POINT_PARAMETERS          },
 108     {"GL_ARB_point_sprite",                 ARB_POINT_SPRITE              },
 109     {"GL_ARB_polygon_offset_clamp",         ARB_POLYGON_OFFSET_CLAMP      },
 110     {"GL_ARB_provoking_vertex",             ARB_PROVOKING_VERTEX          },
 111     {"GL_ARB_query_buffer_object",          ARB_QUERY_BUFFER_OBJECT       },
 112     {"GL_ARB_sample_shading",               ARB_SAMPLE_SHADING            },
 113     {"GL_ARB_sampler_objects",              ARB_SAMPLER_OBJECTS           },
 114     {"GL_ARB_seamless_cube_map",            ARB_SEAMLESS_CUBE_MAP         },
 115     {"GL_ARB_shader_atomic_counters",       ARB_SHADER_ATOMIC_COUNTERS    },
 116     {"GL_ARB_shader_bit_encoding",          ARB_SHADER_BIT_ENCODING       },
 117     {"GL_ARB_shader_image_load_store",      ARB_SHADER_IMAGE_LOAD_STORE   },
 118     {"GL_ARB_shader_image_size",            ARB_SHADER_IMAGE_SIZE         },
 119     {"GL_ARB_shader_storage_buffer_object", ARB_SHADER_STORAGE_BUFFER_OBJECT},
 120     {"GL_ARB_shader_texture_image_samples", ARB_SHADER_TEXTURE_IMAGE_SAMPLES},
 121     {"GL_ARB_shader_texture_lod",           ARB_SHADER_TEXTURE_LOD        },
 122     {"GL_ARB_shader_viewport_layer_array",  ARB_SHADER_VIEWPORT_LAYER_ARRAY},
 123     {"GL_ARB_shading_language_100",         ARB_SHADING_LANGUAGE_100      },
 124     {"GL_ARB_shading_language_420pack",     ARB_SHADING_LANGUAGE_420PACK  },
 125     {"GL_ARB_shading_language_packing",     ARB_SHADING_LANGUAGE_PACKING  },
 126     {"GL_ARB_shadow",                       ARB_SHADOW                    },
 127     {"GL_ARB_stencil_texturing",            ARB_STENCIL_TEXTURING         },
 128     {"GL_ARB_sync",                         ARB_SYNC                      },
 129     {"GL_ARB_tessellation_shader",          ARB_TESSELLATION_SHADER       },
 130     {"GL_ARB_texture_border_clamp",         ARB_TEXTURE_BORDER_CLAMP      },
 131     {"GL_ARB_texture_buffer_object",        ARB_TEXTURE_BUFFER_OBJECT     },
 132     {"GL_ARB_texture_buffer_range",         ARB_TEXTURE_BUFFER_RANGE      },
 133     {"GL_ARB_texture_compression",          ARB_TEXTURE_COMPRESSION       },
 134     {"GL_ARB_texture_compression_bptc",     ARB_TEXTURE_COMPRESSION_BPTC  },
 135     {"GL_ARB_texture_compression_rgtc",     ARB_TEXTURE_COMPRESSION_RGTC  },
 136     {"GL_ARB_texture_cube_map",             ARB_TEXTURE_CUBE_MAP          },
 137     {"GL_ARB_texture_cube_map_array",       ARB_TEXTURE_CUBE_MAP_ARRAY    },
 138     {"GL_ARB_texture_env_combine",          ARB_TEXTURE_ENV_COMBINE       },
 139     {"GL_ARB_texture_env_dot3",             ARB_TEXTURE_ENV_DOT3          },
 140     {"GL_ARB_texture_filter_anisotropic",   ARB_TEXTURE_FILTER_ANISOTROPIC},
 141     {"GL_ARB_texture_float",                ARB_TEXTURE_FLOAT             },
 142     {"GL_ARB_texture_gather",               ARB_TEXTURE_GATHER            },
 143     {"GL_ARB_texture_mirrored_repeat",      ARB_TEXTURE_MIRRORED_REPEAT   },
 144     {"GL_ARB_texture_mirror_clamp_to_edge", ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE},
 145     {"GL_ARB_texture_multisample",          ARB_TEXTURE_MULTISAMPLE       },
 146     {"GL_ARB_texture_non_power_of_two",     ARB_TEXTURE_NON_POWER_OF_TWO  },
 147     {"GL_ARB_texture_query_levels",         ARB_TEXTURE_QUERY_LEVELS      },
 148     {"GL_ARB_texture_rectangle",            ARB_TEXTURE_RECTANGLE         },
 149     {"GL_ARB_texture_rg",                   ARB_TEXTURE_RG                },
 150     {"GL_ARB_texture_rgb10_a2ui",           ARB_TEXTURE_RGB10_A2UI        },
 151     {"GL_ARB_texture_storage",              ARB_TEXTURE_STORAGE           },
 152     {"GL_ARB_texture_storage_multisample",  ARB_TEXTURE_STORAGE_MULTISAMPLE},
 153     {"GL_ARB_texture_swizzle",              ARB_TEXTURE_SWIZZLE           },
 154     {"GL_ARB_texture_view",                 ARB_TEXTURE_VIEW              },
 155     {"GL_ARB_timer_query",                  ARB_TIMER_QUERY               },
 156     {"GL_ARB_transform_feedback2",          ARB_TRANSFORM_FEEDBACK2       },
 157     {"GL_ARB_transform_feedback3",          ARB_TRANSFORM_FEEDBACK3       },
 158     {"GL_ARB_uniform_buffer_object",        ARB_UNIFORM_BUFFER_OBJECT     },
 159     {"GL_ARB_vertex_array_bgra",            ARB_VERTEX_ARRAY_BGRA         },
 160     {"GL_ARB_vertex_buffer_object",         ARB_VERTEX_BUFFER_OBJECT      },
 161     {"GL_ARB_vertex_program",               ARB_VERTEX_PROGRAM            },
 162     {"GL_ARB_vertex_shader",                ARB_VERTEX_SHADER             },
 163     {"GL_ARB_vertex_type_2_10_10_10_rev",   ARB_VERTEX_TYPE_2_10_10_10_REV},
 164     {"GL_ARB_viewport_array",               ARB_VIEWPORT_ARRAY            },
 165     {"GL_ARB_texture_barrier",              ARB_TEXTURE_BARRIER           },
 166
 167     /* ATI */
 168     {"GL_ATI_fragment_shader",              ATI_FRAGMENT_SHADER           },
 169     {"GL_ATI_separate_stencil",             ATI_SEPARATE_STENCIL          },
 170     {"GL_ATI_texture_compression_3dc",      ATI_TEXTURE_COMPRESSION_3DC   },
 171     {"GL_ATI_texture_env_combine3",         ATI_TEXTURE_ENV_COMBINE3      },
 172     {"GL_ATI_texture_mirror_once",          ATI_TEXTURE_MIRROR_ONCE       },
 173
 174     /* EXT */
 175     {"GL_EXT_blend_color",                  EXT_BLEND_COLOR               },
 176     {"GL_EXT_blend_equation_separate",      EXT_BLEND_EQUATION_SEPARATE   },
 177     {"GL_EXT_blend_func_separate",          EXT_BLEND_FUNC_SEPARATE       },
 178     {"GL_EXT_blend_minmax",                 EXT_BLEND_MINMAX              },
 179     {"GL_EXT_blend_subtract",               EXT_BLEND_SUBTRACT            },
 180     {"GL_EXT_depth_bounds_test",            EXT_DEPTH_BOUNDS_TEST         },
 181     {"GL_EXT_draw_buffers2",                EXT_DRAW_BUFFERS2             },
 182     {"GL_EXT_fog_coord",                    EXT_FOG_COORD                 },
 183     {"GL_EXT_framebuffer_blit",             EXT_FRAMEBUFFER_BLIT          },
 184     {"GL_EXT_framebuffer_multisample",      EXT_FRAMEBUFFER_MULTISAMPLE   },
 185     {"GL_EXT_framebuffer_multisample_blit_scaled",
 186                                    EXT_FRAMEBUFFER_MULTISAMPLE_BLIT_SCALED},
 187     {"GL_EXT_framebuffer_object",           EXT_FRAMEBUFFER_OBJECT        },
 188     {"GL_EXT_memory_object",                EXT_MEMORY_OBJECT             },
 189     {"GL_EXT_gpu_program_parameters",       EXT_GPU_PROGRAM_PARAMETERS    },
 190     {"GL_EXT_gpu_shader4",                  EXT_GPU_SHADER4               },
 191     {"GL_EXT_packed_depth_stencil",         EXT_PACKED_DEPTH_STENCIL      },
 192     {"GL_EXT_packed_float",                 EXT_PACKED_FLOAT              },
 193     {"GL_EXT_point_parameters",             EXT_POINT_PARAMETERS          },
 194     {"GL_EXT_polygon_offset_clamp",         ARB_POLYGON_OFFSET_CLAMP      },
 195     {"GL_EXT_provoking_vertex",             EXT_PROVOKING_VERTEX          },
 196     {"GL_EXT_secondary_color",              EXT_SECONDARY_COLOR           },
 197     {"GL_EXT_stencil_two_side",             EXT_STENCIL_TWO_SIDE          },
 198     {"GL_EXT_stencil_wrap",                 EXT_STENCIL_WRAP              },
 199     {"GL_EXT_texture3D",                    EXT_TEXTURE3D                 },
 200     {"GL_EXT_texture_array",                EXT_TEXTURE_ARRAY             },
 201     {"GL_EXT_texture_compression_rgtc",     EXT_TEXTURE_COMPRESSION_RGTC  },
 202     {"GL_EXT_texture_compression_s3tc",     EXT_TEXTURE_COMPRESSION_S3TC  },
 203     {"GL_EXT_texture_env_combine",          EXT_TEXTURE_ENV_COMBINE       },
 204     {"GL_EXT_texture_env_dot3",             EXT_TEXTURE_ENV_DOT3          },
 205     {"GL_EXT_texture_filter_anisotropic",   ARB_TEXTURE_FILTER_ANISOTROPIC},
 206     {"GL_EXT_texture_integer",              EXT_TEXTURE_INTEGER           },
 207     {"GL_EXT_texture_lod_bias",             EXT_TEXTURE_LOD_BIAS          },
 208     {"GL_EXT_texture_mirror_clamp",         EXT_TEXTURE_MIRROR_CLAMP      },
 209     {"GL_EXT_texture_shadow_lod",           EXT_TEXTURE_SHADOW_LOD        },
 210     {"GL_EXT_texture_shared_exponent",      EXT_TEXTURE_SHARED_EXPONENT   },
 211     {"GL_EXT_texture_snorm",                EXT_TEXTURE_SNORM             },
 212     {"GL_EXT_texture_sRGB",                 EXT_TEXTURE_SRGB              },
 213     {"GL_EXT_texture_sRGB_decode",          EXT_TEXTURE_SRGB_DECODE       },
 214     {"GL_EXT_texture_swizzle",              ARB_TEXTURE_SWIZZLE           },
 215     {"GL_EXT_vertex_array_bgra",            ARB_VERTEX_ARRAY_BGRA         },
 216
 217     /* NV */
 218     {"GL_NV_fence",                         NV_FENCE                      },
 219     {"GL_NV_fog_distance",                  NV_FOG_DISTANCE               },
 220     {"GL_NV_fragment_program",              NV_FRAGMENT_PROGRAM           },
 221     {"GL_NV_fragment_program2",             NV_FRAGMENT_PROGRAM2          },
 222     {"GL_NV_fragment_program_option",       NV_FRAGMENT_PROGRAM_OPTION    },
 223     {"GL_NV_half_float",                    NV_HALF_FLOAT                 },
 224     {"GL_NV_light_max_exponent",            NV_LIGHT_MAX_EXPONENT         },
 225     {"GL_NV_point_sprite",                  NV_POINT_SPRITE               },
 226     {"GL_NV_register_combiners",            NV_REGISTER_COMBINERS         },
 227     {"GL_NV_register_combiners2",           NV_REGISTER_COMBINERS2        },
 228     {"GL_NV_texgen_reflection",             NV_TEXGEN_REFLECTION          },
 229     {"GL_NV_texture_env_combine4",          NV_TEXTURE_ENV_COMBINE4       },
 230     {"GL_NV_texture_shader",                NV_TEXTURE_SHADER             },
 231     {"GL_NV_texture_shader2",               NV_TEXTURE_SHADER2            },
 232     {"GL_NV_vertex_program",                NV_VERTEX_PROGRAM             },
 233     {"GL_NV_vertex_program1_1",             NV_VERTEX_PROGRAM1_1          },
 234     {"GL_NV_vertex_program2",               NV_VERTEX_PROGRAM2            },
 235     {"GL_NV_vertex_program2_option",        NV_VERTEX_PROGRAM2_OPTION     },
 236     {"GL_NV_vertex_program3",               NV_VERTEX_PROGRAM3            },
 237     {"GL_NV_texture_barrier",               NV_TEXTURE_BARRIER            },
 238 };
 239
 240 static const struct wined3d_extension_map wgl_extension_map[] =
 241 {
 242     {"WGL_ARB_pixel_format",                WGL_ARB_PIXEL_FORMAT             },
 243     {"WGL_EXT_swap_control",                WGL_EXT_SWAP_CONTROL             },
 244     {"WGL_WINE_pixel_format_passthrough",   WGL_WINE_PIXEL_FORMAT_PASSTHROUGH},
 245     {"WGL_WINE_query_renderer",             WGL_WINE_QUERY_RENDERER          },
 246 };
 247
 248 static void wined3d_caps_gl_ctx_destroy(const struct wined3d_caps_gl_ctx *ctx)
 249 {
 250     const struct wined3d_gl_info *gl_info = ctx->gl_info;
 251
 252     TRACE("Destroying caps GL context.\n");
 253
 254     /* Both glDeleteProgram and glDeleteBuffers silently ignore 0 IDs but
 255      * this function might be called before the relevant function pointers
 256      * in gl_info are initialized. */
 257     if (ctx->test_program_id || ctx->test_vbo)
 258     {
 259         GL_EXTCALL(glDeleteProgram(ctx->test_program_id));
 260         GL_EXTCALL(glDeleteBuffers(1, &ctx->test_vbo));
 261     }
 262
 263     if (!wglMakeCurrent(NULL, NULL))
 264         ERR("Failed to disable caps GL context.\n");
 265
 266     if (!wglDeleteContext(ctx->gl_ctx))
 267     {
 268         DWORD err = GetLastError();
 269         ERR("wglDeleteContext(%p) failed, last error %#x.\n", ctx->gl_ctx, err);
 270     }
 271
 272     wined3d_release_dc(ctx->wnd, ctx->dc);
 273     DestroyWindow(ctx->wnd);
 274
 275     if (ctx->restore_gl_ctx && !wglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
 276         ERR("Failed to restore previous GL context.\n");
 277 }
 278
 279 static BOOL wined3d_caps_gl_ctx_create_attribs(struct wined3d_caps_gl_ctx *caps_gl_ctx,
 280         struct wined3d_gl_info *gl_info)
 281 {
 282     HGLRC new_ctx;
 283
 284     if (!(gl_info->p_wglCreateContextAttribsARB = (void *)wglGetProcAddress("wglCreateContextAttribsARB")))
 285         return TRUE;
 286
 287     if (!(new_ctx = context_create_wgl_attribs(gl_info, caps_gl_ctx->dc, NULL)))
 288     {
 289         gl_info->p_wglCreateContextAttribsARB = NULL;
 290         return FALSE;
 291     }
 292
 293     if (!wglMakeCurrent(caps_gl_ctx->dc, new_ctx))
 294     {
 295         ERR("Failed to make new context current, last error %#x.\n", GetLastError());
 296         if (!wglDeleteContext(new_ctx))
 297             ERR("Failed to delete new context, last error %#x.\n", GetLastError());
 298         gl_info->p_wglCreateContextAttribsARB = NULL;
 299         return TRUE;
 300     }
 301
 302     if (!wglDeleteContext(caps_gl_ctx->gl_ctx))
 303         ERR("Failed to delete old context, last error %#x.\n", GetLastError());
 304     caps_gl_ctx->gl_ctx = new_ctx;
 305
 306     return TRUE;
 307 }
 308
 309 static BOOL wined3d_caps_gl_ctx_create(struct wined3d_adapter *adapter, struct wined3d_caps_gl_ctx *ctx)
 310 {
 311     PIXELFORMATDESCRIPTOR pfd;
 312     int iPixelFormat;
 313
 314     TRACE("getting context...\n");
 315
 316     ctx->restore_dc = wglGetCurrentDC();
 317     ctx->restore_gl_ctx = wglGetCurrentContext();
 318
 319     /* We need a fake window as a hdc retrieved using GetDC(0) can't be used for much GL purposes. */
 320     ctx->wnd = CreateWindowA(WINED3D_OPENGL_WINDOW_CLASS_NAME, "WineD3D fake window",
 321             WS_OVERLAPPEDWINDOW, 10, 10, 10, 10, NULL, NULL, NULL, NULL);
 322     if (!ctx->wnd)
 323     {
 324         ERR("Failed to create a window.\n");
 325         goto fail;
 326     }
 327
 328     ctx->dc = GetDC(ctx->wnd);
 329     if (!ctx->dc)
 330     {
 331         ERR("Failed to get a DC.\n");
 332         goto fail;
 333     }
 334
 335     /* PixelFormat selection */
 336     ZeroMemory(&pfd, sizeof(pfd));
 337     pfd.nSize = sizeof(pfd);
 338     pfd.nVersion = 1;
 339     pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER | PFD_DRAW_TO_WINDOW; /* PFD_GENERIC_ACCELERATED */
 340     pfd.iPixelType = PFD_TYPE_RGBA;
 341     pfd.cColorBits = 32;
 342     pfd.iLayerType = PFD_MAIN_PLANE;
 343
 344     if (!(iPixelFormat = ChoosePixelFormat(ctx->dc, &pfd)))
 345     {
 346         /* If this happens something is very wrong as ChoosePixelFormat barely fails. */
 347         ERR("Failed to find a suitable pixel format.\n");
 348         goto fail;
 349     }
 350     DescribePixelFormat(ctx->dc, iPixelFormat, sizeof(pfd), &pfd);
 351     SetPixelFormat(ctx->dc, iPixelFormat, &pfd);
 352
 353     /* Create a GL context. */
 354     if (!(ctx->gl_ctx = wglCreateContext(ctx->dc)))
 355     {
 356         WARN("Failed to create default context for capabilities initialization.\n");
 357         goto fail;
 358     }
 359
 360     /* Make it the current GL context. */
 361     if (!wglMakeCurrent(ctx->dc, ctx->gl_ctx))
 362     {
 363         ERR("Failed to make caps GL context current.\n");
 364         goto fail;
 365     }
 366
 367     ctx->gl_info = &adapter->gl_info;
 368     return TRUE;
 369
 370 fail:
 371     if (ctx->gl_ctx) wglDeleteContext(ctx->gl_ctx);
 372     ctx->gl_ctx = NULL;
 373     if (ctx->dc) ReleaseDC(ctx->wnd, ctx->dc);
 374     ctx->dc = NULL;
 375     if (ctx->wnd) DestroyWindow(ctx->wnd);
 376     ctx->wnd = NULL;
 377     if (ctx->restore_gl_ctx && !wglMakeCurrent(ctx->restore_dc, ctx->restore_gl_ctx))
 378         ERR("Failed to restore previous GL context.\n");
 379
 380     return FALSE;
 381 }
 382
 383 /* Context activation is done by the caller. */
 384 static BOOL test_arb_vs_offset_limit(const struct wined3d_gl_info *gl_info)
 385 {
 386     GLuint prog;
 387     BOOL ret = FALSE;
 388     static const char testcode[] =
 389         "!!ARBvp1.0\n"
 390         "PARAM C[66] = { program.env[0..65] };\n"
 391         "ADDRESS A0;"
 392         "PARAM zero = {0.0, 0.0, 0.0, 0.0};\n"
 393         "ARL A0.x, zero.x;\n"
 394         "MOV result.position, C[A0.x + 65];\n"
 395         "END\n";
 396
 397     while (gl_info->gl_ops.gl.p_glGetError());
 398     GL_EXTCALL(glGenProgramsARB(1, &prog));
 399     if(!prog) {
 400         ERR("Failed to create an ARB offset limit test program\n");
 401     }
 402     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
 403     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
 404                                   strlen(testcode), testcode));
 405     if (gl_info->gl_ops.gl.p_glGetError())
 406     {
 407         TRACE("OpenGL implementation does not allow indirect addressing offsets > 63\n");
 408         TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
 409         ret = TRUE;
 410     } else TRACE("OpenGL implementation allows offsets > 63\n");
 411
 412     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
 413     GL_EXTCALL(glDeleteProgramsARB(1, &prog));
 414     checkGLcall("ARB vp offset limit test cleanup");
 415
 416     return ret;
 417 }
 418
 419 static BOOL match_amd_r300_to_500(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 420         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 421         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 422 {
 423     return card_vendor == HW_VENDOR_AMD
 424             && (device == CARD_AMD_RADEON_9500
 425             || device == CARD_AMD_RADEON_X700
 426             || device == CARD_AMD_RADEON_X1600);
 427 }
 428
 429 static BOOL match_geforce5(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 430         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 431         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 432 {
 433     return card_vendor == HW_VENDOR_NVIDIA
 434             && (device == CARD_NVIDIA_GEFORCEFX_5200
 435             || device == CARD_NVIDIA_GEFORCEFX_5600
 436             || device == CARD_NVIDIA_GEFORCEFX_5800);
 437 }
 438
 439 static BOOL match_apple(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 440         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 441         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 442 {
 443     /* MacOS has various specialities in the extensions it advertises. Some
 444      * have to be loaded from the OpenGL 1.2+ core, while other extensions are
 445      * advertised, but software emulated. So try to detect the Apple OpenGL
 446      * implementation to apply some extension fixups afterwards.
 447      *
 448      * Detecting this isn't really easy. The vendor string doesn't mention
 449      * Apple. Compile-time checks aren't sufficient either because a Linux
 450      * binary may display on a macOS X server via remote X11. So try to detect
 451      * the OpenGL implementation by looking at certain Apple extensions. Some
 452      * extensions like client storage might be supported on other
 453      * implementations too, but GL_APPLE_flush_render is specific to the
 454      * macOS X window management, and GL_APPLE_ycbcr_422 is QuickTime
 455      * specific. So the chance that other implementations support them is
 456      * rather small since Win32 QuickTime uses DirectDraw, not OpenGL.
 457      *
 458      * This test has been moved into wined3d_guess_gl_vendor(). */
 459     return gl_vendor == GL_VENDOR_APPLE;
 460 }
 461
 462 /* Context activation is done by the caller. */
 463 static void test_pbo_functionality(struct wined3d_gl_info *gl_info)
 464 {
 465     /* Some OpenGL implementations, namely Apple's Geforce 8 driver, advertises PBOs,
 466      * but glTexSubImage from a PBO fails miserably, with the first line repeated over
 467      * all the texture. This function detects this bug by its symptom and disables PBOs
 468      * if the test fails.
 469      *
 470      * The test uploads a 4x4 texture via the PBO in the "native" format GL_BGRA,
 471      * GL_UNSIGNED_INT_8_8_8_8_REV. This format triggers the bug, and it is what we use
 472      * for D3DFMT_A8R8G8B8. Then the texture is read back without any PBO and the data
 473      * read back is compared to the original. If they are equal PBOs are assumed to work,
 474      * otherwise the PBO extension is disabled. */
 475     GLuint texture, pbo;
 476     static const unsigned int pattern[] =
 477     {
 478         0x00000000, 0x000000ff, 0x0000ff00, 0x40ff0000,
 479         0x80ffffff, 0x40ffff00, 0x00ff00ff, 0x0000ffff,
 480         0x00ffff00, 0x00ff00ff, 0x0000ffff, 0x000000ff,
 481         0x80ff00ff, 0x0000ffff, 0x00ff00ff, 0x40ff00ff
 482     };
 483     unsigned int check[ARRAY_SIZE(pattern)];
 484
 485     /* No PBO -> No point in testing them. */
 486     if (!gl_info->supported[ARB_PIXEL_BUFFER_OBJECT]) return;
 487
 488     while (gl_info->gl_ops.gl.p_glGetError());
 489     gl_info->gl_ops.gl.p_glGenTextures(1, &texture);
 490     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, texture);
 491
 492     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
 493     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);
 494     checkGLcall("Specifying the PBO test texture");
 495
 496     GL_EXTCALL(glGenBuffers(1, &pbo));
 497     GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo));
 498     GL_EXTCALL(glBufferData(GL_PIXEL_UNPACK_BUFFER, sizeof(pattern), pattern, GL_STREAM_DRAW));
 499     checkGLcall("Specifying the PBO test pbo");
 500
 501     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);
 502     checkGLcall("Loading the PBO test texture");
 503
 504     GL_EXTCALL(glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0));
 505
 506     gl_info->gl_ops.gl.p_glFinish(); /* just to be sure */
 507
 508     memset(check, 0, sizeof(check));
 509     gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, check);
 510     checkGLcall("Reading back the PBO test texture");
 511
 512     gl_info->gl_ops.gl.p_glDeleteTextures(1, &texture);
 513     GL_EXTCALL(glDeleteBuffers(1, &pbo));
 514     checkGLcall("PBO test cleanup");
 515
 516     if (memcmp(check, pattern, sizeof(check)))
 517     {
 518         WARN_(d3d_perf)("PBO test failed, read back data doesn't match original.\n"
 519                 "Disabling PBOs. This may result in slower performance.\n");
 520         gl_info->supported[ARB_PIXEL_BUFFER_OBJECT] = FALSE;
 521     }
 522     else
 523     {
 524         TRACE("PBO test successful.\n");
 525     }
 526 }
 527
 528 static BOOL match_apple_intel(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 529         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 530         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 531 {
 532     return (card_vendor == HW_VENDOR_INTEL) && (gl_vendor == GL_VENDOR_APPLE);
 533 }
 534
 535 static BOOL match_apple_nonr500ati(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 536         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 537         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 538 {
 539     if (gl_vendor != GL_VENDOR_APPLE) return FALSE;
 540     if (card_vendor != HW_VENDOR_AMD) return FALSE;
 541     if (device == CARD_AMD_RADEON_X1600) return FALSE;
 542     return TRUE;
 543 }
 544
 545 static BOOL match_dx10_capable(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 546         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 547         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 548 {
 549     /* Direct3D 9 cards support 40 single float varyings in hardware, most
 550      * drivers report 32. ATI misreports 44 varyings. So assume that if we
 551      * have more than 44 varyings we have a Direct3D 10+ card. This detection
 552      * is for the gl_ClipPos varying quirk. If a Direct3D 9 card really
 553      * supports more than 44 varyings and we subtract one in Direct3D 9
 554      * shaders it's not going to hurt us because the Direct3D 9 limit is
 555      * hardcoded.
 556      *
 557      * Direct3D 10 cards usually have 64 varyings. */
 558     return gl_info->limits.glsl_varyings > 44;
 559 }
 560
 561 static BOOL match_not_dx10_capable(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 562         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 563         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 564 {
 565     return !match_dx10_capable(gl_info, ctx, gl_renderer, gl_vendor, card_vendor, device);
 566 }
 567
 568 /* A GL context is provided by the caller */
 569 static BOOL match_allows_spec_alpha(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 570         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 571         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 572 {
 573     GLenum error;
 574     DWORD data[16];
 575
 576     if (!gl_info->supported[EXT_SECONDARY_COLOR] || !gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
 577         return FALSE;
 578
 579     while (gl_info->gl_ops.gl.p_glGetError());
 580     GL_EXTCALL(glSecondaryColorPointerEXT)(4, GL_UNSIGNED_BYTE, 4, data);
 581     error = gl_info->gl_ops.gl.p_glGetError();
 582
 583     if (error == GL_NO_ERROR)
 584     {
 585         TRACE("GL Implementation accepts 4 component specular color pointers\n");
 586         return TRUE;
 587     }
 588     else
 589     {
 590         TRACE("GL implementation does not accept 4 component specular colors, error %s\n",
 591               debug_glerror(error));
 592         return FALSE;
 593     }
 594 }
 595
 596 /* A GL context is provided by the caller */
 597 static BOOL match_broken_nv_clip(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 598         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 599         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 600 {
 601     GLuint prog;
 602     BOOL ret = FALSE;
 603     GLint pos;
 604     static const char testcode[] =
 605         "!!ARBvp1.0\n"
 606         "OPTION NV_vertex_program2;\n"
 607         "MOV result.clip[0], 0.0;\n"
 608         "MOV result.position, 0.0;\n"
 609         "END\n";
 610
 611     if (!gl_info->supported[NV_VERTEX_PROGRAM2_OPTION]) return FALSE;
 612
 613     while (gl_info->gl_ops.gl.p_glGetError());
 614
 615     GL_EXTCALL(glGenProgramsARB(1, &prog));
 616     if(!prog)
 617     {
 618         ERR("Failed to create the NVvp clip test program\n");
 619         return FALSE;
 620     }
 621     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, prog));
 622     GL_EXTCALL(glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
 623                                   strlen(testcode), testcode));
 624     gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &pos);
 625     if(pos != -1)
 626     {
 627         WARN("GL_NV_vertex_program2_option result.clip[] test failed\n");
 628         TRACE("error: %s\n", debugstr_a((const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB)));
 629         ret = TRUE;
 630         while (gl_info->gl_ops.gl.p_glGetError());
 631     }
 632     else TRACE("GL_NV_vertex_program2_option result.clip[] test passed\n");
 633
 634     GL_EXTCALL(glBindProgramARB(GL_VERTEX_PROGRAM_ARB, 0));
 635     GL_EXTCALL(glDeleteProgramsARB(1, &prog));
 636     checkGLcall("GL_NV_vertex_program2_option result.clip[] test cleanup");
 637
 638     return ret;
 639 }
 640
 641 /* Context activation is done by the caller. */
 642 static BOOL match_fbo_tex_update(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     char data[4 * 4 * 4];
 647     GLuint tex, fbo;
 648     GLenum status;
 649
 650     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO) return FALSE;
 651
 652     memset(data, 0xcc, sizeof(data));
 653
 654     gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
 655     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
 656     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 657     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 658     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);
 659     checkGLcall("glTexImage2D");
 660
 661     gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
 662     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 663     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
 664     checkGLcall("glFramebufferTexture2D");
 665
 666     status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_FRAMEBUFFER);
 667     if (status != GL_FRAMEBUFFER_COMPLETE) ERR("FBO status %#x\n", status);
 668     checkGLcall("glCheckFramebufferStatus");
 669
 670     memset(data, 0x11, sizeof(data));
 671     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);
 672     checkGLcall("glTexSubImage2D");
 673
 674     gl_info->gl_ops.gl.p_glClearColor(0.996f, 0.729f, 0.745f, 0.792f);
 675     gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
 676     checkGLcall("glClear");
 677
 678     gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
 679     checkGLcall("glGetTexImage");
 680
 681     gl_info->fbo_ops.glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
 682     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 683     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
 684     checkGLcall("glBindTexture");
 685
 686     gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
 687     gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
 688     checkGLcall("glDeleteTextures");
 689
 690     return *(DWORD *)data == 0x11111111;
 691 }
 692
 693 /* Context activation is done by the caller. */
 694 static BOOL match_broken_rgba16(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 695         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 696         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 697 {
 698     /* GL_RGBA16 uses GL_RGBA8 internally on Geforce 7 and older cards.
 699      * This leads to graphical bugs in Half Life 2 and Unreal engine games. */
 700     GLuint tex;
 701     GLint size;
 702
 703     gl_info->gl_ops.gl.p_glGenTextures(1, &tex);
 704     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex);
 705     gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16, 4, 4, 0, GL_RGBA, GL_UNSIGNED_SHORT, NULL);
 706     checkGLcall("glTexImage2D");
 707
 708     gl_info->gl_ops.gl.p_glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_RED_SIZE, &size);
 709     checkGLcall("glGetTexLevelParameteriv");
 710     TRACE("Real color depth is %d\n", size);
 711
 712     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
 713     checkGLcall("glBindTexture");
 714     gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
 715     checkGLcall("glDeleteTextures");
 716
 717     return size < 16;
 718 }
 719
 720 static BOOL match_fglrx(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 721         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 722         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 723 {
 724     return gl_vendor == GL_VENDOR_FGLRX;
 725 }
 726
 727 static BOOL match_r200(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 728         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 729         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 730 {
 731     if (card_vendor != HW_VENDOR_AMD) return FALSE;
 732     if (device == CARD_AMD_RADEON_8500) return TRUE;
 733     return FALSE;
 734 }
 735
 736 static BOOL match_broken_arb_fog(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
 737         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 738         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 739 {
 740     DWORD data[4];
 741     GLuint tex, fbo;
 742     GLenum status;
 743     float color[4] = {0.0f, 1.0f, 0.0f, 0.0f};
 744     GLuint prog;
 745     GLint err_pos;
 746     static const char program_code[] =
 747         "!!ARBfp1.0\n"
 748         "OPTION ARB_fog_linear;\n"
 749         "MOV result.color, {1.0, 0.0, 0.0, 0.0};\n"
 750         "END\n";
 751
 752     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
 753         return FALSE;
 754     if (!gl_info->supported[ARB_FRAGMENT_PROGRAM])
 755         return FALSE;
 756     if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
 757         return FALSE;
 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_RGB8, 4, 1, 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     gl_info->gl_ops.gl.p_glClearColor(0.0f, 0.0f, 1.0f, 0.0f);
 776     gl_info->gl_ops.gl.p_glClear(GL_COLOR_BUFFER_BIT);
 777     checkGLcall("glClear");
 778     gl_info->gl_ops.gl.p_glViewport(0, 0, 4, 1);
 779     checkGLcall("glViewport");
 780
 781     gl_info->gl_ops.gl.p_glEnable(GL_FOG);
 782     gl_info->gl_ops.gl.p_glFogf(GL_FOG_START, 0.5f);
 783     gl_info->gl_ops.gl.p_glFogf(GL_FOG_END, 0.5f);
 784     gl_info->gl_ops.gl.p_glFogi(GL_FOG_MODE, GL_LINEAR);
 785     gl_info->gl_ops.gl.p_glHint(GL_FOG_HINT, GL_NICEST);
 786     gl_info->gl_ops.gl.p_glFogfv(GL_FOG_COLOR, color);
 787     checkGLcall("fog setup");
 788
 789     GL_EXTCALL(glGenProgramsARB(1, &prog));
 790     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, prog));
 791     GL_EXTCALL(glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
 792             strlen(program_code), program_code));
 793     gl_info->gl_ops.gl.p_glEnable(GL_FRAGMENT_PROGRAM_ARB);
 794     checkGLcall("Test fragment program setup");
 795
 796     gl_info->gl_ops.gl.p_glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &err_pos);
 797     if (err_pos != -1)
 798     {
 799         const char *error_str;
 800         error_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_PROGRAM_ERROR_STRING_ARB);
 801         FIXME("Fog test program error at position %d: %s\n\n", err_pos, debugstr_a(error_str));
 802     }
 803
 804     gl_info->gl_ops.gl.p_glBegin(GL_TRIANGLE_STRIP);
 805     gl_info->gl_ops.gl.p_glVertex3f(-1.0f, -1.0f,  0.0f);
 806     gl_info->gl_ops.gl.p_glVertex3f( 1.0f, -1.0f,  1.0f);
 807     gl_info->gl_ops.gl.p_glVertex3f(-1.0f,  1.0f,  0.0f);
 808     gl_info->gl_ops.gl.p_glVertex3f( 1.0f,  1.0f,  1.0f);
 809     gl_info->gl_ops.gl.p_glEnd();
 810     checkGLcall("ARBfp fog test draw");
 811
 812     gl_info->gl_ops.gl.p_glGetTexImage(GL_TEXTURE_2D, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, data);
 813     checkGLcall("glGetTexImage");
 814     data[0] &= 0x00ffffff;
 815     data[1] &= 0x00ffffff;
 816     data[2] &= 0x00ffffff;
 817     data[3] &= 0x00ffffff;
 818
 819     gl_info->fbo_ops.glBindFramebuffer(GL_FRAMEBUFFER, 0);
 820     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
 821
 822     gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
 823     gl_info->gl_ops.gl.p_glDeleteTextures(1, &tex);
 824     gl_info->gl_ops.gl.p_glDisable(GL_FOG);
 825     GL_EXTCALL(glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, 0));
 826     gl_info->gl_ops.gl.p_glDisable(GL_FRAGMENT_PROGRAM_ARB);
 827     GL_EXTCALL(glDeleteProgramsARB(1, &prog));
 828     checkGLcall("ARBfp fog test teardown");
 829
 830     TRACE("Fog test data: %08x %08x %08x %08x\n", data[0], data[1], data[2], data[3]);
 831     return data[0] != 0x00ff0000 || data[3] != 0x0000ff00;
 832 }
 833
 834 static BOOL match_broken_viewport_subpixel_bits(const struct wined3d_gl_info *gl_info,
 835         struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 836         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 837 {
 838     if (!gl_info->supported[ARB_VIEWPORT_ARRAY])
 839         return FALSE;
 840     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
 841         return FALSE;
 842     return !wined3d_caps_gl_ctx_test_viewport_subpixel_bits(ctx);
 843 }
 844
 845 static BOOL match_no_independent_bit_depths(const struct wined3d_gl_info *gl_info,
 846         struct wined3d_caps_gl_ctx *ctx, const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
 847         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
 848 {
 849     GLuint tex[2], fbo;
 850     GLenum status;
 851
 852     /* ARB_framebuffer_object allows implementation-dependent internal format
 853      * restrictions. The EXT extension explicitly calls out an error in the
 854      * relevant case. */
 855     if (!gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
 856         return TRUE;
 857     if (wined3d_settings.offscreen_rendering_mode != ORM_FBO)
 858         return TRUE;
 859
 860     gl_info->gl_ops.gl.p_glGenTextures(2, tex);
 861
 862     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex[0]);
 863     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 864     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 865     gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, 4, 1, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, NULL);
 866
 867     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, tex[1]);
 868     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 869     gl_info->gl_ops.gl.p_glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 870     gl_info->gl_ops.gl.p_glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB5, 4, 1, 0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, NULL);
 871     gl_info->gl_ops.gl.p_glBindTexture(GL_TEXTURE_2D, 0);
 872
 873     gl_info->fbo_ops.glGenFramebuffers(1, &fbo);
 874     gl_info->fbo_ops.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
 875     gl_info->fbo_ops.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex[0], 0);
 876     gl_info->fbo_ops.glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, tex[1], 0);
 877
 878     status = gl_info->fbo_ops.glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
 879
 880     gl_info->fbo_ops.glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
 881     gl_info->fbo_ops.glDeleteFramebuffers(1, &fbo);
 882     gl_info->gl_ops.gl.p_glDeleteTextures(2, tex);
 883     checkGLcall("testing multiple framebuffer attachments with different bit depths");
 884
 885     return status != GL_FRAMEBUFFER_COMPLETE;
 886 }
 887
 888 static void quirk_apple_glsl_constants(struct wined3d_gl_info *gl_info)
 889 {
 890     /* MacOS needs uniforms for relative addressing offsets. This can
 891      * accumulate to quite a few uniforms. Beyond that the general uniform
 892      * isn't optimal, so reserve a number of uniforms. 12 vec4's should allow
 893      * 48 different offsets or other helper immediate values. */
 894     TRACE("Reserving 12 GLSL constants for compiler private use.\n");
 895     gl_info->reserved_glsl_constants = max(gl_info->reserved_glsl_constants, 12);
 896 }
 897
 898 static void quirk_amd_dx9(struct wined3d_gl_info *gl_info)
 899 {
 900     /* MacOS advertises GL_ARB_texture_non_power_of_two on ATI r500 and
 901      * earlier cards, although these cards only support
 902      * GL_ARB_texture_rectangle (D3DPTEXTURECAPS_NONPOW2CONDITIONAL).
 903      *
 904      * If real NP2 textures are used, the driver falls back to software. We
 905      * could just disable the extension and use GL_ARB_texture_rectangle
 906      * instead, but texture_rectangle is inconvenient due to the
 907      * non-normalised texture coordinates. Thus set an internal extension
 908      * flag, GL_WINE_normalized_texrect, which signals the code that it can
 909      * use non-power-of-two textures as per GL_ARB_texture_non_power_of_two,
 910      * but has to stick to the texture_rectangle limits.
 911      *
 912      * Fglrx doesn't advertise GL_ARB_texture_non_power_of_two, but it
 913      * advertises OpenGL 2.0, which has this extension promoted to core. The
 914      * extension loading code sets this extension supported due to that, so
 915      * this code works on fglrx as well. */
 916     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
 917     {
 918         TRACE("GL_ARB_texture_non_power_of_two advertised on R500 or earlier card, removing.\n");
 919         gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
 920         gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT] = TRUE;
 921     }
 922 }
 923
 924 static void quirk_no_np2(struct wined3d_gl_info *gl_info)
 925 {
 926     /*  The NVIDIA GeForce FX series reports OpenGL 2.0 capabilities with the
 927      *  latest drivers versions, but doesn't explicitly advertise the
 928      *  ARB_tex_npot extension in the OpenGL extension string. This usually
 929      *  means that ARB_tex_npot is supported in hardware as long as the
 930      *  application is staying within the limits enforced by the
 931      *  ARB_texture_rectangle extension. This however is not true for the
 932      *  FX series, which instantly falls back to a slower software path as
 933      *  soon as ARB_tex_npot is used. We therefore completely remove
 934      *  ARB_tex_npot from the list of supported extensions.
 935      *
 936      *  Note that WINE_normalized_texrect can't be used in this case because
 937      *  internally it uses ARB_tex_npot, triggering the software fallback.
 938      *  There is not much we can do here apart from disabling the
 939      *  software-emulated extension and re-enable ARB_tex_rect (which was
 940      *  previously disabled in wined3d_adapter_init_gl_caps).
 941      *
 942      *  This fixup removes performance problems on both the FX 5900 and
 943      *  FX 5700 (e.g. for framebuffer post-processing effects in the game
 944      *  "Max Payne 2"). The behaviour can be verified through a simple test
 945      *  app attached in bugreport #14724. */
 946     TRACE("GL_ARB_texture_non_power_of_two advertised through OpenGL 2.0 on NV FX card, removing.\n");
 947     gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO] = FALSE;
 948     gl_info->supported[ARB_TEXTURE_RECTANGLE] = TRUE;
 949 }
 950
 951 static void quirk_texcoord_w(struct wined3d_gl_info *gl_info)
 952 {
 953     /* The Intel GPUs on macOS set the .w register of texcoords to 0.0 by
 954      * default, which causes problems with fixed-function fragment processing.
 955      * Ideally this flag should be detected with a test shader and OpenGL
 956      * feedback mode, but some OpenGL implementations (macOS ATI at least,
 957      * probably all macOS ones) do not like vertex shaders in feedback mode
 958      * and return an error, even though it should be valid according to the
 959      * spec.
 960      *
 961      * We don't want to enable this on all cards, as it adds an extra
 962      * instruction per texcoord used. This makes the shader slower and eats
 963      * instruction slots which should be available to the Direct3D
 964      * application.
 965      *
 966      * ATI Radeon HD 2xxx cards on macOS have the issue. Instead of checking
 967      * for the buggy cards, blacklist all Radeon cards on macOS and whitelist
 968      * the good ones. That way we're prepared for the future. If this
 969      * workaround is activated on cards that do not need it, it won't break
 970      * things, just affect performance negatively. */
 971     TRACE("Enabling vertex texture coord fixes in vertex shaders.\n");
 972     gl_info->quirks |= WINED3D_QUIRK_SET_TEXCOORD_W;
 973 }
 974
 975 static void quirk_clip_varying(struct wined3d_gl_info *gl_info)
 976 {
 977     gl_info->quirks |= WINED3D_QUIRK_GLSL_CLIP_VARYING;
 978 }
 979
 980 static void quirk_allows_specular_alpha(struct wined3d_gl_info *gl_info)
 981 {
 982     gl_info->quirks |= WINED3D_QUIRK_ALLOWS_SPECULAR_ALPHA;
 983 }
 984
 985 static void quirk_disable_nvvp_clip(struct wined3d_gl_info *gl_info)
 986 {
 987     gl_info->quirks |= WINED3D_QUIRK_NV_CLIP_BROKEN;
 988 }
 989
 990 static void quirk_fbo_tex_update(struct wined3d_gl_info *gl_info)
 991 {
 992     gl_info->quirks |= WINED3D_QUIRK_FBO_TEX_UPDATE;
 993 }
 994
 995 static void quirk_broken_rgba16(struct wined3d_gl_info *gl_info)
 996 {
 997     gl_info->quirks |= WINED3D_QUIRK_BROKEN_RGBA16;
 998 }
 999
1000 static void quirk_infolog_spam(struct wined3d_gl_info *gl_info)
1001 {
1002     gl_info->quirks |= WINED3D_QUIRK_INFO_LOG_SPAM;
1003 }
1004
1005 static void quirk_limited_tex_filtering(struct wined3d_gl_info *gl_info)
1006 {
1007     /* NVIDIA GeForce 6xxx and 7xxx support accelerated VTF only on a few
1008      * selected texture formats. They are apparently the only Direct3D 9 class
1009      * GPUs supporting VTF. Also, Direct3D 9-era GPUs are somewhat limited
1010      * with float texture filtering and blending. */
1011     gl_info->quirks |= WINED3D_QUIRK_LIMITED_TEX_FILTERING;
1012 }
1013
1014 static void quirk_r200_constants(struct wined3d_gl_info *gl_info)
1015 {
1016     /* The Mesa r200 driver (and there is no other driver for this GPU Wine
1017      * would run on) loads some fog parameters (start, end, exponent, but not
1018      * the colour) into the program.
1019      *
1020      * Apparently the fog hardware is only able to handle linear fog with a
1021      * range of 0.0;1.0, and it is the responsibility of the vertex pipeline
1022      * to handle non-linear fog and linear fog with start and end other than
1023      * 0.0 and 1.0. */
1024     TRACE("Reserving 1 ARB constant for compiler private use.\n");
1025     gl_info->reserved_arb_constants = max(gl_info->reserved_arb_constants, 1);
1026 }
1027
1028 static void quirk_broken_arb_fog(struct wined3d_gl_info *gl_info)
1029 {
1030     gl_info->quirks |= WINED3D_QUIRK_BROKEN_ARB_FOG;
1031 }
1032
1033 static void quirk_broken_viewport_subpixel_bits(struct wined3d_gl_info *gl_info)
1034 {
1035     if (gl_info->supported[ARB_CLIP_CONTROL])
1036     {
1037         TRACE("Disabling ARB_clip_control.\n");
1038         gl_info->supported[ARB_CLIP_CONTROL] = FALSE;
1039     }
1040 }
1041
1042 static void quirk_no_independent_bit_depths(struct wined3d_gl_info *gl_info)
1043 {
1044     gl_info->quirks |= WINED3D_QUIRK_NO_INDEPENDENT_BIT_DEPTHS;
1045 }
1046
1047 static const struct wined3d_gpu_description *query_gpu_description(const struct wined3d_gl_info *gl_info,
1048         UINT64 *vram_bytes)
1049 {
1050     const struct wined3d_gpu_description *gpu_description = NULL, *gpu_description_override;
1051     enum wined3d_pci_vendor vendor = PCI_VENDOR_NONE;
1052     enum wined3d_pci_device device = PCI_DEVICE_NONE;
1053     GLuint value;
1054
1055     if (gl_info->supported[WGL_WINE_QUERY_RENDERER])
1056     {
1057         if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_VENDOR_ID_WINE, &value)))
1058             vendor = value;
1059         if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_DEVICE_ID_WINE, &value)))
1060             device = value;
1061         if (GL_EXTCALL(wglQueryCurrentRendererIntegerWINE(WGL_RENDERER_VIDEO_MEMORY_WINE, &value)))
1062             *vram_bytes = (UINT64)value * 1024 * 1024;
1063
1064         TRACE("Card reports vendor PCI ID 0x%04x, device PCI ID 0x%04x, 0x%s bytes of video memory.\n",
1065                 vendor, device, wine_dbgstr_longlong(*vram_bytes));
1066
1067         gpu_description = wined3d_get_gpu_description(vendor, device);
1068     }
1069
1070     if ((gpu_description_override = wined3d_get_user_override_gpu_description(vendor, device)))
1071         gpu_description = gpu_description_override;
1072
1073     return gpu_description;
1074 }
1075
1076 /* Context activation is done by the caller. */
1077 static void fixup_extensions(struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
1078         const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
1079         enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device)
1080 {
1081     unsigned int i;
1082
1083     static const struct driver_quirk
1084     {
1085         BOOL (*match)(const struct wined3d_gl_info *gl_info, struct wined3d_caps_gl_ctx *ctx,
1086                 const char *gl_renderer, enum wined3d_gl_vendor gl_vendor,
1087                 enum wined3d_pci_vendor card_vendor, enum wined3d_pci_device device);
1088         void (*apply)(struct wined3d_gl_info *gl_info);
1089         const char *description;
1090     }
1091     quirk_table[] =
1092     {
1093         {
1094             match_amd_r300_to_500,
1095             quirk_amd_dx9,
1096             "AMD normalised texrect quirk"
1097         },
1098         {
1099             match_apple,
1100             quirk_apple_glsl_constants,
1101             "Apple GLSL uniform override"
1102         },
1103         {
1104             match_geforce5,
1105             quirk_no_np2,
1106             "Geforce 5 NP2 disable"
1107         },
1108         {
1109             match_apple_intel,
1110             quirk_texcoord_w,
1111             "Init texcoord .w for Apple Intel GPU driver"
1112         },
1113         {
1114             match_apple_nonr500ati,
1115             quirk_texcoord_w,
1116             "Init texcoord .w for Apple ATI >= r600 GPU driver"
1117         },
1118         {
1119             match_dx10_capable,
1120             quirk_clip_varying,
1121             "Reserved varying for gl_ClipPos"
1122         },
1123         {
1124             /* GL_EXT_secondary_color does not allow 4 component secondary
1125              * colours, but most OpenGL implementations accept it. Apple's
1126              * is the only OpenGL implementation known to reject it.
1127              *
1128              * If we can pass 4-component specular colours, do it, because
1129              * (a) we don't have to screw around with the data, and (b) the
1130              * Direct3D fixed-function vertex pipeline passes specular alpha
1131              * to the pixel shader if any is used. Otherwise the specular
1132              * alpha is used to pass the fog coordinate, which we pass to
1133              * OpenGL via GL_EXT_fog_coord. */
1134             match_allows_spec_alpha,
1135             quirk_allows_specular_alpha,
1136             "Allow specular alpha quirk"
1137         },
1138         {
1139             match_broken_nv_clip,
1140             quirk_disable_nvvp_clip,
1141             "Apple NV_vertex_program clip bug quirk"
1142         },
1143         {
1144             match_fbo_tex_update,
1145             quirk_fbo_tex_update,
1146             "FBO rebind for attachment updates"
1147         },
1148         {
1149             match_broken_rgba16,
1150             quirk_broken_rgba16,
1151             "True RGBA16 is not available"
1152         },
1153         {
1154             match_fglrx,
1155             quirk_infolog_spam,
1156             "Not printing GLSL infolog"
1157         },
1158         {
1159             match_not_dx10_capable,
1160             quirk_limited_tex_filtering,
1161             "Texture filtering, blending and VTF support is limited"
1162         },
1163         {
1164             match_r200,
1165             quirk_r200_constants,
1166             "r200 vertex shader constants"
1167         },
1168         {
1169             match_broken_arb_fog,
1170             quirk_broken_arb_fog,
1171             "ARBfp fogstart == fogend workaround"
1172         },
1173         {
1174             match_broken_viewport_subpixel_bits,
1175             quirk_broken_viewport_subpixel_bits,
1176             "NVIDIA viewport subpixel bits bug"
1177         },
1178         {
1179             match_no_independent_bit_depths,
1180             quirk_no_independent_bit_depths,
1181             "No support for MRT with independent bit depths"
1182         },
1183     };
1184
1185     for (i = 0; i < ARRAY_SIZE(quirk_table); ++i)
1186     {
1187         if (!quirk_table[i].match(gl_info, ctx, gl_renderer, gl_vendor, card_vendor, device)) continue;
1188         TRACE("Applying driver quirk \"%s\".\n", quirk_table[i].description);
1189         quirk_table[i].apply(gl_info);
1190     }
1191
1192     /* Find out if PBOs work as they are supposed to. */
1193     test_pbo_functionality(gl_info);
1194 }
1195
1196 static DWORD wined3d_parse_gl_version(const char *gl_version)
1197 {
1198     const char *ptr = gl_version;
1199     int major, minor;
1200
1201     major = atoi(ptr);
1202     if (major <= 0)
1203         ERR("Invalid OpenGL major version %d.\n", major);
1204
1205     while (isdigit(*ptr)) ++ptr;
1206     if (*ptr++ != '.')
1207         ERR("Invalid OpenGL version string %s.\n", debugstr_a(gl_version));
1208
1209     minor = atoi(ptr);
1210
1211     TRACE("Found OpenGL version %d.%d.\n", major, minor);
1212
1213     return MAKEDWORD_VERSION(major, minor);
1214 }
1215
1216 static enum wined3d_gl_vendor wined3d_guess_gl_vendor(const struct wined3d_gl_info *gl_info,
1217         const char *gl_vendor_string, const char *gl_renderer, const char *gl_version)
1218 {
1219     /* MacOS has various specialities in the extensions it advertises. Some have to be loaded from
1220      * the opengl 1.2+ core, while other extensions are advertised, but software emulated. So try to
1221      * detect the Apple OpenGL implementation to apply some extension fixups afterwards.
1222      *
1223      * Detecting this isn't really easy. The vendor string doesn't mention Apple. Compile-time checks
1224      * aren't sufficient either because a Linux binary may display on a macos X server via remote X11.
1225      * So try to detect the GL implementation by looking at certain Apple extensions. Some extensions
1226      * like client storage might be supported on other implementations too, but GL_APPLE_flush_render
1227      * is specific to the Mac OS X window management, and GL_APPLE_ycbcr_422 is QuickTime specific. So
1228      * the chance that other implementations support them is rather small since Win32 QuickTime uses
1229      * DirectDraw, not OpenGL. */
1230     if (gl_info->supported[APPLE_FLUSH_RENDER]
1231             && (gl_info->supported[APPLE_YCBCR_422] || gl_info->supported[APPLE_RGB_422]))
1232         return GL_VENDOR_APPLE;
1233
1234     if (strstr(gl_vendor_string, "NVIDIA"))
1235         return GL_VENDOR_NVIDIA;
1236
1237     if (strstr(gl_vendor_string, "ATI"))
1238         return GL_VENDOR_FGLRX;
1239
1240     if (strstr(gl_vendor_string, "Mesa")
1241             || strstr(gl_vendor_string, "X.Org")
1242             || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1243             || strstr(gl_vendor_string, "DRI R300 Project")
1244             || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1245             || strstr(gl_vendor_string, "VMware, Inc.")
1246             || strstr(gl_vendor_string, "Red Hat")
1247             || strstr(gl_vendor_string, "Intel")
1248             || strstr(gl_renderer, "Mesa")
1249             || strstr(gl_renderer, "Gallium")
1250             || strstr(gl_renderer, "Intel")
1251             || strstr(gl_version, "Mesa"))
1252         return GL_VENDOR_MESA;
1253
1254     FIXME("Received unrecognized GL_VENDOR %s. Returning GL_VENDOR_UNKNOWN.\n",
1255             debugstr_a(gl_vendor_string));
1256
1257     return GL_VENDOR_UNKNOWN;
1258 }
1259
1260 static enum wined3d_pci_vendor wined3d_guess_card_vendor(const char *gl_vendor_string, const char *gl_renderer)
1261 {
1262     if (strstr(gl_vendor_string, "NVIDIA")
1263             || strstr(gl_vendor_string, "Nouveau")
1264             || strstr(gl_vendor_string, "nouveau"))
1265         return HW_VENDOR_NVIDIA;
1266
1267     if (strstr(gl_vendor_string, "ATI")
1268             || strstr(gl_vendor_string, "Advanced Micro Devices, Inc.")
1269             || strstr(gl_vendor_string, "X.Org R300 Project")
1270             || strstr(gl_renderer, "AMD")
1271             || strstr(gl_renderer, "FirePro")
1272             || strstr(gl_renderer, "Radeon")
1273             || strstr(gl_renderer, "R100")
1274             || strstr(gl_renderer, "R200")
1275             || strstr(gl_renderer, "R300")
1276             || strstr(gl_renderer, "R600")
1277             || strstr(gl_renderer, "R700"))
1278         return HW_VENDOR_AMD;
1279
1280     if (strstr(gl_vendor_string, "Intel(R)")
1281             /* Intel switched from Intel(R) to Intel® recently, so just match Intel. */
1282             || strstr(gl_renderer, "Intel")
1283             || strstr(gl_renderer, "i915")
1284             || strstr(gl_vendor_string, "Intel Inc."))
1285         return HW_VENDOR_INTEL;
1286
1287     if (strstr(gl_vendor_string, "Red Hat")
1288             || strstr(gl_renderer, "virgl"))
1289         return HW_VENDOR_REDHAT;
1290
1291     if (strstr(gl_renderer, "SVGA3D"))
1292         return HW_VENDOR_VMWARE;
1293
1294     if (strstr(gl_vendor_string, "Mesa")
1295             || strstr(gl_vendor_string, "Brian Paul")
1296             || strstr(gl_vendor_string, "Tungsten Graphics, Inc")
1297             || strstr(gl_vendor_string, "VMware, Inc."))
1298         return HW_VENDOR_SOFTWARE;
1299
1300     FIXME("Received unrecognized GL_VENDOR %s. Returning HW_VENDOR_NVIDIA.\n", debugstr_a(gl_vendor_string));
1301
1302     return HW_VENDOR_NVIDIA;
1303 }
1304
1305 static enum wined3d_feature_level feature_level_from_caps(const struct wined3d_gl_info *gl_info,
1306         const struct shader_caps *shader_caps, const struct fragment_caps *fragment_caps)
1307 {
1308     unsigned int shader_model;
1309
1310     shader_model = min(shader_caps->vs_version, shader_caps->ps_version);
1311     shader_model = min(shader_model, max(shader_caps->gs_version, 3));
1312     shader_model = min(shader_model, max(shader_caps->hs_version, 4));
1313     shader_model = min(shader_model, max(shader_caps->ds_version, 4));
1314
1315     if (gl_info->supported[WINED3D_GL_VERSION_3_2]
1316             && gl_info->supported[ARB_POLYGON_OFFSET_CLAMP]
1317             && gl_info->supported[ARB_SAMPLER_OBJECTS])
1318     {
1319         if (shader_model >= 5
1320                 && gl_info->supported[ARB_DRAW_INDIRECT]
1321                 && gl_info->supported[ARB_TEXTURE_COMPRESSION_BPTC])
1322             return WINED3D_FEATURE_LEVEL_11_1;
1323
1324         if (shader_model >= 4)
1325         {
1326             if (gl_info->supported[ARB_TEXTURE_CUBE_MAP_ARRAY]
1327                     && gl_info->supported[ARB_DRAW_BUFFERS_BLEND])
1328                 return WINED3D_FEATURE_LEVEL_10_1;
1329             return WINED3D_FEATURE_LEVEL_10;
1330         }
1331     }
1332
1333     if (shader_model >= 3 && gl_info->limits.texture_size >= 4096 && gl_info->limits.buffers >= 4)
1334         return WINED3D_FEATURE_LEVEL_9_3;
1335     if (shader_model >= 2)
1336     {
1337         if (gl_info->supported[ARB_OCCLUSION_QUERY]
1338                 && gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE]
1339                 && gl_info->supported[EXT_BLEND_EQUATION_SEPARATE]
1340                 && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
1341             return WINED3D_FEATURE_LEVEL_9_2;
1342
1343         return WINED3D_FEATURE_LEVEL_9_1;
1344     }
1345     if (shader_model >= 1)
1346         return WINED3D_FEATURE_LEVEL_8;
1347
1348     if (fragment_caps->TextureOpCaps & WINED3DTEXOPCAPS_DOTPRODUCT3)
1349         return WINED3D_FEATURE_LEVEL_7;
1350     if (fragment_caps->MaxSimultaneousTextures > 1)
1351         return WINED3D_FEATURE_LEVEL_6;
1352
1353     return WINED3D_FEATURE_LEVEL_5;
1354 }
1355
1356 static const struct wined3d_renderer_table
1357 {
1358     const char *renderer;
1359     enum wined3d_pci_device id;
1360 }
1361 cards_nvidia_binary[] =
1362 {
1363     /* Direct 3D 11 */
1364     {"RTX 2080 Ti",                 CARD_NVIDIA_GEFORCE_RTX2080TI}, /* GeForce 2000 - highend */
1365     {"RTX 2080",                    CARD_NVIDIA_GEFORCE_RTX2080},   /* GeForce 2000 - highend */
1366     {"RTX 2070",                    CARD_NVIDIA_GEFORCE_RTX2070},   /* GeForce 2000 - highend */
1367     {"RTX 2060",                    CARD_NVIDIA_GEFORCE_RTX2060},   /* GeForce 2000 - highend */
1368     {"GTX 1660 Ti",                 CARD_NVIDIA_GEFORCE_GTX1660TI}, /* GeForce 1600 - highend */
1369     {"GTX 1660 SUPER",              CARD_NVIDIA_GEFORCE_GTX1660SUPER}, /* GeForce 1600 - highend */
1370     {"GTX 1650 SUPER",              CARD_NVIDIA_GEFORCE_GTX1650SUPER}, /* GeForce 1600 - midend high */
1371     {"TITAN V",                     CARD_NVIDIA_TITANV},            /* GeForce 1000 - highend */
1372     {"TITAN X (Pascal)",            CARD_NVIDIA_TITANX_PASCAL},     /* GeForce 1000 - highend */
1373     {"GTX 1080 Ti",                 CARD_NVIDIA_GEFORCE_GTX1080TI}, /* GeForce 1000 - highend */
1374     {"GTX 1080",                    CARD_NVIDIA_GEFORCE_GTX1080},   /* GeForce 1000 - highend */
1375     {"GTX 1070",                    CARD_NVIDIA_GEFORCE_GTX1070},   /* GeForce 1000 - highend */
1376     {"GTX 1060 3GB",                CARD_NVIDIA_GEFORCE_GTX1060_3GB},/* GeForce 1000 - midend high */
1377     {"GTX 1060",                    CARD_NVIDIA_GEFORCE_GTX1060},   /* GeForce 1000 - midend high */
1378     {"GTX 1050 Ti",                 CARD_NVIDIA_GEFORCE_GTX1050TI}, /* GeForce 1000 - midend */
1379     {"GTX 1050",                    CARD_NVIDIA_GEFORCE_GTX1050},   /* GeForce 1000 - midend */
1380     {"GTX 980 Ti",                  CARD_NVIDIA_GEFORCE_GTX980TI},  /* GeForce 900 - highend */
1381     {"GTX 980",                     CARD_NVIDIA_GEFORCE_GTX980},    /* GeForce 900 - highend */
1382     {"GTX 970M",                    CARD_NVIDIA_GEFORCE_GTX970M},   /* GeForce 900 - highend mobile*/
1383     {"GTX 970",                     CARD_NVIDIA_GEFORCE_GTX970},    /* GeForce 900 - highend */
1384     {"GTX TITAN X",                 CARD_NVIDIA_GEFORCE_GTXTITANX}, /* Geforce 900 - highend */
1385     {"GTX 960M",                    CARD_NVIDIA_GEFORCE_GTX960M},   /* GeForce 900 - midend high mobile */
1386     {"GTX 960",                     CARD_NVIDIA_GEFORCE_GTX960},    /* GeForce 900 - midend high */
1387     {"GTX 950M",                    CARD_NVIDIA_GEFORCE_GTX950M},   /* GeForce 900 - midend mobile */
1388     {"GTX 950",                     CARD_NVIDIA_GEFORCE_GTX950},    /* GeForce 900 - midend */
1389     {"GeForce 940M",                CARD_NVIDIA_GEFORCE_940M},      /* GeForce 900 - midend mobile */
1390     {"GTX 880M",                    CARD_NVIDIA_GEFORCE_GTX880M},   /* GeForce 800 - mobile */
1391     {"GTX 870M",                    CARD_NVIDIA_GEFORCE_GTX870M},   /* GeForce 800 - mobile */
1392     {"GTX 860M",                    CARD_NVIDIA_GEFORCE_GTX860M},   /* GeForce 800 - mobile */
1393     {"GTX 850M",                    CARD_NVIDIA_GEFORCE_GTX850M},   /* GeForce 800 - mobile */
1394     {"GeForce 845M",                CARD_NVIDIA_GEFORCE_845M},      /* GeForce 800 - mobile */
1395     {"GeForce 840M",                CARD_NVIDIA_GEFORCE_840M},      /* GeForce 800 - mobile */
1396     {"GeForce 830M",                CARD_NVIDIA_GEFORCE_830M},      /* GeForce 800 - mobile */
1397     {"GeForce 820M",                CARD_NVIDIA_GEFORCE_820M},      /* GeForce 800 - mobile */
1398     {"GTX 780 Ti",                  CARD_NVIDIA_GEFORCE_GTX780TI},  /* Geforce 700 - highend */
1399     {"GTX TITAN Black",             CARD_NVIDIA_GEFORCE_GTXTITANB}, /* Geforce 700 - highend */
1400     {"GTX TITAN Z",                 CARD_NVIDIA_GEFORCE_GTXTITANZ}, /* Geforce 700 - highend */
1401     {"GTX TITAN",                   CARD_NVIDIA_GEFORCE_GTXTITAN},  /* Geforce 700 - highend */
1402     {"GTX 780",                     CARD_NVIDIA_GEFORCE_GTX780},    /* Geforce 700 - highend */
1403     {"GTX 770M",                    CARD_NVIDIA_GEFORCE_GTX770M},   /* Geforce 700 - midend high mobile */
1404     {"GTX 770",                     CARD_NVIDIA_GEFORCE_GTX770},    /* Geforce 700 - highend */
1405     {"GTX 765M",                    CARD_NVIDIA_GEFORCE_GTX765M},   /* Geforce 700 - midend high mobile */
1406     {"GTX 760 Ti",                  CARD_NVIDIA_GEFORCE_GTX760TI},  /* Geforce 700 - midend high */
1407     {"GTX 760",                     CARD_NVIDIA_GEFORCE_GTX760},    /* Geforce 700 - midend high  */
1408     {"GTX 750 Ti",                  CARD_NVIDIA_GEFORCE_GTX750TI},  /* Geforce 700 - midend */
1409     {"GTX 750",                     CARD_NVIDIA_GEFORCE_GTX750},    /* Geforce 700 - midend */
1410     {"GT 750M",                     CARD_NVIDIA_GEFORCE_GT750M},    /* Geforce 700 - midend mobile */
1411     {"GT 740M",                     CARD_NVIDIA_GEFORCE_GT740M},    /* Geforce 700 - midend mobile */
1412     {"GT 730M",                     CARD_NVIDIA_GEFORCE_GT730M},    /* Geforce 700 - midend mobile */
1413     {"GT 730",                      CARD_NVIDIA_GEFORCE_GT730},     /* Geforce 700 - lowend */
1414     {"GTX 690",                     CARD_NVIDIA_GEFORCE_GTX690},    /* Geforce 600 - highend */
1415     {"GTX 680",                     CARD_NVIDIA_GEFORCE_GTX680},    /* Geforce 600 - highend */
1416     {"GTX 675MX",                   CARD_NVIDIA_GEFORCE_GTX675MX_1},/* Geforce 600 - highend */
1417     {"GTX 670MX",                   CARD_NVIDIA_GEFORCE_GTX670MX},  /* Geforce 600 - highend */
1418     {"GTX 670",                     CARD_NVIDIA_GEFORCE_GTX670},    /* Geforce 600 - midend high */
1419     {"GTX 660 Ti",                  CARD_NVIDIA_GEFORCE_GTX660TI},  /* Geforce 600 - midend high */
1420     {"GTX 660M",                    CARD_NVIDIA_GEFORCE_GTX660M},   /* Geforce 600 - midend high mobile */
1421     {"GTX 660",                     CARD_NVIDIA_GEFORCE_GTX660},    /* Geforce 600 - midend high */
1422     {"GTX 650 Ti",                  CARD_NVIDIA_GEFORCE_GTX650TI},  /* Geforce 600 - lowend */
1423     {"GTX 650",                     CARD_NVIDIA_GEFORCE_GTX650},    /* Geforce 600 - lowend */
1424     {"GT 650M",                     CARD_NVIDIA_GEFORCE_GT650M},    /* Geforce 600 - midend mobile */
1425     {"GT 640M",                     CARD_NVIDIA_GEFORCE_GT640M},    /* Geforce 600 - midend mobile */
1426     {"GT 630M",                     CARD_NVIDIA_GEFORCE_GT630M},    /* Geforce 600 - midend mobile */
1427     {"GT 630",                      CARD_NVIDIA_GEFORCE_GT630},     /* Geforce 600 - lowend */
1428     {"GT 610",                      CARD_NVIDIA_GEFORCE_GT610},     /* Geforce 600 - lowend */
1429     {"GTX 580",                     CARD_NVIDIA_GEFORCE_GTX580},    /* Geforce 500 - highend */
1430     {"GTX 570",                     CARD_NVIDIA_GEFORCE_GTX570},    /* Geforce 500 - midend high */
1431     {"GTX 560 Ti",                  CARD_NVIDIA_GEFORCE_GTX560TI},  /* Geforce 500 - midend */
1432     {"GTX 560M",                    CARD_NVIDIA_GEFORCE_GTX560M},   /* Geforce 500 - midend mobile */
1433     {"GTX 560",                     CARD_NVIDIA_GEFORCE_GTX560},    /* Geforce 500 - midend */
1434     {"GT 555M",                     CARD_NVIDIA_GEFORCE_GT555M},    /* Geforce 500 - midend mobile */
1435     {"GTX 550 Ti",                  CARD_NVIDIA_GEFORCE_GTX550},    /* Geforce 500 - midend */
1436     {"GT 540M",                     CARD_NVIDIA_GEFORCE_GT540M},    /* Geforce 500 - midend mobile */
1437     {"GT 525M",                     CARD_NVIDIA_GEFORCE_GT525M},    /* Geforce 500 - lowend mobile */
1438     {"GT 520",                      CARD_NVIDIA_GEFORCE_GT520},     /* Geforce 500 - lowend */
1439     {"GTX 480",                     CARD_NVIDIA_GEFORCE_GTX480},    /* Geforce 400 - highend */
1440     {"GTX 470",                     CARD_NVIDIA_GEFORCE_GTX470},    /* Geforce 400 - midend high */
1441     /* Direct 3D 10 */
1442     {"GTX 465",                     CARD_NVIDIA_GEFORCE_GTX465},    /* Geforce 400 - midend */
1443     {"GTX 460M",                    CARD_NVIDIA_GEFORCE_GTX460M},   /* Geforce 400 - highend mobile */
1444     {"GTX 460",                     CARD_NVIDIA_GEFORCE_GTX460},    /* Geforce 400 - midend */
1445     {"GTS 450",                     CARD_NVIDIA_GEFORCE_GTS450},    /* Geforce 400 - midend low */
1446     {"GT 440",                      CARD_NVIDIA_GEFORCE_GT440},     /* Geforce 400 - lowend */
1447     {"GT 430",                      CARD_NVIDIA_GEFORCE_GT430},     /* Geforce 400 - lowend */
1448     {"GT 425M",                     CARD_NVIDIA_GEFORCE_GT425M},    /* Geforce 400 - lowend mobile */
1449     {"GT 420",                      CARD_NVIDIA_GEFORCE_GT420},     /* Geforce 400 - lowend */
1450     {"410M",                        CARD_NVIDIA_GEFORCE_410M},      /* Geforce 400 - lowend mobile */
1451     {"GT 330",                      CARD_NVIDIA_GEFORCE_GT330},     /* Geforce 300 - highend */
1452     {"GTS 360M",                    CARD_NVIDIA_GEFORCE_GTS350M},   /* Geforce 300 - highend mobile */
1453     {"GTS 350M",                    CARD_NVIDIA_GEFORCE_GTS350M},   /* Geforce 300 - highend mobile */
1454     {"GT 330M",                     CARD_NVIDIA_GEFORCE_GT325M},    /* Geforce 300 - midend mobile */
1455     {"GT 325M",                     CARD_NVIDIA_GEFORCE_GT325M},    /* Geforce 300 - midend mobile */
1456     {"GT 320M",                     CARD_NVIDIA_GEFORCE_GT320M},    /* Geforce 300 - midend mobile */
1457     {"320M",                        CARD_NVIDIA_GEFORCE_320M},      /* Geforce 300 - midend mobile */
1458     {"315M",                        CARD_NVIDIA_GEFORCE_315M},      /* Geforce 300 - midend mobile */
1459     {"GTX 295",                     CARD_NVIDIA_GEFORCE_GTX280},    /* Geforce 200 - highend */
1460     {"GTX 285",                     CARD_NVIDIA_GEFORCE_GTX280},    /* Geforce 200 - highend */
1461     {"GTX 280",                     CARD_NVIDIA_GEFORCE_GTX280},    /* Geforce 200 - highend */
1462     {"GTX 275",                     CARD_NVIDIA_GEFORCE_GTX275},    /* Geforce 200 - midend high */
1463     {"GTX 260",                     CARD_NVIDIA_GEFORCE_GTX260},    /* Geforce 200 - midend */
1464     {"GTS 250",                     CARD_NVIDIA_GEFORCE_GTS250},    /* Geforce 200 - midend */
1465     {"GT 240",                      CARD_NVIDIA_GEFORCE_GT240},     /* Geforce 200 - midend */
1466     {"GT 220",                      CARD_NVIDIA_GEFORCE_GT220},     /* Geforce 200 - lowend */
1467     {"GeForce 310",                 CARD_NVIDIA_GEFORCE_210},       /* Geforce 200 - lowend */
1468     {"GeForce 305",                 CARD_NVIDIA_GEFORCE_210},       /* Geforce 200 - lowend */
1469     {"GeForce 210",                 CARD_NVIDIA_GEFORCE_210},       /* Geforce 200 - lowend */
1470     {"G 210",                       CARD_NVIDIA_GEFORCE_210},       /* Geforce 200 - lowend */
1471     {"GTS 150",                     CARD_NVIDIA_GEFORCE_9800GT},    /* Geforce 9 - highend / Geforce 200 - midend */
1472     {"9800",                        CARD_NVIDIA_GEFORCE_9800GT},    /* Geforce 9 - highend / Geforce 200 - midend */
1473     {"9700M GT",                    CARD_NVIDIA_GEFORCE_9700MGT},   /* Geforce 9 - midend */
1474     {"GT 140",                      CARD_NVIDIA_GEFORCE_9600GT},    /* Geforce 9 - midend */
1475     {"9600",                        CARD_NVIDIA_GEFORCE_9600GT},    /* Geforce 9 - midend */
1476     {"GT 130",                      CARD_NVIDIA_GEFORCE_9500GT},    /* Geforce 9 - midend low / Geforce 200 - low */
1477     {"GT 120",                      CARD_NVIDIA_GEFORCE_9500GT},    /* Geforce 9 - midend low / Geforce 200 - low */
1478     {"9500",                        CARD_NVIDIA_GEFORCE_9500GT},    /* Geforce 9 - midend low / Geforce 200 - low */
1479     {"9400M",                       CARD_NVIDIA_GEFORCE_9400M},     /* Geforce 9 - lowend */
1480     {"9400",                        CARD_NVIDIA_GEFORCE_9400GT},    /* Geforce 9 - lowend */
1481     {"9300",                        CARD_NVIDIA_GEFORCE_9300},      /* Geforce 9 - lowend low */
1482     {"9200",                        CARD_NVIDIA_GEFORCE_9200},      /* Geforce 9 - lowend low */
1483     {"9100",                        CARD_NVIDIA_GEFORCE_9200},      /* Geforce 9 - lowend low */
1484     {"G 100",                       CARD_NVIDIA_GEFORCE_9200},      /* Geforce 9 - lowend low */
1485     {"8800 GTX",                    CARD_NVIDIA_GEFORCE_8800GTX},   /* Geforce 8 - highend high */
1486     {"8800",                        CARD_NVIDIA_GEFORCE_8800GTS},   /* Geforce 8 - highend */
1487     {"8600M",                       CARD_NVIDIA_GEFORCE_8600MGT},   /* Geforce 8 - midend mobile */
1488     {"8600 M",                      CARD_NVIDIA_GEFORCE_8600MGT},   /* Geforce 8 - midend mobile */
1489     {"8700",                        CARD_NVIDIA_GEFORCE_8600GT},    /* Geforce 8 - midend */
1490     {"8600",                        CARD_NVIDIA_GEFORCE_8600GT},    /* Geforce 8 - midend */
1491     {"8500",                        CARD_NVIDIA_GEFORCE_8500GT},    /* Geforce 8 - mid-lowend */
1492     {"8400",                        CARD_NVIDIA_GEFORCE_8400GS},    /* Geforce 8 - mid-lowend */
1493     {"8300",                        CARD_NVIDIA_GEFORCE_8300GS},    /* Geforce 8 - lowend */
1494     {"8200",                        CARD_NVIDIA_GEFORCE_8200},      /* Geforce 8 - lowend */
1495     {"8100",                        CARD_NVIDIA_GEFORCE_8200},      /* Geforce 8 - lowend */
1496     /* Direct 3D 9 SM3 */
1497     {"Quadro FX 5",                 CARD_NVIDIA_GEFORCE_7800GT},    /* Geforce 7 - highend */
1498     {"Quadro FX 4",                 CARD_NVIDIA_GEFORCE_7800GT},    /* Geforce 7 - highend */
1499     {"7950",                        CARD_NVIDIA_GEFORCE_7800GT},    /* Geforce 7 - highend */
1500     {"7900",                        CARD_NVIDIA_GEFORCE_7800GT},    /* Geforce 7 - highend */
1501     {"7800",                        CARD_NVIDIA_GEFORCE_7800GT},    /* Geforce 7 - highend */
1502     {"7700",                        CARD_NVIDIA_GEFORCE_7600},      /* Geforce 7 - midend */
1503     {"7600",                        CARD_NVIDIA_GEFORCE_7600},      /* Geforce 7 - midend */
1504     {"7400",                        CARD_NVIDIA_GEFORCE_7400},      /* Geforce 7 - lower medium */
1505     {"7300",                        CARD_NVIDIA_GEFORCE_7300},      /* Geforce 7 - lowend */
1506     {"6800",                        CARD_NVIDIA_GEFORCE_6800},      /* Geforce 6 - highend */
1507     {"6700",                        CARD_NVIDIA_GEFORCE_6600GT},    /* Geforce 6 - midend */
1508     {"6610",                        CARD_NVIDIA_GEFORCE_6600GT},    /* Geforce 6 - midend */
1509     {"6600",                        CARD_NVIDIA_GEFORCE_6600GT},    /* Geforce 6 - midend */
1510     /* Direct 3D 9 SM2 */
1511     {"Quadro FX",                   CARD_NVIDIA_GEFORCEFX_5800},    /* GeforceFX - highend */
1512     {"5950",                        CARD_NVIDIA_GEFORCEFX_5800},    /* GeforceFX - highend */
1513     {"5900",                        CARD_NVIDIA_GEFORCEFX_5800},    /* GeforceFX - highend */
1514     {"5800",                        CARD_NVIDIA_GEFORCEFX_5800},    /* GeforceFX - highend */
1515     {"5750",                        CARD_NVIDIA_GEFORCEFX_5600},    /* GeforceFX - midend */
1516     {"5700",                        CARD_NVIDIA_GEFORCEFX_5600},    /* GeforceFX - midend */
1517     {"5650",                        CARD_NVIDIA_GEFORCEFX_5600},    /* GeforceFX - midend */
1518     {"5600",                        CARD_NVIDIA_GEFORCEFX_5600},    /* GeforceFX - midend */
1519     {"5500",                        CARD_NVIDIA_GEFORCEFX_5200},    /* GeforceFX - lowend */
1520     {"5300",                        CARD_NVIDIA_GEFORCEFX_5200},    /* GeforceFX - lowend */
1521     {"5250",                        CARD_NVIDIA_GEFORCEFX_5200},    /* GeforceFX - lowend */
1522     {"5200",                        CARD_NVIDIA_GEFORCEFX_5200},    /* GeforceFX - lowend */
1523     {"5100",                        CARD_NVIDIA_GEFORCEFX_5200},    /* GeforceFX - lowend */
1524     /* Direct 3D 8 */
1525     {"Quadro4",                     CARD_NVIDIA_GEFORCE4_TI4200},
1526     {"GeForce4 Ti",                 CARD_NVIDIA_GEFORCE4_TI4200},   /* Geforce4 Ti4200/Ti4400/Ti4600/Ti4800 */
1527     /* Direct 3D 7 */
1528     {"GeForce4 MX",                 CARD_NVIDIA_GEFORCE4_MX},       /* MX420/MX440/MX460/MX4000 */
1529     {"Quadro2 MXR",                 CARD_NVIDIA_GEFORCE2_MX},
1530     {"GeForce2 MX",                 CARD_NVIDIA_GEFORCE2_MX},       /* Geforce2 standard/MX100/MX200/MX400 */
1531     {"Quadro2",                     CARD_NVIDIA_GEFORCE2},
1532     {"GeForce2",                    CARD_NVIDIA_GEFORCE2},          /* Geforce2 GTS/Pro/Ti/Ultra */
1533     /* Direct 3D 6 */
1534     {"TNT2",                        CARD_NVIDIA_RIVA_TNT2},         /* Riva TNT2 standard/M64/Pro/Ultra */
1535 },
1536 /* See http://developer.amd.com/resources/hardware-drivers/ati-catalyst-pc-vendor-id-1002-li/
1537  *
1538  * Beware: renderer string do not match exact card model,
1539  * e.g. HD 4800 is returned for multiple cards, even for RV790 based ones. */
1540 cards_amd_binary[] =
1541 {
1542     {"RX 480",                      CARD_AMD_RADEON_RX_480},
1543     {"RX 460",                      CARD_AMD_RADEON_RX_460},
1544     {"R9 Fury Series",              CARD_AMD_RADEON_R9_FURY},
1545     /* Southern Islands */
1546     {"HD 7900",                     CARD_AMD_RADEON_HD7900},
1547     {"HD 7800",                     CARD_AMD_RADEON_HD7800},
1548     {"HD 7700",                     CARD_AMD_RADEON_HD7700},
1549     /* Northern Islands */
1550     {"HD 6970",                     CARD_AMD_RADEON_HD6900},
1551     {"HD 6900",                     CARD_AMD_RADEON_HD6900},
1552     {"HD 6800",                     CARD_AMD_RADEON_HD6800},
1553     {"HD 6770M",                    CARD_AMD_RADEON_HD6600M},
1554     {"HD 6750M",                    CARD_AMD_RADEON_HD6600M},
1555     {"HD 6700",                     CARD_AMD_RADEON_HD6700},
1556     {"HD 6670",                     CARD_AMD_RADEON_HD6600},
1557     {"HD 6630M",                    CARD_AMD_RADEON_HD6600M},
1558     {"HD 6600M",                    CARD_AMD_RADEON_HD6600M},
1559     {"HD 6600",                     CARD_AMD_RADEON_HD6600},
1560     {"HD 6570",                     CARD_AMD_RADEON_HD6600},
1561     {"HD 6500M",                    CARD_AMD_RADEON_HD6600M},
1562     {"HD 6500",                     CARD_AMD_RADEON_HD6600},
1563     {"HD 6480G",                    CARD_AMD_RADEON_HD6480G},
1564     {"HD 6400",                     CARD_AMD_RADEON_HD6400},
1565     {"HD 6300",                     CARD_AMD_RADEON_HD6300},
1566     {"HD 6200",                     CARD_AMD_RADEON_HD6300},
1567     /* Evergreen */
1568     {"HD 5870",                     CARD_AMD_RADEON_HD5800},    /* Radeon EG CYPRESS PRO */
1569     {"HD 5850",                     CARD_AMD_RADEON_HD5800},    /* Radeon EG CYPRESS XT */
1570     {"HD 5800",                     CARD_AMD_RADEON_HD5800},    /* Radeon EG CYPRESS HD58xx generic renderer string */
1571     {"HD 5770",                     CARD_AMD_RADEON_HD5700},    /* Radeon EG JUNIPER XT */
1572     {"HD 5750",                     CARD_AMD_RADEON_HD5700},    /* Radeon EG JUNIPER LE */
1573     {"HD 5700",                     CARD_AMD_RADEON_HD5700},    /* Radeon EG JUNIPER HD57xx generic renderer string */
1574     {"HD 5670",                     CARD_AMD_RADEON_HD5600},    /* Radeon EG REDWOOD XT */
1575     {"HD 5570",                     CARD_AMD_RADEON_HD5600},    /* Radeon EG REDWOOD PRO mapped to HD5600 series */
1576     {"HD 5550",                     CARD_AMD_RADEON_HD5600},    /* Radeon EG REDWOOD LE mapped to HD5600 series */
1577     {"HD 5450",                     CARD_AMD_RADEON_HD5400},    /* Radeon EG CEDAR PRO */
1578     {"HD 5000",                     CARD_AMD_RADEON_HD5600},    /* Defaulting to HD 5600 */
1579     /* R700 */
1580     {"HD 4890",                     CARD_AMD_RADEON_HD4800},    /* Radeon RV790 */
1581     {"HD 4870",                     CARD_AMD_RADEON_HD4800},    /* Radeon RV770 */
1582     {"HD 4850",                     CARD_AMD_RADEON_HD4800},    /* Radeon RV770 */
1583     {"HD 4830",                     CARD_AMD_RADEON_HD4800},    /* Radeon RV770 */
1584     {"HD 4800",                     CARD_AMD_RADEON_HD4800},    /* Radeon RV7xx HD48xx generic renderer string */
1585     {"HD 4770",                     CARD_AMD_RADEON_HD4700},    /* Radeon RV740 */
1586     {"HD 4700",                     CARD_AMD_RADEON_HD4700},    /* Radeon RV7xx HD47xx generic renderer string */
1587     {"HD 4670",                     CARD_AMD_RADEON_HD4600},    /* Radeon RV730 */
1588     {"HD 4650",                     CARD_AMD_RADEON_HD4600},    /* Radeon RV730 */
1589     {"HD 4600",                     CARD_AMD_RADEON_HD4600},    /* Radeon RV730 */
1590     {"HD 4550",                     CARD_AMD_RADEON_HD4350},    /* Radeon RV710 */
1591     {"HD 4350",                     CARD_AMD_RADEON_HD4350},    /* Radeon RV710 */
1592     /* R600/R700 integrated */
1593     {"HD 4200M",                    CARD_AMD_RADEON_HD4200M},
1594     {"HD 3300",                     CARD_AMD_RADEON_HD3200},
1595     {"HD 3200",                     CARD_AMD_RADEON_HD3200},
1596     {"HD 3100",                     CARD_AMD_RADEON_HD3200},
1597     /* R600 */
1598     {"HD 3870",                     CARD_AMD_RADEON_HD2900},    /* HD2900/HD3800 - highend */
1599     {"HD 3850",                     CARD_AMD_RADEON_HD2900},    /* HD2900/HD3800 - highend */
1600     {"HD 2900",                     CARD_AMD_RADEON_HD2900},    /* HD2900/HD3800 - highend */
1601     {"HD 3830",                     CARD_AMD_RADEON_HD2600},    /* China-only midend */
1602     {"HD 3690",                     CARD_AMD_RADEON_HD2600},    /* HD2600/HD3600 - midend */
1603     {"HD 3650",                     CARD_AMD_RADEON_HD2600},    /* HD2600/HD3600 - midend */
1604     {"HD 2600",                     CARD_AMD_RADEON_HD2600},    /* HD2600/HD3600 - midend */
1605     {"HD 3470",                     CARD_AMD_RADEON_HD2350},    /* HD2350/HD2400/HD3400 - lowend */
1606     {"HD 3450",                     CARD_AMD_RADEON_HD2350},    /* HD2350/HD2400/HD3400 - lowend */
1607     {"HD 3430",                     CARD_AMD_RADEON_HD2350},    /* HD2350/HD2400/HD3400 - lowend */
1608     {"HD 3400",                     CARD_AMD_RADEON_HD2350},    /* HD2350/HD2400/HD3400 - lowend */
1609     {"HD 2400",                     CARD_AMD_RADEON_HD2350},    /* HD2350/HD2400/HD3400 - lowend */
1610     {"HD 2350",                     CARD_AMD_RADEON_HD2350},    /* HD2350/HD2400/HD3400 - lowend */
1611     /* Radeon R5xx */
1612     {"X1950",                       CARD_AMD_RADEON_X1600},
1613     {"X1900",                       CARD_AMD_RADEON_X1600},
1614     {"X1800",                       CARD_AMD_RADEON_X1600},
1615     {"X1650",                       CARD_AMD_RADEON_X1600},
1616     {"X1600",                       CARD_AMD_RADEON_X1600},
1617     /* Radeon R4xx + X1300/X1400/X1450/X1550/X2300/X2500/HD2300 (lowend R5xx)
1618      * Note X2300/X2500/HD2300 are R5xx GPUs with a 2xxx naming but they are still DX9-only */
1619     {"HD 2300",                     CARD_AMD_RADEON_X700},
1620     {"X2500",                       CARD_AMD_RADEON_X700},
1621     {"X2300",                       CARD_AMD_RADEON_X700},
1622     {"X1550",                       CARD_AMD_RADEON_X700},
1623     {"X1450",                       CARD_AMD_RADEON_X700},
1624     {"X1400",                       CARD_AMD_RADEON_X700},
1625     {"X1300",                       CARD_AMD_RADEON_X700},
1626     {"X850",                        CARD_AMD_RADEON_X700},
1627     {"X800",                        CARD_AMD_RADEON_X700},
1628     {"X700",                        CARD_AMD_RADEON_X700},
1629     /* Radeon Xpress Series - onboard, DX9b, Shader 2.0, 300-400 MHz */
1630     {"Radeon Xpress",               CARD_AMD_RADEON_XPRESS_200M},
1631 },
1632 cards_intel[] =
1633 {
1634     /* Skylake */
1635     {"Iris Pro Graphics P580",      CARD_INTEL_IPP580_1},
1636     {"Skylake",                     CARD_INTEL_HD520_1},
1637     /* Broadwell */
1638     {"Iris Pro P6300",              CARD_INTEL_IPP6300},
1639     {"Iris Pro 6200",               CARD_INTEL_IP6200},
1640     {"Iris 6100",                   CARD_INTEL_I6100},
1641     {"Iris(TM) Graphics 6100",      CARD_INTEL_I6100},  /* MacOS */
1642     /* Haswell */
1643     {"Iris Pro 5200",               CARD_INTEL_IP5200_1},
1644     {"Iris 5100",                   CARD_INTEL_I5100_1},
1645     {"HD Graphics 5000",            CARD_INTEL_HD5000_1}, /* MacOS */
1646     {"Haswell Mobile",              CARD_INTEL_HWM},
1647     {"Iris OpenGL Engine",          CARD_INTEL_HWM},    /* MacOS */
1648     /* Ivybridge */
1649     {"Ivybridge Server",            CARD_INTEL_IVBS},
1650     {"Ivybridge Mobile",            CARD_INTEL_IVBM},
1651     {"Ivybridge Desktop",           CARD_INTEL_IVBD},
1652     {"HD Graphics 4000",            CARD_INTEL_IVBD},   /* MacOS */
1653     /* Sandybridge */
1654     {"Sandybridge Server",          CARD_INTEL_SNBS},
1655     {"Sandybridge Mobile",          CARD_INTEL_SNBM},
1656     {"Sandybridge Desktop",         CARD_INTEL_SNBD},
1657     /* Ironlake */
1658     {"Ironlake Mobile",             CARD_INTEL_ILKM},
1659     {"Ironlake Desktop",            CARD_INTEL_ILKD},
1660     /* G4x */
1661     {"B43",                         CARD_INTEL_B43},
1662     {"G41",                         CARD_INTEL_G41},
1663     {"G45",                         CARD_INTEL_G45},
1664     {"Q45",                         CARD_INTEL_Q45},
1665     {"Integrated Graphics Device",  CARD_INTEL_IGD},
1666     {"GM45",                        CARD_INTEL_GM45},
1667     /* i965 */
1668     {"965GME",                      CARD_INTEL_965GME},
1669     {"965GM",                       CARD_INTEL_965GM},
1670     {"X3100",                       CARD_INTEL_965GM},  /* MacOS */
1671     {"946GZ",                       CARD_INTEL_946GZ},
1672     {"965G",                        CARD_INTEL_965G},
1673     {"965Q",                        CARD_INTEL_965Q},
1674     /* i945 */
1675     {"Pineview M",                  CARD_INTEL_PNVM},
1676     {"Pineview G",                  CARD_INTEL_PNVG},
1677     {"IGD",                         CARD_INTEL_PNVG},
1678     {"Q33",                         CARD_INTEL_Q33},
1679     {"G33",                         CARD_INTEL_G33},
1680     {"Q35",                         CARD_INTEL_Q35},
1681     {"945GME",                      CARD_INTEL_945GME},
1682     {"945GM",                       CARD_INTEL_945GM},
1683     {"GMA 950",                     CARD_INTEL_945GM},  /* MacOS */
1684     {"945G",                        CARD_INTEL_945G},
1685     /* i915 */
1686     {"915GM",                       CARD_INTEL_915GM},
1687     {"E7221G",                      CARD_INTEL_E7221G},
1688     {"915G",                        CARD_INTEL_915G},
1689     /* i8xx */
1690     {"865G",                        CARD_INTEL_865G},
1691     {"845G",                        CARD_INTEL_845G},
1692     {"855GM",                       CARD_INTEL_855GM},
1693     {"830M",                        CARD_INTEL_830M},
1694 },
1695 /* 20101109 - These are never returned by current Gallium radeon
1696  * drivers: R700, RV790, R680, RV535, RV516, R410, RS485, RV360, RV351. */
1697 cards_amd_mesa[] =
1698 {
1699     /* Navi 10 */
1700     {"NAVI10",                      CARD_AMD_RADEON_RX_NAVI_10},
1701     /* Polaris 10/11 */
1702     {"POLARIS10",                   CARD_AMD_RADEON_RX_480},
1703     {"POLARIS11",                   CARD_AMD_RADEON_RX_460},
1704     /* Volcanic Islands */
1705     {"FIJI",                        CARD_AMD_RADEON_R9_FURY},
1706     {"TONGA",                       CARD_AMD_RADEON_R9_285},
1707     /* Sea Islands */
1708     {"HAWAII",                      CARD_AMD_RADEON_R9_290},
1709     {"KAVERI",                      CARD_AMD_RADEON_R7    },
1710     {"KABINI",                      CARD_AMD_RADEON_R3    },
1711     {"BONAIRE",                     CARD_AMD_RADEON_HD8770},
1712     /* Southern Islands */
1713     {"OLAND",                       CARD_AMD_RADEON_HD8670},
1714     {"HAINAN",                      CARD_AMD_RADEON_HD8600M},
1715     {"TAHITI",                      CARD_AMD_RADEON_HD7900},
1716     {"PITCAIRN",                    CARD_AMD_RADEON_HD7800},
1717     {"CAPE VERDE",                  CARD_AMD_RADEON_HD7700},
1718     /* Northern Islands */
1719     {"ARUBA",                       CARD_AMD_RADEON_HD7660D},
1720     {"CAYMAN",                      CARD_AMD_RADEON_HD6900},
1721     {"BARTS",                       CARD_AMD_RADEON_HD6800},
1722     {"TURKS",                       CARD_AMD_RADEON_HD6600},
1723     {"SUMO2",                       CARD_AMD_RADEON_HD6410D},   /* SUMO2 first, because we do a strstr(). */
1724     {"SUMO",                        CARD_AMD_RADEON_HD6550D},
1725     {"CAICOS",                      CARD_AMD_RADEON_HD6400},
1726     {"PALM",                        CARD_AMD_RADEON_HD6300},
1727     /* Evergreen */
1728     {"HEMLOCK",                     CARD_AMD_RADEON_HD5900},
1729     {"CYPRESS",                     CARD_AMD_RADEON_HD5800},
1730     {"JUNIPER",                     CARD_AMD_RADEON_HD5700},
1731     {"REDWOOD",                     CARD_AMD_RADEON_HD5600},
1732     {"CEDAR",                       CARD_AMD_RADEON_HD5400},
1733     /* R700 */
1734     {"R700",                        CARD_AMD_RADEON_HD4800},
1735     {"RV790",                       CARD_AMD_RADEON_HD4800},
1736     {"RV770",                       CARD_AMD_RADEON_HD4800},
1737     {"RV740",                       CARD_AMD_RADEON_HD4700},
1738     {"RV730",                       CARD_AMD_RADEON_HD4600},
1739     {"RV710",                       CARD_AMD_RADEON_HD4350},
1740     /* R600/R700 integrated */
1741     {"RS880",                       CARD_AMD_RADEON_HD4200M},
1742     {"RS780",                       CARD_AMD_RADEON_HD3200},
1743     /* R600 */
1744     {"R680",                        CARD_AMD_RADEON_HD2900},
1745     {"R600",                        CARD_AMD_RADEON_HD2900},
1746     {"RV670",                       CARD_AMD_RADEON_HD3850},
1747     {"RV635",                       CARD_AMD_RADEON_HD2600},
1748     {"RV630",                       CARD_AMD_RADEON_HD2600},
1749     {"RV620",                       CARD_AMD_RADEON_HD2350},
1750     {"RV610",                       CARD_AMD_RADEON_HD2350},
1751     /* R500 */
1752     {"R580",                        CARD_AMD_RADEON_X1600},
1753     {"R520",                        CARD_AMD_RADEON_X1600},
1754     {"RV570",                       CARD_AMD_RADEON_X1600},
1755     {"RV560",                       CARD_AMD_RADEON_X1600},
1756     {"RV535",                       CARD_AMD_RADEON_X1600},
1757     {"RV530",                       CARD_AMD_RADEON_X1600},
1758     {"RV516",                       CARD_AMD_RADEON_X700},
1759     {"RV515",                       CARD_AMD_RADEON_X700},
1760     /* R400 */
1761     {"R481",                        CARD_AMD_RADEON_X700},
1762     {"R480",                        CARD_AMD_RADEON_X700},
1763     {"R430",                        CARD_AMD_RADEON_X700},
1764     {"R423",                        CARD_AMD_RADEON_X700},
1765     {"R420",                        CARD_AMD_RADEON_X700},
1766     {"R410",                        CARD_AMD_RADEON_X700},
1767     {"RV410",                       CARD_AMD_RADEON_X700},
1768     /* Radeon Xpress - onboard, DX9b, Shader 2.0, 300-400 MHz */
1769     {"RS740",                       CARD_AMD_RADEON_XPRESS_200M},
1770     {"RS690",                       CARD_AMD_RADEON_XPRESS_200M},
1771     {"RS600",                       CARD_AMD_RADEON_XPRESS_200M},
1772     {"RS485",                       CARD_AMD_RADEON_XPRESS_200M},
1773     {"RS482",                       CARD_AMD_RADEON_XPRESS_200M},
1774     {"RS480",                       CARD_AMD_RADEON_XPRESS_200M},
1775     {"RS400",                       CARD_AMD_RADEON_XPRESS_200M},
1776     {"RC410",                       CARD_AMD_RADEON_XPRESS_200M},
1777     /* R300 */
1778     {"R360",                        CARD_AMD_RADEON_9500},
1779     {"R350",                        CARD_AMD_RADEON_9500},
1780     {"R300",                        CARD_AMD_RADEON_9500},
1781     {"RV380",                       CARD_AMD_RADEON_9500},
1782     {"RV370",                       CARD_AMD_RADEON_9500},
1783     {"RV360",                       CARD_AMD_RADEON_9500},
1784     {"RV351",                       CARD_AMD_RADEON_9500},
1785     {"RV350",                       CARD_AMD_RADEON_9500},
1786 },
1787 cards_nvidia_mesa[] =
1788 {
1789     /* Maxwell */
1790     {"NV124",                       CARD_NVIDIA_GEFORCE_GTX970},
1791     {"NV120",                       CARD_NVIDIA_GEFORCE_GTX980TI},
1792     {"NV118",                       CARD_NVIDIA_GEFORCE_840M},
1793     {"NV117",                       CARD_NVIDIA_GEFORCE_GTX750},
1794     /* Kepler */
1795     {"NV108",                       CARD_NVIDIA_GEFORCE_GT740M},
1796     {"NV106",                       CARD_NVIDIA_GEFORCE_GT720},
1797     {"NVF1",                        CARD_NVIDIA_GEFORCE_GTX780TI},
1798     {"NVF0",                        CARD_NVIDIA_GEFORCE_GTX780},
1799     {"NVE6",                        CARD_NVIDIA_GEFORCE_GTX770M},
1800     {"NVE4",                        CARD_NVIDIA_GEFORCE_GTX680},    /* 690 / 675MX / 760TI */
1801     /* Fermi */
1802     {"NVD9",                        CARD_NVIDIA_GEFORCE_GT520},
1803     {"NVD7",                        CARD_NVIDIA_GEFORCE_820M},
1804     {"NVCF",                        CARD_NVIDIA_GEFORCE_GTX550},
1805     {"NVCE",                        CARD_NVIDIA_GEFORCE_GTX560},
1806     {"NVC8",                        CARD_NVIDIA_GEFORCE_GTX570},
1807     {"NVC4",                        CARD_NVIDIA_GEFORCE_GTX460},
1808     {"NVC3",                        CARD_NVIDIA_GEFORCE_GT440},
1809     {"NVC1",                        CARD_NVIDIA_GEFORCE_GT420},
1810     {"NVC0",                        CARD_NVIDIA_GEFORCE_GTX480},
1811     /* Tesla */
1812     {"NVAF",                        CARD_NVIDIA_GEFORCE_GT320M},
1813     {"NVAC",                        CARD_NVIDIA_GEFORCE_8200},
1814     {"NVAA",                        CARD_NVIDIA_GEFORCE_8200},      /* 8100 */
1815     {"NVA8",                        CARD_NVIDIA_GEFORCE_210},
1816     {"NVA5",                        CARD_NVIDIA_GEFORCE_GT220},
1817     {"NVA3",                        CARD_NVIDIA_GEFORCE_GT240},
1818     {"NVA0",                        CARD_NVIDIA_GEFORCE_GTX280},
1819     {"NV98",                        CARD_NVIDIA_GEFORCE_9200},
1820     {"NV96",                        CARD_NVIDIA_GEFORCE_9400GT},
1821     {"NV94",                        CARD_NVIDIA_GEFORCE_9600GT},
1822     {"NV92",                        CARD_NVIDIA_GEFORCE_9800GT},
1823     {"NV86",                        CARD_NVIDIA_GEFORCE_8500GT},
1824     {"NV84",                        CARD_NVIDIA_GEFORCE_8600GT},
1825     {"NV50",                        CARD_NVIDIA_GEFORCE_8800GTX},
1826     /* Curie */
1827     {"NV68",                        CARD_NVIDIA_GEFORCE_6200},      /* 7050 */
1828     {"NV67",                        CARD_NVIDIA_GEFORCE_6200},      /* 7000M */
1829     {"NV63",                        CARD_NVIDIA_GEFORCE_6200},      /* 7100 */
1830     {"NV4E",                        CARD_NVIDIA_GEFORCE_6200},      /* 6100 Go / 6150 Go */
1831     {"NV4C",                        CARD_NVIDIA_GEFORCE_6200},      /* 6150SE */
1832     {"NV4B",                        CARD_NVIDIA_GEFORCE_7600},
1833     {"NV4A",                        CARD_NVIDIA_GEFORCE_6200},
1834     {"NV49",                        CARD_NVIDIA_GEFORCE_7800GT},    /* 7900 */
1835     {"NV47",                        CARD_NVIDIA_GEFORCE_7800GT},
1836     {"NV46",                        CARD_NVIDIA_GEFORCE_7400},
1837     {"NV45",                        CARD_NVIDIA_GEFORCE_6800},
1838     {"NV44",                        CARD_NVIDIA_GEFORCE_6200},
1839     {"NV43",                        CARD_NVIDIA_GEFORCE_6600GT},
1840     {"NV42",                        CARD_NVIDIA_GEFORCE_6800},
1841     {"NV41",                        CARD_NVIDIA_GEFORCE_6800},
1842     {"NV40",                        CARD_NVIDIA_GEFORCE_6800},
1843     /* Rankine */
1844     {"NV38",                        CARD_NVIDIA_GEFORCEFX_5800},    /* FX 5950 Ultra */
1845     {"NV36",                        CARD_NVIDIA_GEFORCEFX_5800},    /* FX 5700/5750 */
1846     {"NV35",                        CARD_NVIDIA_GEFORCEFX_5800},    /* FX 5900 */
1847     {"NV34",                        CARD_NVIDIA_GEFORCEFX_5200},
1848     {"NV31",                        CARD_NVIDIA_GEFORCEFX_5600},
1849     {"NV30",                        CARD_NVIDIA_GEFORCEFX_5800},
1850     /* Kelvin */
1851     {"nv28",                        CARD_NVIDIA_GEFORCE4_TI4200},
1852     {"nv25",                        CARD_NVIDIA_GEFORCE4_TI4200},
1853     {"nv20",                        CARD_NVIDIA_GEFORCE3},
1854     /* Celsius */
1855     {"nv1F",                        CARD_NVIDIA_GEFORCE4_MX},       /* GF4 MX IGP */
1856     {"nv1A",                        CARD_NVIDIA_GEFORCE2},          /* GF2 IGP */
1857     {"nv18",                        CARD_NVIDIA_GEFORCE4_MX},
1858     {"nv17",                        CARD_NVIDIA_GEFORCE4_MX},
1859     {"nv16",                        CARD_NVIDIA_GEFORCE2},
1860     {"nv15",                        CARD_NVIDIA_GEFORCE2},
1861     {"nv11",                        CARD_NVIDIA_GEFORCE2_MX},
1862     {"nv10",                        CARD_NVIDIA_GEFORCE},
1863     /* Fahrenheit */
1864     {"nv05",                        CARD_NVIDIA_RIVA_TNT2},
1865     {"nv04",                        CARD_NVIDIA_RIVA_TNT},
1866     {"nv03",                        CARD_NVIDIA_RIVA_128},
1867 },
1868 cards_redhat[] =
1869 {
1870     {"virgl",                       CARD_REDHAT_VIRGL},
1871 },
1872 cards_vmware[] =
1873 {
1874     {"SVGA3D",                      CARD_VMWARE_SVGA3D},
1875 };
1876
1877 static const struct gl_vendor_selection
1878 {
1879     enum wined3d_gl_vendor gl_vendor;
1880     const char *description;        /* Description of the card selector i.e. Apple OS/X Intel */
1881     const struct wined3d_renderer_table *cards; /* To be used as cards[], pointer to the first member in an array */
1882     size_t cards_size;              /* Number of entries in the array above */
1883 }
1884 amd_gl_vendor_table[] =
1885 {
1886     {GL_VENDOR_APPLE,   "Apple OSX AMD/ATI binary driver",  cards_amd_binary,       ARRAY_SIZE(cards_amd_binary)},
1887     {GL_VENDOR_FGLRX,   "AMD/ATI binary driver",            cards_amd_binary,       ARRAY_SIZE(cards_amd_binary)},
1888     {GL_VENDOR_MESA,    "Mesa AMD/ATI driver",              cards_amd_mesa,         ARRAY_SIZE(cards_amd_mesa)},
1889 },
1890 nvidia_gl_vendor_table[] =
1891 {
1892     {GL_VENDOR_APPLE,   "Apple OSX NVidia binary driver",   cards_nvidia_binary,    ARRAY_SIZE(cards_nvidia_binary)},
1893     {GL_VENDOR_MESA,    "Mesa Nouveau driver",              cards_nvidia_mesa,      ARRAY_SIZE(cards_nvidia_mesa)},
1894     {GL_VENDOR_NVIDIA,  "NVIDIA binary driver",             cards_nvidia_binary,    ARRAY_SIZE(cards_nvidia_binary)},
1895 },
1896 redhat_gl_vendor_table[] =
1897 {
1898     {GL_VENDOR_MESA,    "Red Hat driver",                   cards_redhat,           ARRAY_SIZE(cards_redhat)},
1899 },
1900 vmware_gl_vendor_table[] =
1901 {
1902     {GL_VENDOR_MESA,    "VMware driver",                    cards_vmware,           ARRAY_SIZE(cards_vmware)},
1903 },
1904 intel_gl_vendor_table[] =
1905 {
1906     {GL_VENDOR_APPLE,   "Apple OSX Intel binary driver",    cards_intel,            ARRAY_SIZE(cards_intel)},
1907     {GL_VENDOR_MESA,    "Mesa Intel driver",                cards_intel,            ARRAY_SIZE(cards_intel)},
1908 };
1909
1910 static enum wined3d_pci_device select_card_handler(const struct gl_vendor_selection *table,
1911         unsigned int table_size, enum wined3d_gl_vendor gl_vendor, const char *gl_renderer)
1912 {
1913     unsigned int i, j;
1914
1915     for (i = 0; i < table_size; ++i)
1916     {
1917         if (table[i].gl_vendor != gl_vendor)
1918             continue;
1919
1920         TRACE("Applying card selector \"%s\".\n", table[i].description);
1921
1922         for (j = 0; j < table[i].cards_size; ++j)
1923         {
1924             if (strstr(gl_renderer, table[i].cards[j].renderer))
1925                 return table[i].cards[j].id;
1926         }
1927         return PCI_DEVICE_NONE;
1928     }
1929     FIXME("Couldn't find a suitable card selector for GL vendor %04x (using GL_RENDERER %s)\n",
1930             gl_vendor, debugstr_a(gl_renderer));
1931
1932     return PCI_DEVICE_NONE;
1933 }
1934
1935 static const struct
1936 {
1937     enum wined3d_pci_vendor card_vendor;
1938     const char *description;        /* Description of the card selector i.e. Apple OS/X Intel */
1939     const struct gl_vendor_selection *gl_vendor_selection;
1940     unsigned int gl_vendor_count;
1941 }
1942 card_vendor_table[] =
1943 {
1944     {HW_VENDOR_AMD,    "AMD",    amd_gl_vendor_table,    ARRAY_SIZE(amd_gl_vendor_table)},
1945     {HW_VENDOR_NVIDIA, "NVIDIA", nvidia_gl_vendor_table, ARRAY_SIZE(nvidia_gl_vendor_table)},
1946     {HW_VENDOR_REDHAT, "Red Hat",redhat_gl_vendor_table, ARRAY_SIZE(redhat_gl_vendor_table)},
1947     {HW_VENDOR_VMWARE, "VMware", vmware_gl_vendor_table, ARRAY_SIZE(vmware_gl_vendor_table)},
1948     {HW_VENDOR_INTEL,  "Intel",  intel_gl_vendor_table,  ARRAY_SIZE(intel_gl_vendor_table)},
1949 };
1950
1951 static enum wined3d_pci_device wined3d_guess_card(enum wined3d_feature_level feature_level,
1952         const char *gl_renderer, enum wined3d_gl_vendor *gl_vendor,
1953         enum wined3d_pci_vendor *card_vendor)
1954 {
1955     /* A Direct3D device object contains the PCI id (vendor + device) of the
1956      * videocard which is used for rendering. Various applications use this
1957      * information to get a rough estimation of the features of the card and
1958      * some might use it for enabling 3d effects only on certain types of
1959      * videocards. In some cases games might even use it to work around bugs
1960      * which happen on certain videocards/driver combinations. The problem is
1961      * that OpenGL only exposes a rendering string containing the name of the
1962      * videocard and not the PCI id.
1963      *
1964      * Various games depend on the PCI id, so somehow we need to provide one.
1965      * A simple option is to parse the renderer string and translate this to
1966      * the right PCI id. This is a lot of work because there are more than 200
1967      * GPUs just for NVIDIA. Various cards share the same renderer string, so
1968      * the amount of code might be 'small' but there are quite a number of
1969      * exceptions which would make this a pain to maintain. Another way would
1970      * be to query the PCI id from the operating system (assuming this is the
1971      * videocard which is used for rendering which is not always the case).
1972      * This would work but it is not very portable. Second it would not work
1973      * well in, let's say, a remote X situation in which the amount of 3d
1974      * features which can be used is limited.
1975      *
1976      * As said most games only use the PCI id to get an indication of the
1977      * capabilities of the card. It doesn't really matter if the given id is
1978      * the correct one if we return the id of a card with similar 3d features.
1979      *
1980      * The code below checks the OpenGL capabilities of a videocard and matches
1981      * that to a certain level of Direct3D functionality. Once a card passes
1982      * the Direct3D9 check, we know that the card (in case of NVIDIA) is at
1983      * least a GeforceFX. To give a better estimate we do a basic check on the
1984      * renderer string but if that won't pass we return a default card. This
1985      * way is better than maintaining a full card database as even without a
1986      * full database we can return a card with similar features. Second the
1987      * size of the database can be made quite small because when you know what
1988      * type of 3d functionality a card has, you know to which GPU family the
1989      * GPU must belong. Because of this you only have to check a small part of
1990      * the renderer string to distinguish between different models from that
1991      * family.
1992      *
1993      * The code also selects a default amount of video memory which we will
1994      * use for an estimation of the amount of free texture memory. In case of
1995      * real D3D the amount of texture memory includes video memory and system
1996      * memory (to be specific AGP memory or in case of PCIE TurboCache /
1997      * HyperMemory). We don't know how much system memory can be addressed by
1998      * the system but we can make a reasonable estimation about the amount of
1999      * video memory. If the value is slightly wrong it doesn't matter as we
2000      * didn't include AGP-like memory which makes the amount of addressable
2001      * memory higher and second OpenGL isn't that critical it moves to system
2002      * memory behind our backs if really needed. Note that the amount of video
2003      * memory can be overruled using a registry setting. */
2004
2005     enum wined3d_pci_device device;
2006     unsigned int i;
2007
2008     for (i = 0; i < ARRAY_SIZE(card_vendor_table); ++i)
2009     {
2010         if (card_vendor_table[i].card_vendor != *card_vendor)
2011             continue;
2012
2013         TRACE("Applying card selector \"%s\".\n", card_vendor_table[i].description);
2014         device = select_card_handler(card_vendor_table[i].gl_vendor_selection,
2015                 card_vendor_table[i].gl_vendor_count, *gl_vendor, gl_renderer);
2016         if (device != PCI_DEVICE_NONE)
2017             return device;
2018
2019         TRACE("Unrecognized renderer %s, falling back to default.\n", debugstr_a(gl_renderer));
2020
2021         return wined3d_gpu_from_feature_level(card_vendor, feature_level);
2022     }
2023
2024     FIXME("No card selector available for card vendor %04x (using GL_RENDERER %s).\n",
2025             *card_vendor, debugstr_a(gl_renderer));
2026
2027     return wined3d_gpu_from_feature_level(card_vendor, feature_level);
2028 }
2029
2030 static const struct wined3d_vertex_pipe_ops *select_vertex_implementation(const struct wined3d_gl_info *gl_info,
2031         const struct wined3d_shader_backend_ops *shader_backend_ops)
2032 {
2033     if (shader_backend_ops == &glsl_shader_backend && gl_info->supported[ARB_VERTEX_SHADER])
2034         return &glsl_vertex_pipe;
2035     return &ffp_vertex_pipe;
2036 }
2037
2038 static const struct wined3d_fragment_pipe_ops *select_fragment_implementation(const struct wined3d_gl_info *gl_info,
2039         const struct wined3d_shader_backend_ops *shader_backend_ops)
2040 {
2041     if (shader_backend_ops == &glsl_shader_backend && gl_info->supported[ARB_FRAGMENT_SHADER])
2042         return &glsl_fragment_pipe;
2043     if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
2044         return &arbfp_fragment_pipeline;
2045     if (gl_info->supported[ATI_FRAGMENT_SHADER])
2046         return &atifs_fragment_pipeline;
2047     if (gl_info->supported[NV_REGISTER_COMBINERS] && gl_info->supported[NV_TEXTURE_SHADER2])
2048         return &nvts_fragment_pipeline;
2049     if (gl_info->supported[NV_REGISTER_COMBINERS])
2050         return &nvrc_fragment_pipeline;
2051     return &ffp_fragment_pipeline;
2052 }
2053
2054 static const struct wined3d_shader_backend_ops *select_shader_backend(const struct wined3d_gl_info *gl_info)
2055 {
2056     BOOL glsl = wined3d_settings.shader_backend == WINED3D_SHADER_BACKEND_AUTO
2057             || wined3d_settings.shader_backend == WINED3D_SHADER_BACKEND_GLSL;
2058     BOOL arb = wined3d_settings.shader_backend == WINED3D_SHADER_BACKEND_AUTO
2059             || wined3d_settings.shader_backend == WINED3D_SHADER_BACKEND_ARB;
2060
2061     if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] && !glsl)
2062     {
2063         ERR_(winediag)("Ignoring the shader backend registry key. "
2064                 "GLSL is the only shader backend available on core profile contexts. "
2065                 "You need to explicitly set GL version to use legacy contexts.\n");
2066         glsl = TRUE;
2067     }
2068
2069     glsl = glsl && gl_info->glsl_version >= MAKEDWORD_VERSION(1, 20);
2070
2071     if (glsl && gl_info->supported[ARB_VERTEX_SHADER] && gl_info->supported[ARB_FRAGMENT_SHADER])
2072         return &glsl_shader_backend;
2073     if (arb && gl_info->supported[ARB_VERTEX_PROGRAM] && gl_info->supported[ARB_FRAGMENT_PROGRAM])
2074         return &arb_program_shader_backend;
2075     if (glsl && (gl_info->supported[ARB_VERTEX_SHADER] || gl_info->supported[ARB_FRAGMENT_SHADER]))
2076         return &glsl_shader_backend;
2077     if (arb && (gl_info->supported[ARB_VERTEX_PROGRAM] || gl_info->supported[ARB_FRAGMENT_PROGRAM]))
2078         return &arb_program_shader_backend;
2079     return &none_shader_backend;
2080 }
2081
2082 static void parse_extension_string(struct wined3d_gl_info *gl_info, const char *extensions,
2083         const struct wined3d_extension_map *map, UINT entry_count)
2084 {
2085     while (*extensions)
2086     {
2087         const char *start;
2088         size_t len;
2089         UINT i;
2090
2091         while (isspace(*extensions))
2092             ++extensions;
2093         start = extensions;
2094         while (!isspace(*extensions) && *extensions)
2095             ++extensions;
2096
2097         len = extensions - start;
2098         if (!len)
2099             continue;
2100
2101         TRACE("- %s.\n", debugstr_an(start, len));
2102
2103         for (i = 0; i < entry_count; ++i)
2104         {
2105             if (len == strlen(map[i].extension_string)
2106                     && !memcmp(start, map[i].extension_string, len))
2107             {
2108                 TRACE(" FOUND: %s support.\n", map[i].extension_string);
2109                 gl_info->supported[map[i].extension] = TRUE;
2110                 break;
2111             }
2112         }
2113     }
2114 }
2115
2116 static void enumerate_gl_extensions(struct wined3d_gl_info *gl_info,
2117         const struct wined3d_extension_map *map, unsigned int map_entries_count)
2118 {
2119     const char *gl_extension_name;
2120     unsigned int i, j;
2121     GLint extensions_count;
2122
2123     gl_info->gl_ops.gl.p_glGetIntegerv(GL_NUM_EXTENSIONS, &extensions_count);
2124     for (i = 0; i < extensions_count; ++i)
2125     {
2126         gl_extension_name = (const char *)GL_EXTCALL(glGetStringi(GL_EXTENSIONS, i));
2127         TRACE("- %s.\n", debugstr_a(gl_extension_name));
2128         for (j = 0; j < map_entries_count; ++j)
2129         {
2130             if (!strcmp(gl_extension_name, map[j].extension_string))
2131             {
2132                 TRACE("FOUND: %s support.\n", map[j].extension_string);
2133                 gl_info->supported[map[j].extension] = TRUE;
2134                 break;
2135             }
2136         }
2137     }
2138 }
2139
2140 static void load_gl_funcs(struct wined3d_gl_info *gl_info)
2141 {
2142 #define USE_GL_FUNC(pfn) gl_info->gl_ops.ext.p_##pfn = (void *)wglGetProcAddress(#pfn);
2143     /* GL_APPLE_fence */
2144     USE_GL_FUNC(glDeleteFencesAPPLE)
2145     USE_GL_FUNC(glFinishFenceAPPLE)
2146     USE_GL_FUNC(glFinishObjectAPPLE)
2147     USE_GL_FUNC(glGenFencesAPPLE)
2148     USE_GL_FUNC(glIsFenceAPPLE)
2149     USE_GL_FUNC(glSetFenceAPPLE)
2150     USE_GL_FUNC(glTestFenceAPPLE)
2151     USE_GL_FUNC(glTestObjectAPPLE)
2152     /* GL_APPLE_flush_buffer_range */
2153     USE_GL_FUNC(glBufferParameteriAPPLE)
2154     USE_GL_FUNC(glFlushMappedBufferRangeAPPLE)
2155     /* GL_ARB_base_instance */
2156     USE_GL_FUNC(glDrawArraysInstancedBaseInstance)
2157     USE_GL_FUNC(glDrawElementsInstancedBaseVertexBaseInstance)
2158     /* GL_ARB_blend_func_extended */
2159     USE_GL_FUNC(glBindFragDataLocationIndexed)
2160     USE_GL_FUNC(glGetFragDataIndex)
2161     /* GL_ARB_buffer_storage */
2162     USE_GL_FUNC(glBufferStorage)
2163     /* GL_ARB_clear_buffer_object */
2164     USE_GL_FUNC(glClearBufferData)
2165     USE_GL_FUNC(glClearBufferSubData)
2166     /* GL_ARB_clear_texture */
2167     USE_GL_FUNC(glClearTexImage)
2168     USE_GL_FUNC(glClearTexSubImage)
2169     /* GL_ARB_clip_control */
2170     USE_GL_FUNC(glClipControl)
2171     /* GL_ARB_color_buffer_float */
2172     USE_GL_FUNC(glClampColorARB)
2173     /* GL_ARB_compute_shader */
2174     USE_GL_FUNC(glDispatchCompute)
2175     USE_GL_FUNC(glDispatchComputeIndirect)
2176     /* GL_ARB_copy_buffer */
2177     USE_GL_FUNC(glCopyBufferSubData)
2178     /* GL_ARB_copy_image */
2179     USE_GL_FUNC(glCopyImageSubData)
2180     /* GL_ARB_debug_output */
2181     USE_GL_FUNC(glDebugMessageCallbackARB)
2182     USE_GL_FUNC(glDebugMessageControlARB)
2183     USE_GL_FUNC(glDebugMessageInsertARB)
2184     USE_GL_FUNC(glGetDebugMessageLogARB)
2185     /* GL_ARB_draw_buffers */
2186     USE_GL_FUNC(glDrawBuffersARB)
2187     /* GL_ARB_draw_buffers_blend */
2188     USE_GL_FUNC(glBlendEquationiARB)
2189     USE_GL_FUNC(glBlendEquationSeparateiARB)
2190     USE_GL_FUNC(glBlendFunciARB)
2191     USE_GL_FUNC(glBlendFuncSeparateiARB)
2192     /* GL_ARB_draw_elements_base_vertex */
2193     USE_GL_FUNC(glDrawElementsBaseVertex)
2194     USE_GL_FUNC(glDrawElementsInstancedBaseVertex)
2195     USE_GL_FUNC(glDrawRangeElementsBaseVertex)
2196     USE_GL_FUNC(glMultiDrawElementsBaseVertex)
2197     /* GL_ARB_draw_indirect */
2198     USE_GL_FUNC(glDrawArraysIndirect)
2199     USE_GL_FUNC(glDrawElementsIndirect)
2200     /* GL_ARB_draw_instanced */
2201     USE_GL_FUNC(glDrawArraysInstancedARB)
2202     USE_GL_FUNC(glDrawElementsInstancedARB)
2203     /* GL_ARB_ES2_compatibility */
2204     USE_GL_FUNC(glReleaseShaderCompiler)
2205     USE_GL_FUNC(glShaderBinary)
2206     USE_GL_FUNC(glGetShaderPrecisionFormat)
2207     USE_GL_FUNC(glDepthRangef)
2208     USE_GL_FUNC(glClearDepthf)
2209     /* GL_ARB_framebuffer_no_attachments */
2210     USE_GL_FUNC(glFramebufferParameteri)
2211     /* GL_ARB_framebuffer_object */
2212     USE_GL_FUNC(glBindFramebuffer)
2213     USE_GL_FUNC(glBindRenderbuffer)
2214     USE_GL_FUNC(glBlitFramebuffer)
2215     USE_GL_FUNC(glCheckFramebufferStatus)
2216     USE_GL_FUNC(glDeleteFramebuffers)
2217     USE_GL_FUNC(glDeleteRenderbuffers)
2218     USE_GL_FUNC(glFramebufferRenderbuffer)
2219     USE_GL_FUNC(glFramebufferTexture)
2220     USE_GL_FUNC(glFramebufferTexture1D)
2221     USE_GL_FUNC(glFramebufferTexture2D)
2222     USE_GL_FUNC(glFramebufferTexture3D)
2223     USE_GL_FUNC(glFramebufferTextureLayer)
2224     USE_GL_FUNC(glGenFramebuffers)
2225     USE_GL_FUNC(glGenRenderbuffers)
2226     USE_GL_FUNC(glGenerateMipmap)
2227     USE_GL_FUNC(glGetFramebufferAttachmentParameteriv)
2228     USE_GL_FUNC(glGetRenderbufferParameteriv)
2229     USE_GL_FUNC(glIsFramebuffer)
2230     USE_GL_FUNC(glIsRenderbuffer)
2231     USE_GL_FUNC(glRenderbufferStorage)
2232     USE_GL_FUNC(glRenderbufferStorageMultisample)
2233     /* GL_ARB_geometry_shader4 */
2234     USE_GL_FUNC(glFramebufferTextureARB)
2235     USE_GL_FUNC(glFramebufferTextureFaceARB)
2236     USE_GL_FUNC(glFramebufferTextureLayerARB)
2237     USE_GL_FUNC(glProgramParameteriARB)
2238     /* GL_ARB_instanced_arrays */
2239     USE_GL_FUNC(glVertexAttribDivisorARB)
2240     /* GL_ARB_internalformat_query */
2241     USE_GL_FUNC(glGetInternalformativ)
2242     /* GL_ARB_internalformat_query2 */
2243     USE_GL_FUNC(glGetInternalformati64v)
2244     /* GL_ARB_map_buffer_range */
2245     USE_GL_FUNC(glFlushMappedBufferRange)
2246     USE_GL_FUNC(glMapBufferRange)
2247     /* GL_ARB_multisample */
2248     USE_GL_FUNC(glSampleCoverageARB)
2249     /* GL_ARB_multitexture */
2250     USE_GL_FUNC(glActiveTextureARB)
2251     USE_GL_FUNC(glClientActiveTextureARB)
2252     USE_GL_FUNC(glMultiTexCoord1fARB)
2253     USE_GL_FUNC(glMultiTexCoord1fvARB)
2254     USE_GL_FUNC(glMultiTexCoord2fARB)
2255     USE_GL_FUNC(glMultiTexCoord2fvARB)
2256     USE_GL_FUNC(glMultiTexCoord2svARB)
2257     USE_GL_FUNC(glMultiTexCoord3fARB)
2258     USE_GL_FUNC(glMultiTexCoord3fvARB)
2259     USE_GL_FUNC(glMultiTexCoord4fARB)
2260     USE_GL_FUNC(glMultiTexCoord4fvARB)
2261     USE_GL_FUNC(glMultiTexCoord4svARB)
2262     /* GL_ARB_occlusion_query */
2263     USE_GL_FUNC(glBeginQueryARB)
2264     USE_GL_FUNC(glDeleteQueriesARB)
2265     USE_GL_FUNC(glEndQueryARB)
2266     USE_GL_FUNC(glGenQueriesARB)
2267     USE_GL_FUNC(glGetQueryivARB)
2268     USE_GL_FUNC(glGetQueryObjectivARB)
2269     USE_GL_FUNC(glGetQueryObjectuivARB)
2270     USE_GL_FUNC(glIsQueryARB)
2271     /* GL_ARB_point_parameters */
2272     USE_GL_FUNC(glPointParameterfARB)
2273     USE_GL_FUNC(glPointParameterfvARB)
2274     /* GL_ARB_polgyon_offset_clamp */
2275     USE_GL_FUNC(glPolygonOffsetClamp)
2276     /* GL_ARB_provoking_vertex */
2277     USE_GL_FUNC(glProvokingVertex)
2278     /* GL_ARB_sample_shading */
2279     USE_GL_FUNC(glMinSampleShadingARB)
2280     /* GL_ARB_sampler_objects */
2281     USE_GL_FUNC(glGenSamplers)
2282     USE_GL_FUNC(glDeleteSamplers)
2283     USE_GL_FUNC(glIsSampler)
2284     USE_GL_FUNC(glBindSampler)
2285     USE_GL_FUNC(glSamplerParameteri)
2286     USE_GL_FUNC(glSamplerParameterf)
2287     USE_GL_FUNC(glSamplerParameteriv)
2288     USE_GL_FUNC(glSamplerParameterfv)
2289     USE_GL_FUNC(glSamplerParameterIiv)
2290     USE_GL_FUNC(glSamplerParameterIuiv)
2291     USE_GL_FUNC(glGetSamplerParameteriv)
2292     USE_GL_FUNC(glGetSamplerParameterfv)
2293     USE_GL_FUNC(glGetSamplerParameterIiv)
2294     USE_GL_FUNC(glGetSamplerParameterIuiv)
2295     /* GL_ARB_shader_atomic_counters */
2296     USE_GL_FUNC(glGetActiveAtomicCounterBufferiv)
2297     /* GL_ARB_shader_image_load_store */
2298     USE_GL_FUNC(glBindImageTexture)
2299     USE_GL_FUNC(glMemoryBarrier)
2300     /* GL_ARB_shader_objects */
2301     USE_GL_FUNC(glAttachObjectARB)
2302     USE_GL_FUNC(glBindAttribLocationARB)
2303     USE_GL_FUNC(glCompileShaderARB)
2304     USE_GL_FUNC(glCreateProgramObjectARB)
2305     USE_GL_FUNC(glCreateShaderObjectARB)
2306     USE_GL_FUNC(glDeleteObjectARB)
2307     USE_GL_FUNC(glDetachObjectARB)
2308     USE_GL_FUNC(glGetActiveUniformARB)
2309     USE_GL_FUNC(glGetAttachedObjectsARB)
2310     USE_GL_FUNC(glGetAttribLocationARB)
2311     USE_GL_FUNC(glGetHandleARB)
2312     USE_GL_FUNC(glGetInfoLogARB)
2313     USE_GL_FUNC(glGetObjectParameterfvARB)
2314     USE_GL_FUNC(glGetObjectParameterivARB)
2315     USE_GL_FUNC(glGetShaderSourceARB)
2316     USE_GL_FUNC(glGetUniformLocationARB)
2317     USE_GL_FUNC(glGetUniformfvARB)
2318     USE_GL_FUNC(glGetUniformivARB)
2319     USE_GL_FUNC(glLinkProgramARB)
2320     USE_GL_FUNC(glShaderSourceARB)
2321     USE_GL_FUNC(glUniform1fARB)
2322     USE_GL_FUNC(glUniform1fvARB)
2323     USE_GL_FUNC(glUniform1iARB)
2324     USE_GL_FUNC(glUniform1ivARB)
2325     USE_GL_FUNC(glUniform2fARB)
2326     USE_GL_FUNC(glUniform2fvARB)
2327     USE_GL_FUNC(glUniform2iARB)
2328     USE_GL_FUNC(glUniform2ivARB)
2329     USE_GL_FUNC(glUniform3fARB)
2330     USE_GL_FUNC(glUniform3fvARB)
2331     USE_GL_FUNC(glUniform3iARB)
2332     USE_GL_FUNC(glUniform3ivARB)
2333     USE_GL_FUNC(glUniform4fARB)
2334     USE_GL_FUNC(glUniform4fvARB)
2335     USE_GL_FUNC(glUniform4iARB)
2336     USE_GL_FUNC(glUniform4ivARB)
2337     USE_GL_FUNC(glUniformMatrix2fvARB)
2338     USE_GL_FUNC(glUniformMatrix3fvARB)
2339     USE_GL_FUNC(glUniformMatrix4fvARB)
2340     USE_GL_FUNC(glUseProgramObjectARB)
2341     USE_GL_FUNC(glValidateProgramARB)
2342     /* GL_ARB_shader_storage_buffer_object */
2343     USE_GL_FUNC(glShaderStorageBlockBinding)
2344     /* GL_ARB_sync */
2345     USE_GL_FUNC(glClientWaitSync)
2346     USE_GL_FUNC(glDeleteSync)
2347     USE_GL_FUNC(glFenceSync)
2348     USE_GL_FUNC(glGetInteger64v)
2349     USE_GL_FUNC(glGetSynciv)
2350     USE_GL_FUNC(glIsSync)
2351     USE_GL_FUNC(glWaitSync)
2352     /* GL_ARB_tessellation_shader */
2353     USE_GL_FUNC(glPatchParameteri)
2354     USE_GL_FUNC(glPatchParameterfv)
2355     /* GL_ARB_texture_buffer_object */
2356     USE_GL_FUNC(glTexBufferARB)
2357     /* GL_ARB_texture_buffer_range */
2358     USE_GL_FUNC(glTexBufferRange)
2359     /* GL_ARB_texture_compression */
2360     USE_GL_FUNC(glCompressedTexImage2DARB)
2361     USE_GL_FUNC(glCompressedTexImage3DARB)
2362     USE_GL_FUNC(glCompressedTexSubImage2DARB)
2363     USE_GL_FUNC(glCompressedTexSubImage3DARB)
2364     USE_GL_FUNC(glGetCompressedTexImageARB)
2365     /* GL_ARB_texture_multisample */
2366     USE_GL_FUNC(glGetMultisamplefv);
2367     USE_GL_FUNC(glSampleMaski);
2368     USE_GL_FUNC(glTexImage2DMultisample);
2369     USE_GL_FUNC(glTexImage3DMultisample);
2370     /* GL_ARB_texture_storage */
2371     USE_GL_FUNC(glTexStorage1D)
2372     USE_GL_FUNC(glTexStorage2D)
2373     USE_GL_FUNC(glTexStorage3D)
2374     /* GL_ARB_texture_storage_multisample */
2375     USE_GL_FUNC(glTexStorage2DMultisample);
2376     USE_GL_FUNC(glTexStorage3DMultisample);
2377     /* GL_ARB_texture_view */
2378     USE_GL_FUNC(glTextureView)
2379     /* GL_ARB_timer_query */
2380     USE_GL_FUNC(glQueryCounter)
2381     USE_GL_FUNC(glGetQueryObjectui64v)
2382     /* GL_ARB_transform_feedback2 */
2383     USE_GL_FUNC(glBindTransformFeedback);
2384     USE_GL_FUNC(glDeleteTransformFeedbacks);
2385     USE_GL_FUNC(glDrawTransformFeedback);
2386     USE_GL_FUNC(glGenTransformFeedbacks);
2387     USE_GL_FUNC(glIsTransformFeedback);
2388     USE_GL_FUNC(glPauseTransformFeedback);
2389     USE_GL_FUNC(glResumeTransformFeedback);
2390     /* GL_ARB_transform_feedback3 */
2391     USE_GL_FUNC(glBeginQueryIndexed);
2392     USE_GL_FUNC(glDrawTransformFeedbackStream);
2393     USE_GL_FUNC(glEndQueryIndexed);
2394     USE_GL_FUNC(glGetQueryIndexediv);
2395     /* GL_ARB_uniform_buffer_object */
2396     USE_GL_FUNC(glBindBufferBase)
2397     USE_GL_FUNC(glBindBufferRange)
2398     USE_GL_FUNC(glGetActiveUniformBlockName)
2399     USE_GL_FUNC(glGetActiveUniformBlockiv)
2400     USE_GL_FUNC(glGetActiveUniformName)
2401     USE_GL_FUNC(glGetActiveUniformsiv)
2402     USE_GL_FUNC(glGetIntegeri_v)
2403     USE_GL_FUNC(glGetUniformBlockIndex)
2404     USE_GL_FUNC(glGetUniformIndices)
2405     USE_GL_FUNC(glUniformBlockBinding)
2406     /* GL_ARB_vertex_buffer_object */
2407     USE_GL_FUNC(glBindBufferARB)
2408     USE_GL_FUNC(glBufferDataARB)
2409     USE_GL_FUNC(glBufferSubDataARB)
2410     USE_GL_FUNC(glDeleteBuffersARB)
2411     USE_GL_FUNC(glGenBuffersARB)
2412     USE_GL_FUNC(glGetBufferParameterivARB)
2413     USE_GL_FUNC(glGetBufferPointervARB)
2414     USE_GL_FUNC(glGetBufferSubDataARB)
2415     USE_GL_FUNC(glIsBufferARB)
2416     USE_GL_FUNC(glMapBufferARB)
2417     USE_GL_FUNC(glUnmapBufferARB)
2418     /* GL_ARB_vertex_program */
2419     USE_GL_FUNC(glBindProgramARB)
2420     USE_GL_FUNC(glDeleteProgramsARB)
2421     USE_GL_FUNC(glDisableVertexAttribArrayARB)
2422     USE_GL_FUNC(glEnableVertexAttribArrayARB)
2423     USE_GL_FUNC(glGenProgramsARB)
2424     USE_GL_FUNC(glGetProgramivARB)
2425     USE_GL_FUNC(glProgramEnvParameter4fvARB)
2426     USE_GL_FUNC(glProgramLocalParameter4fvARB)
2427     USE_GL_FUNC(glProgramStringARB)
2428     USE_GL_FUNC(glVertexAttrib1dARB)
2429     USE_GL_FUNC(glVertexAttrib1dvARB)
2430     USE_GL_FUNC(glVertexAttrib1fARB)
2431     USE_GL_FUNC(glVertexAttrib1fvARB)
2432     USE_GL_FUNC(glVertexAttrib1sARB)
2433     USE_GL_FUNC(glVertexAttrib1svARB)
2434     USE_GL_FUNC(glVertexAttrib2dARB)
2435     USE_GL_FUNC(glVertexAttrib2dvARB)
2436     USE_GL_FUNC(glVertexAttrib2fARB)
2437     USE_GL_FUNC(glVertexAttrib2fvARB)
2438     USE_GL_FUNC(glVertexAttrib2sARB)
2439     USE_GL_FUNC(glVertexAttrib2svARB)
2440     USE_GL_FUNC(glVertexAttrib3dARB)
2441     USE_GL_FUNC(glVertexAttrib3dvARB)
2442     USE_GL_FUNC(glVertexAttrib3fARB)
2443     USE_GL_FUNC(glVertexAttrib3fvARB)
2444     USE_GL_FUNC(glVertexAttrib3sARB)
2445     USE_GL_FUNC(glVertexAttrib3svARB)
2446     USE_GL_FUNC(glVertexAttrib4NbvARB)
2447     USE_GL_FUNC(glVertexAttrib4NivARB)
2448     USE_GL_FUNC(glVertexAttrib4NsvARB)
2449     USE_GL_FUNC(glVertexAttrib4NubARB)
2450     USE_GL_FUNC(glVertexAttrib4NubvARB)
2451     USE_GL_FUNC(glVertexAttrib4NuivARB)
2452     USE_GL_FUNC(glVertexAttrib4NusvARB)
2453     USE_GL_FUNC(glVertexAttrib4bvARB)
2454     USE_GL_FUNC(glVertexAttrib4dARB)
2455     USE_GL_FUNC(glVertexAttrib4dvARB)
2456     USE_GL_FUNC(glVertexAttrib4fARB)
2457     USE_GL_FUNC(glVertexAttrib4fvARB)
2458     USE_GL_FUNC(glVertexAttrib4ivARB)
2459     USE_GL_FUNC(glVertexAttrib4sARB)
2460     USE_GL_FUNC(glVertexAttrib4svARB)
2461     USE_GL_FUNC(glVertexAttrib4ubvARB)
2462     USE_GL_FUNC(glVertexAttrib4uivARB)
2463     USE_GL_FUNC(glVertexAttrib4usvARB)
2464     USE_GL_FUNC(glVertexAttribPointerARB)
2465     /* GL_ARB_viewport_array */
2466     USE_GL_FUNC(glDepthRangeArrayv)
2467     USE_GL_FUNC(glDepthRangeIndexed)
2468     USE_GL_FUNC(glGetDoublei_v)
2469     USE_GL_FUNC(glGetFloati_v)
2470     USE_GL_FUNC(glScissorArrayv)
2471     USE_GL_FUNC(glScissorIndexed)
2472     USE_GL_FUNC(glScissorIndexedv)
2473     USE_GL_FUNC(glViewportArrayv)
2474     USE_GL_FUNC(glViewportIndexedf)
2475     USE_GL_FUNC(glViewportIndexedfv)
2476     /* GL_ARB_texture_barrier */
2477     USE_GL_FUNC(glTextureBarrier);
2478     /* GL_ATI_fragment_shader */
2479     USE_GL_FUNC(glAlphaFragmentOp1ATI)
2480     USE_GL_FUNC(glAlphaFragmentOp2ATI)
2481     USE_GL_FUNC(glAlphaFragmentOp3ATI)
2482     USE_GL_FUNC(glBeginFragmentShaderATI)
2483     USE_GL_FUNC(glBindFragmentShaderATI)
2484     USE_GL_FUNC(glColorFragmentOp1ATI)
2485     USE_GL_FUNC(glColorFragmentOp2ATI)
2486     USE_GL_FUNC(glColorFragmentOp3ATI)
2487     USE_GL_FUNC(glDeleteFragmentShaderATI)
2488     USE_GL_FUNC(glEndFragmentShaderATI)
2489     USE_GL_FUNC(glGenFragmentShadersATI)
2490     USE_GL_FUNC(glPassTexCoordATI)
2491     USE_GL_FUNC(glSampleMapATI)
2492     USE_GL_FUNC(glSetFragmentShaderConstantATI)
2493     /* GL_ATI_separate_stencil */
2494     USE_GL_FUNC(glStencilOpSeparateATI)
2495     USE_GL_FUNC(glStencilFuncSeparateATI)
2496     /* GL_EXT_blend_color */
2497     USE_GL_FUNC(glBlendColorEXT)
2498     /* GL_EXT_blend_equation_separate */
2499     USE_GL_FUNC(glBlendFuncSeparateEXT)
2500     /* GL_EXT_blend_func_separate */
2501     USE_GL_FUNC(glBlendEquationSeparateEXT)
2502     /* GL_EXT_blend_minmax */
2503     USE_GL_FUNC(glBlendEquationEXT)
2504     /* GL_EXT_depth_bounds_test */
2505     USE_GL_FUNC(glDepthBoundsEXT)
2506     /* GL_EXT_draw_buffers2 */
2507     USE_GL_FUNC(glColorMaskIndexedEXT)
2508     USE_GL_FUNC(glDisableIndexedEXT)
2509     USE_GL_FUNC(glEnableIndexedEXT)
2510     USE_GL_FUNC(glGetBooleanIndexedvEXT)
2511     USE_GL_FUNC(glGetIntegerIndexedvEXT)
2512     USE_GL_FUNC(glIsEnabledIndexedEXT)
2513     /* GL_EXT_fog_coord */
2514     USE_GL_FUNC(glFogCoordPointerEXT)
2515     USE_GL_FUNC(glFogCoorddEXT)
2516     USE_GL_FUNC(glFogCoorddvEXT)
2517     USE_GL_FUNC(glFogCoordfEXT)
2518     USE_GL_FUNC(glFogCoordfvEXT)
2519     /* GL_EXT_framebuffer_blit */
2520     USE_GL_FUNC(glBlitFramebufferEXT)
2521     /* GL_EXT_framebuffer_multisample */
2522     USE_GL_FUNC(glRenderbufferStorageMultisampleEXT)
2523     /* GL_EXT_framebuffer_object */
2524     USE_GL_FUNC(glBindFramebufferEXT)
2525     USE_GL_FUNC(glBindRenderbufferEXT)
2526     USE_GL_FUNC(glCheckFramebufferStatusEXT)
2527     USE_GL_FUNC(glDeleteFramebuffersEXT)
2528     USE_GL_FUNC(glDeleteRenderbuffersEXT)
2529     USE_GL_FUNC(glFramebufferRenderbufferEXT)
2530     USE_GL_FUNC(glFramebufferTexture1DEXT)
2531     USE_GL_FUNC(glFramebufferTexture2DEXT)
2532     USE_GL_FUNC(glFramebufferTexture3DEXT)
2533     USE_GL_FUNC(glGenFramebuffersEXT)
2534     USE_GL_FUNC(glGenRenderbuffersEXT)
2535     USE_GL_FUNC(glGenerateMipmapEXT)
2536     USE_GL_FUNC(glGetFramebufferAttachmentParameterivEXT)
2537     USE_GL_FUNC(glGetRenderbufferParameterivEXT)
2538     USE_GL_FUNC(glIsFramebufferEXT)
2539     USE_GL_FUNC(glIsRenderbufferEXT)
2540     USE_GL_FUNC(glRenderbufferStorageEXT)
2541     /* GL_EXT_gpu_program_parameters */
2542     USE_GL_FUNC(glProgramEnvParameters4fvEXT)
2543     USE_GL_FUNC(glProgramLocalParameters4fvEXT)
2544     /* GL_EXT_gpu_shader4 */
2545     USE_GL_FUNC(glBindFragDataLocationEXT)
2546     USE_GL_FUNC(glGetFragDataLocationEXT)
2547     USE_GL_FUNC(glGetUniformuivEXT)
2548     USE_GL_FUNC(glGetVertexAttribIivEXT)
2549     USE_GL_FUNC(glGetVertexAttribIuivEXT)
2550     USE_GL_FUNC(glUniform1uiEXT)
2551     USE_GL_FUNC(glUniform1uivEXT)
2552     USE_GL_FUNC(glUniform2uiEXT)
2553     USE_GL_FUNC(glUniform2uivEXT)
2554     USE_GL_FUNC(glUniform3uiEXT)
2555     USE_GL_FUNC(glUniform3uivEXT)
2556     USE_GL_FUNC(glUniform4uiEXT)
2557     USE_GL_FUNC(glUniform4uivEXT)
2558     USE_GL_FUNC(glVertexAttribI1iEXT)
2559     USE_GL_FUNC(glVertexAttribI1ivEXT)
2560     USE_GL_FUNC(glVertexAttribI1uiEXT)
2561     USE_GL_FUNC(glVertexAttribI1uivEXT)
2562     USE_GL_FUNC(glVertexAttribI2iEXT)
2563     USE_GL_FUNC(glVertexAttribI2ivEXT)
2564     USE_GL_FUNC(glVertexAttribI2uiEXT)
2565     USE_GL_FUNC(glVertexAttribI2uivEXT)
2566     USE_GL_FUNC(glVertexAttribI3iEXT)
2567     USE_GL_FUNC(glVertexAttribI3ivEXT)
2568     USE_GL_FUNC(glVertexAttribI3uiEXT)
2569     USE_GL_FUNC(glVertexAttribI3uivEXT)
2570     USE_GL_FUNC(glVertexAttribI4bvEXT)
2571     USE_GL_FUNC(glVertexAttribI4iEXT)
2572     USE_GL_FUNC(glVertexAttribI4ivEXT)
2573     USE_GL_FUNC(glVertexAttribI4svEXT)
2574     USE_GL_FUNC(glVertexAttribI4ubvEXT)
2575     USE_GL_FUNC(glVertexAttribI4uiEXT)
2576     USE_GL_FUNC(glVertexAttribI4uivEXT)
2577     USE_GL_FUNC(glVertexAttribI4usvEXT)
2578     USE_GL_FUNC(glVertexAttribIPointerEXT)
2579     /* GL_EXT_memory_object */
2580     USE_GL_FUNC(glGetUnsignedBytei_vEXT)
2581     USE_GL_FUNC(glGetUnsignedBytevEXT)
2582     /* GL_EXT_point_parameters */
2583     USE_GL_FUNC(glPointParameterfEXT)
2584     USE_GL_FUNC(glPointParameterfvEXT)
2585     /* GL_EXT_polgyon_offset_clamp */
2586     USE_GL_FUNC(glPolygonOffsetClampEXT)
2587     /* GL_EXT_provoking_vertex */
2588     USE_GL_FUNC(glProvokingVertexEXT)
2589     /* GL_EXT_secondary_color */
2590     USE_GL_FUNC(glSecondaryColor3fEXT)
2591     USE_GL_FUNC(glSecondaryColor3fvEXT)
2592     USE_GL_FUNC(glSecondaryColor3ubEXT)
2593     USE_GL_FUNC(glSecondaryColor3ubvEXT)
2594     USE_GL_FUNC(glSecondaryColorPointerEXT)
2595     /* GL_EXT_stencil_two_side */
2596     USE_GL_FUNC(glActiveStencilFaceEXT)
2597     /* GL_EXT_texture3D */
2598     USE_GL_FUNC(glTexImage3D)
2599     USE_GL_FUNC(glTexImage3DEXT)
2600     USE_GL_FUNC(glTexSubImage3D)
2601     USE_GL_FUNC(glTexSubImage3DEXT)
2602     /* GL_NV_fence */
2603     USE_GL_FUNC(glDeleteFencesNV)
2604     USE_GL_FUNC(glFinishFenceNV)
2605     USE_GL_FUNC(glGenFencesNV)
2606     USE_GL_FUNC(glGetFenceivNV)
2607     USE_GL_FUNC(glIsFenceNV)
2608     USE_GL_FUNC(glSetFenceNV)
2609     USE_GL_FUNC(glTestFenceNV)
2610     /* GL_NV_half_float */
2611     USE_GL_FUNC(glColor3hNV)
2612     USE_GL_FUNC(glColor3hvNV)
2613     USE_GL_FUNC(glColor4hNV)
2614     USE_GL_FUNC(glColor4hvNV)
2615     USE_GL_FUNC(glFogCoordhNV)
2616     USE_GL_FUNC(glFogCoordhvNV)
2617     USE_GL_FUNC(glMultiTexCoord1hNV)
2618     USE_GL_FUNC(glMultiTexCoord1hvNV)
2619     USE_GL_FUNC(glMultiTexCoord2hNV)
2620     USE_GL_FUNC(glMultiTexCoord2hvNV)
2621     USE_GL_FUNC(glMultiTexCoord3hNV)
2622     USE_GL_FUNC(glMultiTexCoord3hvNV)
2623     USE_GL_FUNC(glMultiTexCoord4hNV)
2624     USE_GL_FUNC(glMultiTexCoord4hvNV)
2625     USE_GL_FUNC(glNormal3hNV)
2626     USE_GL_FUNC(glNormal3hvNV)
2627     USE_GL_FUNC(glSecondaryColor3hNV)
2628     USE_GL_FUNC(glSecondaryColor3hvNV)
2629     USE_GL_FUNC(glTexCoord1hNV)
2630     USE_GL_FUNC(glTexCoord1hvNV)
2631     USE_GL_FUNC(glTexCoord2hNV)
2632     USE_GL_FUNC(glTexCoord2hvNV)
2633     USE_GL_FUNC(glTexCoord3hNV)
2634     USE_GL_FUNC(glTexCoord3hvNV)
2635     USE_GL_FUNC(glTexCoord4hNV)
2636     USE_GL_FUNC(glTexCoord4hvNV)
2637     USE_GL_FUNC(glVertex2hNV)
2638     USE_GL_FUNC(glVertex2hvNV)
2639     USE_GL_FUNC(glVertex3hNV)
2640     USE_GL_FUNC(glVertex3hvNV)
2641     USE_GL_FUNC(glVertex4hNV)
2642     USE_GL_FUNC(glVertex4hvNV)
2643     USE_GL_FUNC(glVertexAttrib1hNV)
2644     USE_GL_FUNC(glVertexAttrib1hvNV)
2645     USE_GL_FUNC(glVertexAttrib2hNV)
2646     USE_GL_FUNC(glVertexAttrib2hvNV)
2647     USE_GL_FUNC(glVertexAttrib3hNV)
2648     USE_GL_FUNC(glVertexAttrib3hvNV)
2649     USE_GL_FUNC(glVertexAttrib4hNV)
2650     USE_GL_FUNC(glVertexAttrib4hvNV)
2651     USE_GL_FUNC(glVertexAttribs1hvNV)
2652     USE_GL_FUNC(glVertexAttribs2hvNV)
2653     USE_GL_FUNC(glVertexAttribs3hvNV)
2654     USE_GL_FUNC(glVertexAttribs4hvNV)
2655     USE_GL_FUNC(glVertexWeighthNV)
2656     USE_GL_FUNC(glVertexWeighthvNV)
2657     /* GL_NV_point_sprite */
2658     USE_GL_FUNC(glPointParameteriNV)
2659     USE_GL_FUNC(glPointParameterivNV)
2660     /* GL_NV_register_combiners */
2661     USE_GL_FUNC(glCombinerInputNV)
2662     USE_GL_FUNC(glCombinerOutputNV)
2663     USE_GL_FUNC(glCombinerParameterfNV)
2664     USE_GL_FUNC(glCombinerParameterfvNV)
2665     USE_GL_FUNC(glCombinerParameteriNV)
2666     USE_GL_FUNC(glCombinerParameterivNV)
2667     USE_GL_FUNC(glFinalCombinerInputNV)
2668     /* GL_NV_texture_barrier */
2669     USE_GL_FUNC(glTextureBarrierNV);
2670     /* WGL extensions */
2671     USE_GL_FUNC(wglChoosePixelFormatARB)
2672     USE_GL_FUNC(wglGetExtensionsStringARB)
2673     USE_GL_FUNC(wglGetPixelFormatAttribfvARB)
2674     USE_GL_FUNC(wglGetPixelFormatAttribivARB)
2675     USE_GL_FUNC(wglQueryCurrentRendererIntegerWINE)
2676     USE_GL_FUNC(wglQueryCurrentRendererStringWINE)
2677     USE_GL_FUNC(wglQueryRendererIntegerWINE)
2678     USE_GL_FUNC(wglQueryRendererStringWINE)
2679     USE_GL_FUNC(wglSetPixelFormatWINE)
2680     USE_GL_FUNC(wglSwapIntervalEXT)
2681
2682     /* Newer core functions */
2683     USE_GL_FUNC(glActiveTexture)                               /* OpenGL 1.3 */
2684     USE_GL_FUNC(glAttachShader)                                /* OpenGL 2.0 */
2685     USE_GL_FUNC(glBeginQuery)                                  /* OpenGL 1.5 */
2686     USE_GL_FUNC(glBeginTransformFeedback)                      /* OpenGL 3.0 */
2687     USE_GL_FUNC(glBindAttribLocation)                          /* OpenGL 2.0 */
2688     USE_GL_FUNC(glBindBuffer)                                  /* OpenGL 1.5 */
2689     USE_GL_FUNC(glBindFragDataLocation)                        /* OpenGL 3.0 */
2690     USE_GL_FUNC(glBindVertexArray)                             /* OpenGL 3.0 */
2691     USE_GL_FUNC(glBlendColor)                                  /* OpenGL 1.4 */
2692     USE_GL_FUNC(glBlendEquation)                               /* OpenGL 1.4 */
2693     USE_GL_FUNC(glBlendEquationi)                              /* OpenGL 4.0 */
2694     USE_GL_FUNC(glBlendEquationSeparate)                       /* OpenGL 2.0 */
2695     USE_GL_FUNC(glBlendEquationSeparatei)                      /* OpenGL 4.0 */
2696     USE_GL_FUNC(glBlendFunci)                                  /* OpenGL 4.0 */
2697     USE_GL_FUNC(glBlendFuncSeparate)                           /* OpenGL 1.4 */
2698     USE_GL_FUNC(glBlendFuncSeparatei)                          /* OpenGL 4.0 */
2699     USE_GL_FUNC(glBufferData)                                  /* OpenGL 1.5 */
2700     USE_GL_FUNC(glBufferSubData)                               /* OpenGL 1.5 */
2701     USE_GL_FUNC(glColorMaski)                                  /* OpenGL 3.0 */
2702     USE_GL_FUNC(glCompileShader)                               /* OpenGL 2.0 */
2703     USE_GL_FUNC(glCompressedTexImage2D)                        /* OpenGL 1.3 */
2704     USE_GL_FUNC(glCompressedTexImage3D)                        /* OpenGL 1.3 */
2705     USE_GL_FUNC(glCompressedTexSubImage2D)                     /* OpenGL 1.3 */
2706     USE_GL_FUNC(glCompressedTexSubImage3D)                     /* OpenGL 1.3 */
2707     USE_GL_FUNC(glCreateProgram)                               /* OpenGL 2.0 */
2708     USE_GL_FUNC(glCreateShader)                                /* OpenGL 2.0 */
2709     USE_GL_FUNC(glDebugMessageCallback)                        /* OpenGL 4.3 */
2710     USE_GL_FUNC(glDebugMessageControl)                         /* OpenGL 4.3 */
2711     USE_GL_FUNC(glDebugMessageInsert)                          /* OpenGL 4.3 */
2712     USE_GL_FUNC(glDeleteBuffers)                               /* OpenGL 1.5 */
2713     USE_GL_FUNC(glDeleteProgram)                               /* OpenGL 2.0 */
2714     USE_GL_FUNC(glDeleteQueries)                               /* OpenGL 1.5 */
2715     USE_GL_FUNC(glDeleteShader)                                /* OpenGL 2.0 */
2716     USE_GL_FUNC(glDeleteVertexArrays)                          /* OpenGL 3.0 */
2717     USE_GL_FUNC(glDetachShader)                                /* OpenGL 2.0 */
2718     USE_GL_FUNC(glDisablei)                                    /* OpenGL 3.0 */
2719     USE_GL_FUNC(glDisableVertexAttribArray)                    /* OpenGL 2.0 */
2720     USE_GL_FUNC(glDrawArraysInstanced)                         /* OpenGL 3.1 */
2721     USE_GL_FUNC(glDrawBuffers)                                 /* OpenGL 2.0 */
2722     USE_GL_FUNC(glDrawElementsInstanced)                       /* OpenGL 3.1 */
2723     USE_GL_FUNC(glEnablei)                                     /* OpenGL 3.0 */
2724     USE_GL_FUNC(glEnableVertexAttribArray)                     /* OpenGL 2.0 */
2725     USE_GL_FUNC(glEndQuery)                                    /* OpenGL 1.5 */
2726     USE_GL_FUNC(glEndTransformFeedback)                        /* OpenGL 3.0 */
2727     USE_GL_FUNC(glFramebufferTexture)                          /* OpenGL 3.2 */
2728     USE_GL_FUNC(glGenBuffers)                                  /* OpenGL 1.5 */
2729     USE_GL_FUNC(glGenQueries)                                  /* OpenGL 1.5 */
2730     USE_GL_FUNC(glGenVertexArrays)                             /* OpenGL 3.0 */
2731     USE_GL_FUNC(glGetActiveUniform)                            /* OpenGL 2.0 */
2732     USE_GL_FUNC(glGetAttachedShaders)                          /* OpenGL 2.0 */
2733     USE_GL_FUNC(glGetAttribLocation)                           /* OpenGL 2.0 */
2734     USE_GL_FUNC(glGetBooleani_v)                               /* OpenGL 3.0 */
2735     USE_GL_FUNC(glGetBufferSubData)                            /* OpenGL 1.5 */
2736     USE_GL_FUNC(glGetCompressedTexImage)                       /* OpenGL 1.3 */
2737     USE_GL_FUNC(glGetDebugMessageLog)                          /* OpenGL 4.3 */
2738     USE_GL_FUNC(glGetIntegeri_v)                               /* OpenGL 3.0 */
2739     USE_GL_FUNC(glGetProgramInfoLog)                           /* OpenGL 2.0 */
2740     USE_GL_FUNC(glGetProgramiv)                                /* OpenGL 2.0 */
2741     USE_GL_FUNC(glGetQueryiv)                                  /* OpenGL 1.5 */
2742     USE_GL_FUNC(glGetQueryObjectuiv)                           /* OpenGL 1.5 */
2743     USE_GL_FUNC(glGetShaderInfoLog)                            /* OpenGL 2.0 */
2744     USE_GL_FUNC(glGetShaderiv)                                 /* OpenGL 2.0 */
2745     USE_GL_FUNC(glGetShaderSource)                             /* OpenGL 2.0 */
2746     USE_GL_FUNC(glGetStringi)                                  /* OpenGL 3.0 */
2747     USE_GL_FUNC(glGetTextureLevelParameteriv)                  /* OpenGL 4.5 */
2748     USE_GL_FUNC(glGetTextureParameteriv)                       /* OpenGL 4.5 */
2749     USE_GL_FUNC(glGetUniformfv)                                /* OpenGL 2.0 */
2750     USE_GL_FUNC(glGetUniformiv)                                /* OpenGL 2.0 */
2751     USE_GL_FUNC(glGetUniformLocation)                          /* OpenGL 2.0 */
2752     USE_GL_FUNC(glIsEnabledi)                                  /* OpenGL 3.0 */
2753     USE_GL_FUNC(glLinkProgram)                                 /* OpenGL 2.0 */
2754     USE_GL_FUNC(glMapBuffer)                                   /* OpenGL 1.5 */
2755     USE_GL_FUNC(glMinSampleShading)                            /* OpenGL 4.0 */
2756     USE_GL_FUNC(glPointParameteri)                             /* OpenGL 1.4 */
2757     USE_GL_FUNC(glPointParameteriv)                            /* OpenGL 1.4 */
2758     USE_GL_FUNC(glShaderSource)                                /* OpenGL 2.0 */
2759     USE_GL_FUNC(glStencilFuncSeparate)                         /* OpenGL 2.0 */
2760     USE_GL_FUNC(glStencilOpSeparate)                           /* OpenGL 2.0 */
2761     USE_GL_FUNC(glTexBuffer)                                   /* OpenGL 3.1 */
2762     USE_GL_FUNC(glTexImage3D)                                  /* OpenGL 1.2 */
2763     USE_GL_FUNC(glTexSubImage3D)                               /* OpenGL 1.2 */
2764     USE_GL_FUNC(glTransformFeedbackVaryings)                   /* OpenGL 3.0 */
2765     USE_GL_FUNC(glUniform1f)                                   /* OpenGL 2.0 */
2766     USE_GL_FUNC(glUniform1fv)                                  /* OpenGL 2.0 */
2767     USE_GL_FUNC(glUniform1i)                                   /* OpenGL 2.0 */
2768     USE_GL_FUNC(glUniform1iv)                                  /* OpenGL 2.0 */
2769     USE_GL_FUNC(glUniform2f)                                   /* OpenGL 2.0 */
2770     USE_GL_FUNC(glUniform2fv)                                  /* OpenGL 2.0 */
2771     USE_GL_FUNC(glUniform2i)                                   /* OpenGL 2.0 */
2772     USE_GL_FUNC(glUniform2iv)                                  /* OpenGL 2.0 */
2773     USE_GL_FUNC(glUniform3f)                                   /* OpenGL 2.0 */
2774     USE_GL_FUNC(glUniform3fv)                                  /* OpenGL 2.0 */
2775     USE_GL_FUNC(glUniform3i)                                   /* OpenGL 2.0 */
2776     USE_GL_FUNC(glUniform3iv)                                  /* OpenGL 2.0 */
2777     USE_GL_FUNC(glUniform4f)                                   /* OpenGL 2.0 */
2778     USE_GL_FUNC(glUniform4fv)                                  /* OpenGL 2.0 */
2779     USE_GL_FUNC(glUniform4i)                                   /* OpenGL 2.0 */
2780     USE_GL_FUNC(glUniform4iv)                                  /* OpenGL 2.0 */
2781     USE_GL_FUNC(glUniformMatrix2fv)                            /* OpenGL 2.0 */
2782     USE_GL_FUNC(glUniformMatrix3fv)                            /* OpenGL 2.0 */
2783     USE_GL_FUNC(glUniformMatrix4fv)                            /* OpenGL 2.0 */
2784     USE_GL_FUNC(glUnmapBuffer)                                 /* OpenGL 1.5 */
2785     USE_GL_FUNC(glUseProgram)                                  /* OpenGL 2.0 */
2786     USE_GL_FUNC(glValidateProgram)                             /* OpenGL 2.0 */
2787     USE_GL_FUNC(glVertexAttrib1f)                              /* OpenGL 2.0 */
2788     USE_GL_FUNC(glVertexAttrib1fv)                             /* OpenGL 2.0 */
2789     USE_GL_FUNC(glVertexAttrib2f)                              /* OpenGL 2.0 */
2790     USE_GL_FUNC(glVertexAttrib2fv)                             /* OpenGL 2.0 */
2791     USE_GL_FUNC(glVertexAttrib3f)                              /* OpenGL 2.0 */
2792     USE_GL_FUNC(glVertexAttrib3fv)                             /* OpenGL 2.0 */
2793     USE_GL_FUNC(glVertexAttrib4f)                              /* OpenGL 2.0 */
2794     USE_GL_FUNC(glVertexAttrib4fv)                             /* OpenGL 2.0 */
2795     USE_GL_FUNC(glVertexAttrib4Nsv)                            /* OpenGL 2.0 */
2796     USE_GL_FUNC(glVertexAttrib4Nub)                            /* OpenGL 2.0 */
2797     USE_GL_FUNC(glVertexAttrib4Nubv)                           /* OpenGL 2.0 */
2798     USE_GL_FUNC(glVertexAttrib4Nusv)                           /* OpenGL 2.0 */
2799     USE_GL_FUNC(glVertexAttrib4sv)                             /* OpenGL 2.0 */
2800     USE_GL_FUNC(glVertexAttrib4ubv)                            /* OpenGL 2.0 */
2801     USE_GL_FUNC(glVertexAttribDivisor)                         /* OpenGL 3.3 */
2802     USE_GL_FUNC(glVertexAttribIPointer)                        /* OpenGL 3.0 */
2803     USE_GL_FUNC(glVertexAttribPointer)                         /* OpenGL 2.0 */
2804 #undef USE_GL_FUNC
2805
2806 #ifndef USE_WIN32_OPENGL
2807     /* hack: use the functions directly from the TEB table to bypass the thunks */
2808     /* note that we still need the above wglGetProcAddress calls to initialize the table */
2809     gl_info->gl_ops.ext = ((struct opengl_funcs *)NtCurrentTeb()->glTable)->ext;
2810 #endif
2811
2812 #define MAP_GL_FUNCTION(core_func, ext_func)                                          \
2813         do                                                                            \
2814         {                                                                             \
2815             if (!gl_info->gl_ops.ext.p_##core_func)                                   \
2816                 gl_info->gl_ops.ext.p_##core_func = gl_info->gl_ops.ext.p_##ext_func; \
2817         } while (0)
2818 #define MAP_GL_FUNCTION_CAST(core_func, ext_func)                                             \
2819         do                                                                                    \
2820         {                                                                                     \
2821             if (!gl_info->gl_ops.ext.p_##core_func)                                           \
2822                 gl_info->gl_ops.ext.p_##core_func = (void *)gl_info->gl_ops.ext.p_##ext_func; \
2823         } while (0)
2824
2825     MAP_GL_FUNCTION(glActiveTexture, glActiveTextureARB);
2826     MAP_GL_FUNCTION(glAttachShader, glAttachObjectARB);
2827     MAP_GL_FUNCTION(glBeginQuery, glBeginQueryARB);
2828     MAP_GL_FUNCTION(glBindAttribLocation, glBindAttribLocationARB);
2829     MAP_GL_FUNCTION(glBindBuffer, glBindBufferARB);
2830     MAP_GL_FUNCTION(glBindFragDataLocation, glBindFragDataLocationEXT);
2831     MAP_GL_FUNCTION(glBlendColor, glBlendColorEXT);
2832     MAP_GL_FUNCTION(glBlendEquation, glBlendEquationEXT);
2833     MAP_GL_FUNCTION(glBlendEquationi, glBlendEquationiARB);
2834     MAP_GL_FUNCTION(glBlendEquationSeparate, glBlendEquationSeparateEXT);
2835     MAP_GL_FUNCTION(glBlendEquationSeparatei, glBlendEquationSeparateiARB);
2836     MAP_GL_FUNCTION(glBlendFunci, glBlendFunciARB);
2837     MAP_GL_FUNCTION(glBlendFuncSeparate, glBlendFuncSeparateEXT);
2838     MAP_GL_FUNCTION(glBlendFuncSeparatei, glBlendFuncSeparateiARB);
2839     MAP_GL_FUNCTION(glBufferData, glBufferDataARB);
2840     MAP_GL_FUNCTION(glBufferSubData, glBufferSubDataARB);
2841     MAP_GL_FUNCTION(glColorMaski, glColorMaskIndexedEXT);
2842     MAP_GL_FUNCTION(glCompileShader, glCompileShaderARB);
2843     MAP_GL_FUNCTION(glCompressedTexImage2D, glCompressedTexImage2DARB);
2844     MAP_GL_FUNCTION(glCompressedTexImage3D, glCompressedTexImage3DARB);
2845     MAP_GL_FUNCTION(glCompressedTexSubImage2D, glCompressedTexSubImage2DARB);
2846     MAP_GL_FUNCTION(glCompressedTexSubImage3D, glCompressedTexSubImage3DARB);
2847     MAP_GL_FUNCTION(glCreateProgram, glCreateProgramObjectARB);
2848     MAP_GL_FUNCTION(glCreateShader, glCreateShaderObjectARB);
2849     MAP_GL_FUNCTION(glDebugMessageCallback, glDebugMessageCallbackARB);
2850     MAP_GL_FUNCTION(glDebugMessageControl, glDebugMessageControlARB);
2851     MAP_GL_FUNCTION(glDebugMessageInsert, glDebugMessageInsertARB);
2852     MAP_GL_FUNCTION(glDeleteBuffers, glDeleteBuffersARB);
2853     MAP_GL_FUNCTION(glDeleteProgram, glDeleteObjectARB);
2854     MAP_GL_FUNCTION(glDeleteQueries, glDeleteQueriesARB);
2855     MAP_GL_FUNCTION(glDeleteShader, glDeleteObjectARB);
2856     MAP_GL_FUNCTION(glDetachShader, glDetachObjectARB);
2857     MAP_GL_FUNCTION(glDisablei, glDisableIndexedEXT);
2858     MAP_GL_FUNCTION(glDisableVertexAttribArray, glDisableVertexAttribArrayARB);
2859     MAP_GL_FUNCTION(glDrawArraysInstanced, glDrawArraysInstancedARB);
2860     MAP_GL_FUNCTION(glDrawBuffers, glDrawBuffersARB);
2861     MAP_GL_FUNCTION(glDrawElementsInstanced, glDrawElementsInstancedARB);
2862     MAP_GL_FUNCTION(glEnablei, glEnableIndexedEXT);
2863     MAP_GL_FUNCTION(glEnableVertexAttribArray, glEnableVertexAttribArrayARB);
2864     MAP_GL_FUNCTION(glEndQuery, glEndQueryARB);
2865     MAP_GL_FUNCTION(glFramebufferTexture, glFramebufferTextureARB);
2866     MAP_GL_FUNCTION(glGenBuffers, glGenBuffersARB);
2867     MAP_GL_FUNCTION(glGenQueries, glGenQueriesARB);
2868     MAP_GL_FUNCTION(glGetActiveUniform, glGetActiveUniformARB);
2869     MAP_GL_FUNCTION(glGetAttachedShaders, glGetAttachedObjectsARB);
2870     MAP_GL_FUNCTION(glGetAttribLocation, glGetAttribLocationARB);
2871     MAP_GL_FUNCTION(glGetBooleani_v, glGetBooleanIndexedvEXT);
2872     MAP_GL_FUNCTION(glGetBufferSubData, glGetBufferSubDataARB);
2873     MAP_GL_FUNCTION(glGetCompressedTexImage, glGetCompressedTexImageARB);
2874     MAP_GL_FUNCTION(glGetDebugMessageLog, glGetDebugMessageLogARB);
2875     MAP_GL_FUNCTION(glGetIntegeri_v, glGetIntegerIndexedvEXT);
2876     MAP_GL_FUNCTION(glGetProgramInfoLog, glGetInfoLogARB);
2877     MAP_GL_FUNCTION(glGetProgramiv, glGetObjectParameterivARB);
2878     MAP_GL_FUNCTION(glGetQueryiv, glGetQueryivARB);
2879     MAP_GL_FUNCTION(glGetQueryObjectuiv, glGetQueryObjectuivARB);
2880     MAP_GL_FUNCTION(glGetShaderInfoLog, glGetInfoLogARB);
2881     MAP_GL_FUNCTION(glGetShaderiv, glGetObjectParameterivARB);
2882     MAP_GL_FUNCTION(glGetShaderSource, glGetShaderSourceARB);
2883     MAP_GL_FUNCTION(glGetUniformfv, glGetUniformfvARB);
2884     MAP_GL_FUNCTION(glGetUniformiv, glGetUniformivARB);
2885     MAP_GL_FUNCTION(glGetUniformLocation, glGetUniformLocationARB);
2886     MAP_GL_FUNCTION(glIsEnabledi, glIsEnabledIndexedEXT);
2887     MAP_GL_FUNCTION(glLinkProgram, glLinkProgramARB);
2888     MAP_GL_FUNCTION(glMapBuffer, glMapBufferARB);
2889     MAP_GL_FUNCTION(glMinSampleShading, glMinSampleShadingARB);
2890     MAP_GL_FUNCTION(glPolygonOffsetClamp, glPolygonOffsetClampEXT);
2891     MAP_GL_FUNCTION_CAST(glShaderSource, glShaderSourceARB);
2892     MAP_GL_FUNCTION(glTexBuffer, glTexBufferARB);
2893     MAP_GL_FUNCTION_CAST(glTexImage3D, glTexImage3DEXT);
2894     MAP_GL_FUNCTION(glTexSubImage3D, glTexSubImage3DEXT);
2895     MAP_GL_FUNCTION(glUniform1f, glUniform1fARB);
2896     MAP_GL_FUNCTION(glUniform1fv, glUniform1fvARB);
2897     MAP_GL_FUNCTION(glUniform1i, glUniform1iARB);
2898     MAP_GL_FUNCTION(glUniform1iv, glUniform1ivARB);
2899     MAP_GL_FUNCTION(glUniform2f, glUniform2fARB);
2900     MAP_GL_FUNCTION(glUniform2fv, glUniform2fvARB);
2901     MAP_GL_FUNCTION(glUniform2i, glUniform2iARB);
2902     MAP_GL_FUNCTION(glUniform2iv, glUniform2ivARB);
2903     MAP_GL_FUNCTION(glUniform3f, glUniform3fARB);
2904     MAP_GL_FUNCTION(glUniform3fv, glUniform3fvARB);
2905     MAP_GL_FUNCTION(glUniform3i, glUniform3iARB);
2906     MAP_GL_FUNCTION(glUniform3iv, glUniform3ivARB);
2907     MAP_GL_FUNCTION(glUniform4f, glUniform4fARB);
2908     MAP_GL_FUNCTION(glUniform4fv, glUniform4fvARB);
2909     MAP_GL_FUNCTION(glUniform4i, glUniform4iARB);
2910     MAP_GL_FUNCTION(glUniform4iv, glUniform4ivARB);
2911     MAP_GL_FUNCTION(glUniformMatrix2fv, glUniformMatrix2fvARB);
2912     MAP_GL_FUNCTION(glUniformMatrix3fv, glUniformMatrix3fvARB);
2913     MAP_GL_FUNCTION(glUniformMatrix4fv, glUniformMatrix4fvARB);
2914     MAP_GL_FUNCTION(glUnmapBuffer, glUnmapBufferARB);
2915     MAP_GL_FUNCTION(glUseProgram, glUseProgramObjectARB);
2916     MAP_GL_FUNCTION(glValidateProgram, glValidateProgramARB);
2917     MAP_GL_FUNCTION(glVertexAttrib1f, glVertexAttrib1fARB);
2918     MAP_GL_FUNCTION(glVertexAttrib1fv, glVertexAttrib1fvARB);
2919     MAP_GL_FUNCTION(glVertexAttrib2f, glVertexAttrib2fARB);
2920     MAP_GL_FUNCTION(glVertexAttrib2fv, glVertexAttrib2fvARB);
2921     MAP_GL_FUNCTION(glVertexAttrib3f, glVertexAttrib3fARB);
2922     MAP_GL_FUNCTION(glVertexAttrib3fv, glVertexAttrib3fvARB);
2923     MAP_GL_FUNCTION(glVertexAttrib4f, glVertexAttrib4fARB);
2924     MAP_GL_FUNCTION(glVertexAttrib4fv, glVertexAttrib4fvARB);
2925     MAP_GL_FUNCTION(glVertexAttrib4Nsv, glVertexAttrib4NsvARB);
2926     MAP_GL_FUNCTION(glVertexAttrib4Nub, glVertexAttrib4NubARB);
2927     MAP_GL_FUNCTION(glVertexAttrib4Nubv, glVertexAttrib4NubvARB);
2928     MAP_GL_FUNCTION(glVertexAttrib4Nusv, glVertexAttrib4NusvARB);
2929     MAP_GL_FUNCTION(glVertexAttrib4sv, glVertexAttrib4svARB);
2930     MAP_GL_FUNCTION(glVertexAttrib4ubv, glVertexAttrib4ubvARB);
2931     MAP_GL_FUNCTION(glVertexAttribDivisor, glVertexAttribDivisorARB);
2932     MAP_GL_FUNCTION(glVertexAttribIPointer, glVertexAttribIPointerEXT);
2933     MAP_GL_FUNCTION(glVertexAttribPointer, glVertexAttribPointerARB);
2934 #undef MAP_GL_FUNCTION
2935 #undef MAP_GL_FUNCTION_CAST
2936 }
2937
2938 static void wined3d_adapter_init_limits(struct wined3d_gl_info *gl_info)
2939 {
2940     unsigned int i, sampler_count;
2941     GLint gl_max;
2942
2943     gl_info->limits.buffers = 1;
2944     gl_info->limits.textures = 0;
2945     gl_info->limits.texture_coords = 0;
2946     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
2947     {
2948         gl_info->limits.uniform_blocks[i] = 0;
2949         gl_info->limits.samplers[i] = 0;
2950     }
2951     gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] = 1;
2952     gl_info->limits.combined_samplers = gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL];
2953     gl_info->limits.graphics_samplers = gl_info->limits.combined_samplers;
2954     gl_info->limits.vertex_attribs = 16;
2955     gl_info->limits.texture_buffer_offset_alignment = 1;
2956     gl_info->limits.glsl_vs_float_constants = 0;
2957     gl_info->limits.glsl_ps_float_constants = 0;
2958     gl_info->limits.arb_vs_float_constants = 0;
2959     gl_info->limits.arb_vs_native_constants = 0;
2960     gl_info->limits.arb_vs_instructions = 0;
2961     gl_info->limits.arb_vs_temps = 0;
2962     gl_info->limits.arb_ps_float_constants = 0;
2963     gl_info->limits.arb_ps_local_constants = 0;
2964     gl_info->limits.arb_ps_instructions = 0;
2965     gl_info->limits.arb_ps_temps = 0;
2966
2967     gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_CLIP_DISTANCES, &gl_max);
2968     gl_info->limits.user_clip_distances = min(WINED3D_MAX_CLIP_DISTANCES, gl_max);
2969     TRACE("Clip plane support - max planes %d.\n", gl_max);
2970
2971     if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
2972     {
2973         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_LIGHTS, &gl_max);
2974         gl_info->limits.lights = gl_max;
2975         TRACE("Light support - max lights %d.\n", gl_max);
2976     }
2977
2978     gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_SIZE, &gl_max);
2979     gl_info->limits.texture_size = gl_max;
2980     TRACE("Maximum texture size support - max texture size %d.\n", gl_max);
2981
2982     if (gl_info->supported[ARB_MAP_BUFFER_ALIGNMENT])
2983     {
2984         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MIN_MAP_BUFFER_ALIGNMENT, &gl_max);
2985         TRACE("Minimum buffer map alignment: %d.\n", gl_max);
2986     }
2987     else
2988     {
2989         WARN_(d3d_perf)("Driver doesn't guarantee a minimum buffer map alignment.\n");
2990     }
2991     if (gl_info->supported[NV_REGISTER_COMBINERS])
2992     {
2993         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_GENERAL_COMBINERS_NV, &gl_max);
2994         gl_info->limits.general_combiners = gl_max;
2995         TRACE("Max general combiners: %d.\n", gl_max);
2996     }
2997     if (gl_info->supported[ARB_DRAW_BUFFERS] && wined3d_settings.offscreen_rendering_mode == ORM_FBO)
2998     {
2999         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_DRAW_BUFFERS_ARB, &gl_max);
3000         gl_info->limits.buffers = min(WINED3D_MAX_RENDER_TARGETS, gl_max);
3001         TRACE("Max draw buffers: %u.\n", gl_max);
3002     }
3003     if (gl_info->supported[ARB_MULTITEXTURE])
3004     {
3005         if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
3006         {
3007             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &gl_max);
3008             gl_info->limits.textures = min(WINED3D_MAX_TEXTURES, gl_max);
3009             TRACE("Max textures: %d.\n", gl_info->limits.textures);
3010
3011             if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
3012             {
3013                 gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_COORDS_ARB, &gl_max);
3014                 gl_info->limits.texture_coords = min(WINED3D_MAX_TEXTURES, gl_max);
3015             }
3016             else
3017             {
3018                 gl_info->limits.texture_coords = gl_info->limits.textures;
3019             }
3020             TRACE("Max texture coords: %d.\n", gl_info->limits.texture_coords);
3021         }
3022
3023         if (gl_info->supported[ARB_FRAGMENT_PROGRAM] || gl_info->supported[ARB_FRAGMENT_SHADER])
3024         {
3025             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &gl_max);
3026             gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] = gl_max;
3027         }
3028         else
3029         {
3030             gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] = gl_info->limits.textures;
3031         }
3032         TRACE("Max fragment samplers: %d.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL]);
3033
3034         if (gl_info->supported[ARB_VERTEX_SHADER])
3035         {
3036             unsigned int vertex_sampler_count;
3037
3038             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB, &gl_max);
3039             vertex_sampler_count = gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX] = gl_max;
3040             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB, &gl_max);
3041             gl_info->limits.combined_samplers = gl_max;
3042             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_ATTRIBS_ARB, &gl_max);
3043             gl_info->limits.vertex_attribs = gl_max;
3044
3045             /* Loading GLSL sampler uniforms is much simpler if we can assume
3046              * that the sampler setup is known at shader link time. In a
3047              * vertex shader + pixel shader combination this isn't an issue
3048              * because then the sampler setup only depends on the two shaders.
3049              * If a pixel shader is used with fixed-function vertex processing
3050              * we're fine too because fixed-function vertex processing doesn't
3051              * use any samplers. If fixed-function fragment processing is used
3052              * we have to make sure that all vertex sampler setups are valid
3053              * together with all possible fixed-function fragment processing
3054              * setups. This is true if vsamplers + WINED3D_MAX_TEXTURES <= max_samplers.
3055              * This is true on all Direct3D 9 cards that support vertex
3056              * texture fetch (GeForce 6 and GeForce 7 cards). Direct3D 9
3057              * Radeon cards do not support vertex texture fetch. Direct3D 10
3058              * cards have 128 samplers, and Direct3D 9 is limited to 8
3059              * fixed-function texture stages and 4 vertex samplers.
3060              * Direct3D 10 does not have a fixed-function pipeline anymore.
3061              *
3062              * So this is just a check to check that our assumption holds
3063              * true. If not, write a warning and reduce the number of vertex
3064              * samplers or probably disable vertex texture fetch. */
3065             if (vertex_sampler_count && gl_info->limits.combined_samplers < 12
3066                     && WINED3D_MAX_TEXTURES + vertex_sampler_count > gl_info->limits.combined_samplers)
3067             {
3068                 FIXME("OpenGL implementation supports %u vertex samplers and %u total samplers.\n",
3069                         vertex_sampler_count, gl_info->limits.combined_samplers);
3070                 FIXME("Expected vertex samplers + WINED3D_MAX_TEXTURES(=8) > combined_samplers.\n");
3071                 if (gl_info->limits.combined_samplers > WINED3D_MAX_TEXTURES)
3072                     vertex_sampler_count = gl_info->limits.combined_samplers - WINED3D_MAX_TEXTURES;
3073                 else
3074                     vertex_sampler_count = 0;
3075                 gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX] = vertex_sampler_count;
3076             }
3077         }
3078         else
3079         {
3080             gl_info->limits.combined_samplers = gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL];
3081         }
3082         TRACE("Max vertex samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_VERTEX]);
3083         TRACE("Max combined samplers: %u.\n", gl_info->limits.combined_samplers);
3084         TRACE("Max vertex attributes: %u.\n", gl_info->limits.vertex_attribs);
3085     }
3086     else
3087     {
3088         gl_info->limits.textures = 1;
3089         gl_info->limits.texture_coords = 1;
3090     }
3091
3092     if (gl_info->supported[EXT_TEXTURE3D])
3093     {
3094         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_3D_TEXTURE_SIZE_EXT, &gl_max);
3095         gl_info->limits.texture3d_size = gl_max;
3096         TRACE("Max texture3D size: %d.\n", gl_info->limits.texture3d_size);
3097     }
3098     if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC])
3099     {
3100         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY, &gl_max);
3101         gl_info->limits.anisotropy = gl_max;
3102         TRACE("Max anisotropy: %d.\n", gl_info->limits.anisotropy);
3103     }
3104     if (gl_info->supported[ARB_FRAGMENT_PROGRAM])
3105     {
3106         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
3107         gl_info->limits.arb_ps_float_constants = gl_max;
3108         TRACE("Max ARB_FRAGMENT_PROGRAM float constants: %d.\n", gl_info->limits.arb_ps_float_constants);
3109         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
3110         gl_info->limits.arb_ps_native_constants = gl_max;
3111         TRACE("Max ARB_FRAGMENT_PROGRAM native float constants: %d.\n",
3112                 gl_info->limits.arb_ps_native_constants);
3113         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
3114         gl_info->limits.arb_ps_temps = gl_max;
3115         TRACE("Max ARB_FRAGMENT_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_ps_temps);
3116         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
3117         gl_info->limits.arb_ps_instructions = gl_max;
3118         TRACE("Max ARB_FRAGMENT_PROGRAM native instructions: %d.\n", gl_info->limits.arb_ps_instructions);
3119         GL_EXTCALL(glGetProgramivARB(GL_FRAGMENT_PROGRAM_ARB, GL_MAX_PROGRAM_LOCAL_PARAMETERS_ARB, &gl_max));
3120         gl_info->limits.arb_ps_local_constants = gl_max;
3121         TRACE("Max ARB_FRAGMENT_PROGRAM local parameters: %d.\n", gl_info->limits.arb_ps_instructions);
3122     }
3123     if (gl_info->supported[ARB_VERTEX_PROGRAM])
3124     {
3125         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_ENV_PARAMETERS_ARB, &gl_max));
3126         gl_info->limits.arb_vs_float_constants = gl_max;
3127         TRACE("Max ARB_VERTEX_PROGRAM float constants: %d.\n", gl_info->limits.arb_vs_float_constants);
3128         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_PARAMETERS_ARB, &gl_max));
3129         gl_info->limits.arb_vs_native_constants = gl_max;
3130         TRACE("Max ARB_VERTEX_PROGRAM native float constants: %d.\n",
3131                 gl_info->limits.arb_vs_native_constants);
3132         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB, &gl_max));
3133         gl_info->limits.arb_vs_temps = gl_max;
3134         TRACE("Max ARB_VERTEX_PROGRAM native temporaries: %d.\n", gl_info->limits.arb_vs_temps);
3135         GL_EXTCALL(glGetProgramivARB(GL_VERTEX_PROGRAM_ARB, GL_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB, &gl_max));
3136         gl_info->limits.arb_vs_instructions = gl_max;
3137         TRACE("Max ARB_VERTEX_PROGRAM native instructions: %d.\n", gl_info->limits.arb_vs_instructions);
3138     }
3139     if (gl_info->supported[ARB_VERTEX_SHADER])
3140     {
3141         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS_ARB, &gl_max);
3142         gl_info->limits.glsl_vs_float_constants = gl_max / 4;
3143         TRACE("Max ARB_VERTEX_SHADER float constants: %u.\n", gl_info->limits.glsl_vs_float_constants);
3144
3145         if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
3146         {
3147             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_UNIFORM_BLOCKS, &gl_max);
3148             gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_VERTEX] = min(gl_max, WINED3D_MAX_CBS);
3149             TRACE("Max vertex uniform blocks: %u (%d).\n",
3150                     gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_VERTEX], gl_max);
3151         }
3152     }
3153     if (gl_info->supported[ARB_TESSELLATION_SHADER])
3154     {
3155         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_CONTROL_UNIFORM_BLOCKS, &gl_max);
3156         gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_HULL] = min(gl_max, WINED3D_MAX_CBS);
3157         TRACE("Max hull uniform blocks: %u (%d).\n",
3158                 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_HULL], gl_max);
3159         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS, &gl_max);
3160         gl_info->limits.samplers[WINED3D_SHADER_TYPE_HULL] = gl_max;
3161         TRACE("Max hull samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_HULL]);
3162
3163         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_EVALUATION_UNIFORM_BLOCKS, &gl_max);
3164         gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_DOMAIN] = min(gl_max, WINED3D_MAX_CBS);
3165         TRACE("Max domain uniform blocks: %u (%d).\n",
3166                 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_DOMAIN], gl_max);
3167         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS, &gl_max);
3168         gl_info->limits.samplers[WINED3D_SHADER_TYPE_DOMAIN] = gl_max;
3169         TRACE("Max domain samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_DOMAIN]);
3170     }
3171     if (gl_info->supported[WINED3D_GL_VERSION_3_2] && gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
3172     {
3173         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_GEOMETRY_UNIFORM_BLOCKS, &gl_max);
3174         gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_GEOMETRY] = min(gl_max, WINED3D_MAX_CBS);
3175         TRACE("Max geometry uniform blocks: %u (%d).\n",
3176                 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_GEOMETRY], gl_max);
3177         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &gl_max);
3178         gl_info->limits.samplers[WINED3D_SHADER_TYPE_GEOMETRY] = gl_max;
3179         TRACE("Max geometry samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_GEOMETRY]);
3180     }
3181     if (gl_info->supported[ARB_FRAGMENT_SHADER])
3182     {
3183         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB, &gl_max);
3184         gl_info->limits.glsl_ps_float_constants = gl_max / 4;
3185         TRACE("Max ARB_FRAGMENT_SHADER float constants: %u.\n", gl_info->limits.glsl_ps_float_constants);
3186         if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
3187         {
3188             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VARYING_FLOATS_ARB, &gl_max);
3189             gl_info->limits.glsl_varyings = gl_max;
3190         }
3191         else
3192         {
3193             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_INPUT_COMPONENTS, &gl_max);
3194             gl_info->limits.glsl_varyings = gl_max - 4;
3195         }
3196         TRACE("Max GLSL varyings: %u (%u 4 component varyings).\n", gl_info->limits.glsl_varyings,
3197                 gl_info->limits.glsl_varyings / 4);
3198
3199         if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
3200         {
3201             gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_UNIFORM_BLOCKS, &gl_max);
3202             gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_PIXEL] = min(gl_max, WINED3D_MAX_CBS);
3203             TRACE("Max fragment uniform blocks: %u (%d).\n",
3204                     gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_PIXEL], gl_max);
3205         }
3206     }
3207     if (gl_info->supported[ARB_COMPUTE_SHADER])
3208     {
3209         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMPUTE_UNIFORM_BLOCKS, &gl_max);
3210         gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_COMPUTE] = min(gl_max, WINED3D_MAX_CBS);
3211         TRACE("Max compute uniform blocks: %u (%d).\n",
3212                 gl_info->limits.uniform_blocks[WINED3D_SHADER_TYPE_COMPUTE], gl_max);
3213         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMPUTE_TEXTURE_IMAGE_UNITS, &gl_max);
3214         gl_info->limits.samplers[WINED3D_SHADER_TYPE_COMPUTE] = gl_max;
3215         TRACE("Max compute samplers: %u.\n", gl_info->limits.samplers[WINED3D_SHADER_TYPE_COMPUTE]);
3216     }
3217     if (gl_info->supported[ARB_UNIFORM_BUFFER_OBJECT])
3218     {
3219         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMBINED_UNIFORM_BLOCKS, &gl_max);
3220         TRACE("Max combined uniform blocks: %d.\n", gl_max);
3221         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_UNIFORM_BUFFER_BINDINGS, &gl_max);
3222         TRACE("Max uniform buffer bindings: %d.\n", gl_max);
3223     }
3224     if (gl_info->supported[ARB_TEXTURE_BUFFER_RANGE])
3225     {
3226         gl_info->gl_ops.gl.p_glGetIntegerv(GL_TEXTURE_BUFFER_OFFSET_ALIGNMENT, &gl_max);
3227         gl_info->limits.texture_buffer_offset_alignment = gl_max;
3228         TRACE("Minimum required texture buffer offset alignment %d.\n", gl_max);
3229     }
3230     if (gl_info->supported[ARB_SHADER_ATOMIC_COUNTERS])
3231     {
3232         GLint max_fragment_buffers, max_combined_buffers, max_bindings;
3233         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS, &max_fragment_buffers);
3234         TRACE("Max fragment atomic counter buffers: %d.\n", max_fragment_buffers);
3235         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS, &max_combined_buffers);
3236         TRACE("Max combined atomic counter buffers: %d.\n", max_combined_buffers);
3237         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS, &max_bindings);
3238         TRACE("Max atomic counter buffer bindings: %d.\n", max_bindings);
3239         if (max_fragment_buffers < MAX_UNORDERED_ACCESS_VIEWS
3240                 || max_combined_buffers < MAX_UNORDERED_ACCESS_VIEWS
3241                 || max_bindings < MAX_UNORDERED_ACCESS_VIEWS)
3242         {
3243             WARN("Disabling ARB_shader_atomic_counters.\n");
3244             gl_info->supported[ARB_SHADER_ATOMIC_COUNTERS] = FALSE;
3245         }
3246     }
3247     if (gl_info->supported[ARB_TRANSFORM_FEEDBACK3])
3248     {
3249         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_VERTEX_STREAMS, &gl_max);
3250         TRACE("Max vertex streams: %d.\n", gl_max);
3251     }
3252
3253     if (gl_info->supported[NV_LIGHT_MAX_EXPONENT])
3254         gl_info->gl_ops.gl.p_glGetFloatv(GL_MAX_SHININESS_NV, &gl_info->limits.shininess);
3255     else
3256         gl_info->limits.shininess = 128.0f;
3257
3258     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT] || gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
3259     {
3260         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_SAMPLES, &gl_max);
3261         gl_info->limits.samples = gl_max;
3262     }
3263
3264     if (gl_info->supported[ARB_FRAMEBUFFER_NO_ATTACHMENTS])
3265     {
3266         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAMEBUFFER_WIDTH, &gl_max);
3267         gl_info->limits.framebuffer_width = gl_max;
3268         gl_info->gl_ops.gl.p_glGetIntegerv(GL_MAX_FRAMEBUFFER_HEIGHT, &gl_max);
3269         gl_info->limits.framebuffer_height = gl_max;
3270     }
3271     else
3272     {
3273         gl_info->limits.framebuffer_width = gl_info->limits.texture_size;
3274         gl_info->limits.framebuffer_height = gl_info->limits.texture_size;
3275     }
3276
3277     gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL] =
3278             min(gl_info->limits.samplers[WINED3D_SHADER_TYPE_PIXEL], MAX_GL_FRAGMENT_SAMPLERS);
3279     sampler_count = 0;
3280     for (i = 0; i < WINED3D_SHADER_TYPE_GRAPHICS_COUNT; ++i)
3281         sampler_count += gl_info->limits.samplers[i];
3282     if (gl_info->supported[WINED3D_GL_VERSION_3_2] && gl_info->limits.combined_samplers < sampler_count)
3283     {
3284         /* The minimum value for GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS in OpenGL
3285          * 3.2 is 48 (16 per stage). When tessellation shaders are supported
3286          * the minimum value is increased to 80. */
3287         WARN("Graphics pipeline sampler count %u is greater than combined sampler count %u.\n",
3288                 sampler_count, gl_info->limits.combined_samplers);
3289         for (i = 0; i < WINED3D_SHADER_TYPE_GRAPHICS_COUNT; ++i)
3290             gl_info->limits.samplers[i] = min(gl_info->limits.samplers[i], 16);
3291     }
3292
3293     /* A majority of OpenGL implementations allow us to statically partition
3294      * the set of texture bindings into six separate sets. */
3295     gl_info->limits.graphics_samplers = gl_info->limits.combined_samplers;
3296     sampler_count = 0;
3297     for (i = 0; i < WINED3D_SHADER_TYPE_COUNT; ++i)
3298         sampler_count += gl_info->limits.samplers[i];
3299     if (gl_info->limits.combined_samplers >= sampler_count)
3300         gl_info->limits.graphics_samplers -= gl_info->limits.samplers[WINED3D_SHADER_TYPE_COMPUTE];
3301 }
3302
3303 /* Context activation is done by the caller. */
3304 static BOOL wined3d_adapter_init_gl_caps(struct wined3d_adapter *adapter,
3305         struct wined3d_caps_gl_ctx *caps_gl_ctx, unsigned int wined3d_creation_flags)
3306 {
3307     static const struct
3308     {
3309         enum wined3d_gl_extension extension;
3310         DWORD min_gl_version;
3311     }
3312     core_extensions[] =
3313     {
3314         {EXT_TEXTURE3D,                    MAKEDWORD_VERSION(1, 2)},
3315         {ARB_MULTISAMPLE,                  MAKEDWORD_VERSION(1, 3)},
3316         {ARB_MULTITEXTURE,                 MAKEDWORD_VERSION(1, 3)},
3317         {ARB_TEXTURE_BORDER_CLAMP,         MAKEDWORD_VERSION(1, 3)},
3318         {ARB_TEXTURE_COMPRESSION,          MAKEDWORD_VERSION(1, 3)},
3319         {ARB_TEXTURE_CUBE_MAP,             MAKEDWORD_VERSION(1, 3)},
3320         {ARB_DEPTH_TEXTURE,                MAKEDWORD_VERSION(1, 4)},
3321         {ARB_POINT_PARAMETERS,             MAKEDWORD_VERSION(1, 4)},
3322         {ARB_SHADOW,                       MAKEDWORD_VERSION(1, 4)},
3323         {ARB_TEXTURE_MIRRORED_REPEAT,      MAKEDWORD_VERSION(1, 4)},
3324         {EXT_BLEND_COLOR,                  MAKEDWORD_VERSION(1, 4)},
3325         {EXT_BLEND_FUNC_SEPARATE,          MAKEDWORD_VERSION(1, 4)},
3326         {EXT_BLEND_MINMAX,                 MAKEDWORD_VERSION(1, 4)},
3327         {EXT_BLEND_SUBTRACT,               MAKEDWORD_VERSION(1, 4)},
3328         {EXT_STENCIL_WRAP,                 MAKEDWORD_VERSION(1, 4)},
3329         {NV_POINT_SPRITE,                  MAKEDWORD_VERSION(1, 4)},
3330         {ARB_OCCLUSION_QUERY,              MAKEDWORD_VERSION(1, 5)},
3331         {ARB_VERTEX_BUFFER_OBJECT,         MAKEDWORD_VERSION(1, 5)},
3332         {ARB_DRAW_BUFFERS,                 MAKEDWORD_VERSION(2, 0)},
3333         {ARB_FRAGMENT_SHADER,              MAKEDWORD_VERSION(2, 0)},
3334         {ARB_SHADING_LANGUAGE_100,         MAKEDWORD_VERSION(2, 0)},
3335         {ARB_TEXTURE_NON_POWER_OF_TWO,     MAKEDWORD_VERSION(2, 0)},
3336         {ARB_VERTEX_SHADER,                MAKEDWORD_VERSION(2, 0)},
3337         {EXT_BLEND_EQUATION_SEPARATE,      MAKEDWORD_VERSION(2, 0)},
3338         {ARB_PIXEL_BUFFER_OBJECT,          MAKEDWORD_VERSION(2, 1)},
3339         {EXT_TEXTURE_SRGB,                 MAKEDWORD_VERSION(2, 1)},
3340         {ARB_COLOR_BUFFER_FLOAT,           MAKEDWORD_VERSION(3, 0)},
3341         {ARB_DEPTH_BUFFER_FLOAT,           MAKEDWORD_VERSION(3, 0)},
3342         {ARB_FRAMEBUFFER_OBJECT,           MAKEDWORD_VERSION(3, 0)},
3343         {ARB_FRAMEBUFFER_SRGB,             MAKEDWORD_VERSION(3, 0)},
3344         {ARB_HALF_FLOAT_PIXEL,             MAKEDWORD_VERSION(3, 0)},
3345         {ARB_HALF_FLOAT_VERTEX,            MAKEDWORD_VERSION(3, 0)},
3346         {ARB_MAP_BUFFER_RANGE,             MAKEDWORD_VERSION(3, 0)},
3347         {ARB_TEXTURE_COMPRESSION_RGTC,     MAKEDWORD_VERSION(3, 0)},
3348         {ARB_TEXTURE_FLOAT,                MAKEDWORD_VERSION(3, 0)},
3349         {ARB_TEXTURE_RG,                   MAKEDWORD_VERSION(3, 0)},
3350         {EXT_DRAW_BUFFERS2,                MAKEDWORD_VERSION(3, 0)},
3351         {EXT_PACKED_FLOAT,                 MAKEDWORD_VERSION(3, 0)},
3352         {EXT_TEXTURE_ARRAY,                MAKEDWORD_VERSION(3, 0)},
3353         {EXT_TEXTURE_INTEGER,              MAKEDWORD_VERSION(3, 0)},
3354         {EXT_TEXTURE_SHARED_EXPONENT,      MAKEDWORD_VERSION(3, 0)},
3355         /* We don't want to enable EXT_GPU_SHADER4: even though similar
3356          * functionality is available in core GL 3.0 / GLSL 1.30, it's different
3357          * enough that reusing the same flag for the new features hurts more
3358          * than it helps. */
3359         /* EXT_framebuffer_object, EXT_framebuffer_blit,
3360          * EXT_framebuffer_multisample and EXT_packed_depth_stencil
3361          * are integrated into ARB_framebuffer_object. */
3362
3363         {ARB_COPY_BUFFER,                  MAKEDWORD_VERSION(3, 1)},
3364         {ARB_DRAW_INSTANCED,               MAKEDWORD_VERSION(3, 1)},
3365         {ARB_TEXTURE_BUFFER_OBJECT,        MAKEDWORD_VERSION(3, 1)},
3366         {ARB_UNIFORM_BUFFER_OBJECT,        MAKEDWORD_VERSION(3, 1)},
3367         {EXT_TEXTURE_SNORM,                MAKEDWORD_VERSION(3, 1)},
3368         /* We don't need or want GL_ARB_texture_rectangle (core in 3.1). */
3369
3370         {ARB_DEPTH_CLAMP,                  MAKEDWORD_VERSION(3, 2)},
3371         {ARB_DRAW_ELEMENTS_BASE_VERTEX,    MAKEDWORD_VERSION(3, 2)},
3372         /* ARB_geometry_shader4 exposes a somewhat different API compared to 3.2
3373          * core geometry shaders so it's not really correct to expose the
3374          * extension for core-only support. */
3375         {ARB_FRAGMENT_COORD_CONVENTIONS,   MAKEDWORD_VERSION(3, 2)},
3376         {ARB_PROVOKING_VERTEX,             MAKEDWORD_VERSION(3, 2)},
3377         {ARB_SEAMLESS_CUBE_MAP,            MAKEDWORD_VERSION(3, 2)},
3378         {ARB_SYNC,                         MAKEDWORD_VERSION(3, 2)},
3379         {ARB_TEXTURE_MULTISAMPLE,          MAKEDWORD_VERSION(3, 2)},
3380         {ARB_VERTEX_ARRAY_BGRA,            MAKEDWORD_VERSION(3, 2)},
3381
3382         {ARB_BLEND_FUNC_EXTENDED,          MAKEDWORD_VERSION(3, 3)},
3383         {ARB_EXPLICIT_ATTRIB_LOCATION,     MAKEDWORD_VERSION(3, 3)},
3384         {ARB_INSTANCED_ARRAYS,             MAKEDWORD_VERSION(3, 3)},
3385         {ARB_SAMPLER_OBJECTS,              MAKEDWORD_VERSION(3, 3)},
3386         {ARB_SHADER_BIT_ENCODING,          MAKEDWORD_VERSION(3, 3)},
3387         {ARB_TEXTURE_RGB10_A2UI,           MAKEDWORD_VERSION(3, 3)},
3388         {ARB_TEXTURE_SWIZZLE,              MAKEDWORD_VERSION(3, 3)},
3389         {ARB_TIMER_QUERY,                  MAKEDWORD_VERSION(3, 3)},
3390         {ARB_VERTEX_TYPE_2_10_10_10_REV,   MAKEDWORD_VERSION(3, 3)},
3391
3392         {ARB_DRAW_BUFFERS_BLEND,           MAKEDWORD_VERSION(4, 0)},
3393         {ARB_DRAW_INDIRECT,                MAKEDWORD_VERSION(4, 0)},
3394         {ARB_GPU_SHADER5,                  MAKEDWORD_VERSION(4, 0)},
3395         {ARB_SAMPLE_SHADING,               MAKEDWORD_VERSION(4, 0)},
3396         {ARB_TESSELLATION_SHADER,          MAKEDWORD_VERSION(4, 0)},
3397         {ARB_TEXTURE_CUBE_MAP_ARRAY,       MAKEDWORD_VERSION(4, 0)},
3398         {ARB_TEXTURE_GATHER,               MAKEDWORD_VERSION(4, 0)},
3399         {ARB_TRANSFORM_FEEDBACK2,          MAKEDWORD_VERSION(4, 0)},
3400         {ARB_TRANSFORM_FEEDBACK3,          MAKEDWORD_VERSION(4, 0)},
3401
3402         {ARB_ES2_COMPATIBILITY,            MAKEDWORD_VERSION(4, 1)},
3403         {ARB_VIEWPORT_ARRAY,               MAKEDWORD_VERSION(4, 1)},
3404
3405         {ARB_BASE_INSTANCE,                MAKEDWORD_VERSION(4, 2)},
3406         {ARB_CONSERVATIVE_DEPTH,           MAKEDWORD_VERSION(4, 2)},
3407         {ARB_INTERNALFORMAT_QUERY,         MAKEDWORD_VERSION(4, 2)},
3408         {ARB_MAP_BUFFER_ALIGNMENT,         MAKEDWORD_VERSION(4, 2)},
3409         {ARB_SHADER_ATOMIC_COUNTERS,       MAKEDWORD_VERSION(4, 2)},
3410         {ARB_SHADER_IMAGE_LOAD_STORE,      MAKEDWORD_VERSION(4, 2)},
3411         {ARB_SHADING_LANGUAGE_420PACK,     MAKEDWORD_VERSION(4, 2)},
3412         {ARB_SHADING_LANGUAGE_PACKING,     MAKEDWORD_VERSION(4, 2)},
3413         {ARB_TEXTURE_COMPRESSION_BPTC,     MAKEDWORD_VERSION(4, 2)},
3414         {ARB_TEXTURE_STORAGE,              MAKEDWORD_VERSION(4, 2)},
3415
3416         {ARB_CLEAR_BUFFER_OBJECT,          MAKEDWORD_VERSION(4, 3)},
3417         {ARB_COMPUTE_SHADER,               MAKEDWORD_VERSION(4, 3)},
3418         {ARB_COPY_IMAGE,                   MAKEDWORD_VERSION(4, 3)},
3419         {ARB_DEBUG_OUTPUT,                 MAKEDWORD_VERSION(4, 3)},
3420         {ARB_ES3_COMPATIBILITY,            MAKEDWORD_VERSION(4, 3)},
3421         {ARB_FRAGMENT_LAYER_VIEWPORT,      MAKEDWORD_VERSION(4, 3)},
3422         {ARB_FRAMEBUFFER_NO_ATTACHMENTS,   MAKEDWORD_VERSION(4, 3)},
3423         {ARB_INTERNALFORMAT_QUERY2,        MAKEDWORD_VERSION(4, 3)},
3424         {ARB_SHADER_IMAGE_SIZE,            MAKEDWORD_VERSION(4, 3)},
3425         {ARB_SHADER_STORAGE_BUFFER_OBJECT, MAKEDWORD_VERSION(4, 3)},
3426         {ARB_STENCIL_TEXTURING,            MAKEDWORD_VERSION(4, 3)},
3427         {ARB_TEXTURE_BUFFER_RANGE,         MAKEDWORD_VERSION(4, 3)},
3428         {ARB_TEXTURE_QUERY_LEVELS,         MAKEDWORD_VERSION(4, 3)},
3429         {ARB_TEXTURE_STORAGE_MULTISAMPLE,  MAKEDWORD_VERSION(4, 3)},
3430         {ARB_TEXTURE_VIEW,                 MAKEDWORD_VERSION(4, 3)},
3431
3432         {ARB_BUFFER_STORAGE,               MAKEDWORD_VERSION(4, 4)},
3433         {ARB_CLEAR_TEXTURE,                MAKEDWORD_VERSION(4, 4)},
3434         {ARB_QUERY_BUFFER_OBJECT,          MAKEDWORD_VERSION(4, 4)},
3435         {ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE, MAKEDWORD_VERSION(4, 4)},
3436
3437         {ARB_CLIP_CONTROL,                 MAKEDWORD_VERSION(4, 5)},
3438         {ARB_CULL_DISTANCE,                MAKEDWORD_VERSION(4, 5)},
3439         {ARB_DERIVATIVE_CONTROL,           MAKEDWORD_VERSION(4, 5)},
3440         {ARB_SHADER_TEXTURE_IMAGE_SAMPLES, MAKEDWORD_VERSION(4, 5)},
3441         {ARB_TEXTURE_BARRIER,              MAKEDWORD_VERSION(4, 5)},
3442
3443         {ARB_PIPELINE_STATISTICS_QUERY,    MAKEDWORD_VERSION(4, 6)},
3444         {ARB_POLYGON_OFFSET_CLAMP,         MAKEDWORD_VERSION(4, 6)},
3445         {ARB_TEXTURE_FILTER_ANISOTROPIC,   MAKEDWORD_VERSION(4, 6)},
3446     };
3447     struct wined3d_driver_info *driver_info = &adapter->driver_info;
3448     const char *gl_vendor_str, *gl_renderer_str, *gl_version_str;
3449     const struct wined3d_gpu_description *gpu_description;
3450     struct wined3d_gl_info *gl_info = &adapter->gl_info;
3451     const char *WGL_Extensions = NULL;
3452     enum wined3d_gl_vendor gl_vendor;
3453     DWORD gl_version, gl_ext_emul_mask;
3454     GLint context_profile = 0;
3455     UINT64 vram_bytes = 0;
3456     unsigned int i, j;
3457     HDC hdc;
3458
3459     TRACE("adapter %p.\n", adapter);
3460
3461     gl_renderer_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_RENDERER);
3462     TRACE("GL_RENDERER: %s.\n", debugstr_a(gl_renderer_str));
3463     if (!gl_renderer_str)
3464     {
3465         ERR("Received a NULL GL_RENDERER.\n");
3466         return FALSE;
3467     }
3468
3469     gl_vendor_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VENDOR);
3470     TRACE("GL_VENDOR: %s.\n", debugstr_a(gl_vendor_str));
3471     if (!gl_vendor_str)
3472     {
3473         ERR("Received a NULL GL_VENDOR.\n");
3474         return FALSE;
3475     }
3476
3477     /* Parse the GL_VERSION field into major and minor information */
3478     gl_version_str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_VERSION);
3479     TRACE("GL_VERSION: %s.\n", debugstr_a(gl_version_str));
3480     if (!gl_version_str)
3481     {
3482         ERR("Received a NULL GL_VERSION.\n");
3483         return FALSE;
3484     }
3485     gl_version = wined3d_parse_gl_version(gl_version_str);
3486
3487     load_gl_funcs(gl_info);
3488
3489     memset(gl_info->supported, 0, sizeof(gl_info->supported));
3490     gl_info->supported[WINED3D_GL_EXT_NONE] = TRUE;
3491
3492     if (gl_version >= MAKEDWORD_VERSION(3, 2))
3493     {
3494         gl_info->gl_ops.gl.p_glGetIntegerv(GL_CONTEXT_PROFILE_MASK, &context_profile);
3495         checkGLcall("Querying context profile");
3496     }
3497     if (context_profile & GL_CONTEXT_CORE_PROFILE_BIT)
3498         TRACE("Got a core profile context.\n");
3499     else
3500         gl_info->supported[WINED3D_GL_LEGACY_CONTEXT] = TRUE;
3501
3502     TRACE("GL extensions reported:\n");
3503     if (gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
3504     {
3505         const char *gl_extensions = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_EXTENSIONS);
3506
3507         if (!gl_extensions)
3508         {
3509             ERR("Received a NULL GL_EXTENSIONS.\n");
3510             return FALSE;
3511         }
3512         parse_extension_string(gl_info, gl_extensions, gl_extension_map, ARRAY_SIZE(gl_extension_map));
3513     }
3514     else
3515     {
3516         enumerate_gl_extensions(gl_info, gl_extension_map, ARRAY_SIZE(gl_extension_map));
3517     }
3518
3519     hdc = wglGetCurrentDC();
3520     /* Not all GL drivers might offer WGL extensions e.g. VirtualBox. */
3521     if (GL_EXTCALL(wglGetExtensionsStringARB))
3522         WGL_Extensions = (const char *)GL_EXTCALL(wglGetExtensionsStringARB(hdc));
3523     if (!WGL_Extensions)
3524         WARN("WGL extensions not supported.\n");
3525     else
3526         parse_extension_string(gl_info, WGL_Extensions, wgl_extension_map, ARRAY_SIZE(wgl_extension_map));
3527
3528     for (i = 0; i < ARRAY_SIZE(core_extensions); ++i)
3529     {
3530         if (!gl_info->supported[core_extensions[i].extension]
3531                 && gl_version >= core_extensions[i].min_gl_version)
3532         {
3533             for (j = 0; j < ARRAY_SIZE(gl_extension_map); ++j)
3534                 if (gl_extension_map[j].extension == core_extensions[i].extension)
3535                     break;
3536
3537             if (j < ARRAY_SIZE(gl_extension_map))
3538             {
3539                 TRACE("GL CORE: %s support.\n", gl_extension_map[j].extension_string);
3540                 gl_info->supported[core_extensions[i].extension] = TRUE;
3541             }
3542             else
3543             {
3544                 FIXME("GL extension %u not in the GL extensions map.\n", core_extensions[i].extension);
3545             }
3546         }
3547     }
3548
3549     if (gl_info->supported[EXT_BLEND_MINMAX] || gl_info->supported[EXT_BLEND_SUBTRACT])
3550         gl_info->supported[WINED3D_GL_BLEND_EQUATION] = TRUE;
3551
3552     if (gl_version >= MAKEDWORD_VERSION(2, 0))
3553     {
3554         gl_info->supported[WINED3D_GL_VERSION_2_0] = TRUE;
3555         /* We want to use the core APIs for two-sided stencil in GL 2.0. */
3556         gl_info->supported[EXT_STENCIL_TWO_SIDE] = FALSE;
3557     }
3558     if (gl_version >= MAKEDWORD_VERSION(3, 2))
3559         gl_info->supported[WINED3D_GL_VERSION_3_2] = TRUE;
3560
3561     /* All the points are actually point sprites in core contexts, the APIs from
3562      * ARB_point_sprite are not supported anymore. */
3563     if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
3564         gl_info->supported[ARB_POINT_SPRITE] = FALSE;
3565
3566     if (gl_info->supported[APPLE_FENCE])
3567     {
3568         /* GL_NV_fence and GL_APPLE_fence provide the same functionality basically.
3569          * The apple extension interacts with some other apple exts. Disable the NV
3570          * extension if the apple one is support to prevent confusion in other parts
3571          * of the code. */
3572         gl_info->supported[NV_FENCE] = FALSE;
3573     }
3574     if (gl_info->supported[APPLE_FLOAT_PIXELS])
3575     {
3576         /* GL_APPLE_float_pixels == GL_ARB_texture_float + GL_ARB_half_float_pixel
3577          *
3578          * The enums are the same:
3579          * GL_RGBA16F_ARB     = GL_RGBA_FLOAT16_APPLE = 0x881a
3580          * GL_RGB16F_ARB      = GL_RGB_FLOAT16_APPLE  = 0x881b
3581          * GL_RGBA32F_ARB     = GL_RGBA_FLOAT32_APPLE = 0x8814
3582          * GL_RGB32F_ARB      = GL_RGB_FLOAT32_APPLE  = 0x8815
3583          * GL_HALF_FLOAT_ARB  = GL_HALF_APPLE         = 0x140b
3584          */
3585         if (!gl_info->supported[ARB_TEXTURE_FLOAT])
3586         {
3587             TRACE(" IMPLIED: GL_ARB_texture_float support (by GL_APPLE_float_pixels).\n");
3588             gl_info->supported[ARB_TEXTURE_FLOAT] = TRUE;
3589         }
3590         if (!gl_info->supported[ARB_HALF_FLOAT_PIXEL])
3591         {
3592             TRACE(" IMPLIED: GL_ARB_half_float_pixel support (by GL_APPLE_float_pixels).\n");
3593             gl_info->supported[ARB_HALF_FLOAT_PIXEL] = TRUE;
3594         }
3595     }
3596     if (gl_info->supported[ARB_MAP_BUFFER_RANGE])
3597     {
3598         /* GL_ARB_map_buffer_range and GL_APPLE_flush_buffer_range provide the same
3599          * functionality. Prefer the ARB extension */
3600         gl_info->supported[APPLE_FLUSH_BUFFER_RANGE] = FALSE;
3601     }
3602     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
3603     {
3604         TRACE(" IMPLIED: NVIDIA (NV) Texture Gen Reflection support.\n");
3605         gl_info->supported[NV_TEXGEN_REFLECTION] = TRUE;
3606     }
3607     if (!gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC])
3608     {
3609         TRACE(" IMPLIED: EXT_texture_compression_rgtc support (by ARB_texture_compression_rgtc).\n");
3610         gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC] = TRUE;
3611     }
3612     if (!gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && gl_info->supported[EXT_TEXTURE_COMPRESSION_RGTC])
3613     {
3614         TRACE(" IMPLIED: ARB_texture_compression_rgtc support (by EXT_texture_compression_rgtc).\n");
3615         gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = TRUE;
3616     }
3617     if (gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] && !gl_info->supported[ARB_TEXTURE_RG])
3618     {
3619         TRACE("ARB_texture_rg not supported, disabling ARB_texture_compression_rgtc.\n");
3620         gl_info->supported[ARB_TEXTURE_COMPRESSION_RGTC] = FALSE;
3621     }
3622     if (gl_info->supported[NV_TEXTURE_SHADER2])
3623     {
3624         if (gl_info->supported[NV_REGISTER_COMBINERS])
3625         {
3626             /* Also disable ATI_FRAGMENT_SHADER if register combiners and texture_shader2
3627              * are supported. The nv extensions provide the same functionality as the
3628              * ATI one, and a bit more(signed pixelformats). */
3629             gl_info->supported[ATI_FRAGMENT_SHADER] = FALSE;
3630         }
3631     }
3632     if (gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO])
3633     {
3634         /* If we have full NP2 texture support, disable
3635          * GL_ARB_texture_rectangle because we will never use it.
3636          * This saves a few redundant glDisable calls. */
3637         gl_info->supported[ARB_TEXTURE_RECTANGLE] = FALSE;
3638     }
3639     if (gl_info->supported[ATI_FRAGMENT_SHADER])
3640     {
3641         /* Disable NV_register_combiners and fragment shader if this is supported.
3642          * generally the NV extensions are preferred over the ATI ones, and this
3643          * extension is disabled if register_combiners and texture_shader2 are both
3644          * supported. So we reach this place only if we have incomplete NV dxlevel 8
3645          * fragment processing support. */
3646         gl_info->supported[NV_REGISTER_COMBINERS] = FALSE;
3647         gl_info->supported[NV_REGISTER_COMBINERS2] = FALSE;
3648         gl_info->supported[NV_TEXTURE_SHADER] = FALSE;
3649         gl_info->supported[NV_TEXTURE_SHADER2] = FALSE;
3650     }
3651     if (gl_info->supported[NV_HALF_FLOAT])
3652     {
3653         /* GL_ARB_half_float_vertex is a subset of GL_NV_half_float. */
3654         gl_info->supported[ARB_HALF_FLOAT_VERTEX] = TRUE;
3655     }
3656     if (gl_info->supported[ARB_FRAMEBUFFER_SRGB] && !gl_info->supported[EXT_TEXTURE_SRGB_DECODE])
3657     {
3658         /* Current wined3d sRGB infrastructure requires EXT_texture_sRGB_decode
3659          * for GL_ARB_framebuffer_sRGB support (without EXT_texture_sRGB_decode
3660          * we never render to sRGB surfaces). */
3661         TRACE("EXT_texture_sRGB_decode is not supported, disabling ARB_framebuffer_sRGB.\n");
3662         gl_info->supported[ARB_FRAMEBUFFER_SRGB] = FALSE;
3663     }
3664     if (gl_info->supported[ARB_OCCLUSION_QUERY])
3665     {
3666         GLint counter_bits;
3667
3668         GL_EXTCALL(glGetQueryiv(GL_SAMPLES_PASSED, GL_QUERY_COUNTER_BITS, &counter_bits));
3669         TRACE("Occlusion query counter has %d bits.\n", counter_bits);
3670         if (!counter_bits)
3671             gl_info->supported[ARB_OCCLUSION_QUERY] = FALSE;
3672     }
3673     if (gl_info->supported[ARB_TIMER_QUERY])
3674     {
3675         GLint counter_bits;
3676
3677         GL_EXTCALL(glGetQueryiv(GL_TIMESTAMP, GL_QUERY_COUNTER_BITS, &counter_bits));
3678         TRACE("Timestamp query counter has %d bits.\n", counter_bits);
3679         if (!counter_bits)
3680             gl_info->supported[ARB_TIMER_QUERY] = FALSE;
3681     }
3682     if (gl_version >= MAKEDWORD_VERSION(3, 0))
3683     {
3684         GLint counter_bits;
3685
3686         gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY] = TRUE;
3687
3688         GL_EXTCALL(glGetQueryiv(GL_PRIMITIVES_GENERATED, GL_QUERY_COUNTER_BITS, &counter_bits));
3689         TRACE("Primitives query counter has %d bits.\n", counter_bits);
3690         if (!counter_bits)
3691             gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY] = FALSE;
3692
3693         GL_EXTCALL(glGetQueryiv(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, GL_QUERY_COUNTER_BITS, &counter_bits));
3694         TRACE("Transform feedback primitives query counter has %d bits.\n", counter_bits);
3695         if (!counter_bits)
3696             gl_info->supported[WINED3D_GL_PRIMITIVE_QUERY] = FALSE;
3697     }
3698     if (gl_info->supported[ARB_VIEWPORT_ARRAY])
3699     {
3700         GLint subpixel_bits;
3701
3702         gl_info->gl_ops.gl.p_glGetIntegerv(GL_VIEWPORT_SUBPIXEL_BITS, &subpixel_bits);
3703         TRACE("Viewport supports %d subpixel bits.\n", subpixel_bits);
3704         if (subpixel_bits < 8 && gl_info->supported[ARB_CLIP_CONTROL])
3705         {
3706             TRACE("Disabling ARB_clip_control because viewport subpixel bits < 8.\n");
3707             gl_info->supported[ARB_CLIP_CONTROL] = FALSE;
3708         }
3709     }
3710     if (gl_info->supported[ARB_CLIP_CONTROL] && !gl_info->supported[ARB_VIEWPORT_ARRAY])
3711     {
3712         /* When using ARB_clip_control we need the float viewport parameters
3713          * introduced by ARB_viewport_array to take care of the shifted pixel
3714          * coordinates. */
3715         TRACE("Disabling ARB_clip_control because ARB_viewport_array is not supported.\n");
3716         gl_info->supported[ARB_CLIP_CONTROL] = FALSE;
3717     }
3718     if (gl_info->supported[ARB_STENCIL_TEXTURING] && !gl_info->supported[ARB_TEXTURE_SWIZZLE])
3719     {
3720         /* The stencil value needs to be placed in the green channel.  */
3721         TRACE("Disabling ARB_stencil_texturing because ARB_texture_swizzle is not supported.\n");
3722         gl_info->supported[ARB_STENCIL_TEXTURING] = FALSE;
3723     }
3724     if (!gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] && gl_info->supported[EXT_TEXTURE_MIRROR_CLAMP])
3725     {
3726         TRACE(" IMPLIED: ATI_texture_mirror_once support (by EXT_texture_mirror_clamp).\n");
3727         gl_info->supported[ATI_TEXTURE_MIRROR_ONCE] = TRUE;
3728     }
3729     if (!gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] && gl_info->supported[ATI_TEXTURE_MIRROR_ONCE])
3730     {
3731         TRACE(" IMPLIED: ARB_texture_mirror_clamp_to_edge support (by ATI_texture_mirror_once).\n");
3732         gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] = TRUE;
3733     }
3734     if (gl_info->supported[ARB_TEXTURE_STORAGE] && gl_info->supported[APPLE_YCBCR_422])
3735     {
3736         /* AFAIK APPLE_ycbcr_422 is only available in legacy contexts so we shouldn't ever hit this. */
3737         ERR("Disabling APPLE_ycbcr_422 because of ARB_texture_storage.\n");
3738         gl_info->supported[APPLE_YCBCR_422] = FALSE;
3739     }
3740     if (gl_info->supported[ARB_DRAW_INDIRECT] && !gl_info->supported[ARB_BASE_INSTANCE])
3741     {
3742         /* If ARB_base_instance is not supported the baseInstance field
3743          * in indirect draw parameters must be 0 or behavior is undefined.
3744          */
3745         WARN("Disabling ARB_draw_indirect because ARB_base_instance is not supported.\n");
3746         gl_info->supported[ARB_DRAW_INDIRECT] = FALSE;
3747     }
3748     if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE] && !wined3d_settings.multisample_textures)
3749         gl_info->supported[ARB_TEXTURE_MULTISAMPLE] = FALSE;
3750     if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE] && !gl_info->supported[ARB_TEXTURE_STORAGE_MULTISAMPLE])
3751     {
3752         WARN("Disabling ARB_texture_multisample because immutable storage is not supported.\n");
3753         gl_info->supported[ARB_TEXTURE_MULTISAMPLE] = FALSE;
3754     }
3755     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT] && !gl_info->supported[EXT_PACKED_DEPTH_STENCIL])
3756     {
3757         TRACE(" IMPLIED: GL_EXT_packed_depth_stencil (by GL_ARB_framebuffer_object).\n");
3758         gl_info->supported[EXT_PACKED_DEPTH_STENCIL] = TRUE;
3759     }
3760
3761     wined3d_adapter_init_limits(gl_info);
3762
3763     if (gl_info->supported[ARB_VERTEX_PROGRAM] && test_arb_vs_offset_limit(gl_info))
3764         gl_info->quirks |= WINED3D_QUIRK_ARB_VS_OFFSET_LIMIT;
3765
3766     if (gl_info->supported[ARB_SHADING_LANGUAGE_100])
3767     {
3768         const char *str = (const char *)gl_info->gl_ops.gl.p_glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
3769         unsigned int major, minor;
3770
3771         TRACE("GLSL version string: %s.\n", debugstr_a(str));
3772
3773         /* The format of the GLSL version string is "major.minor[.release] [vendor info]". */
3774         sscanf(str, "%u.%u", &major, &minor);
3775         gl_info->glsl_version = MAKEDWORD_VERSION(major, minor);
3776         if (gl_info->glsl_version > MAKEDWORD_VERSION(1, 30) && gl_version < MAKEDWORD_VERSION(3, 0))
3777         {
3778             WARN("OpenGL version %u.%u too low, limiting GLSL version to 1.30.\n",
3779                     gl_version >> 16, gl_version & 0xffff);
3780             gl_info->glsl_version = MAKEDWORD_VERSION(1, 30);
3781         }
3782         if (gl_info->glsl_version >= MAKEDWORD_VERSION(1, 30))
3783             gl_info->supported[WINED3D_GLSL_130] = TRUE;
3784     }
3785
3786     checkGLcall("extension detection");
3787
3788     adapter->shader_backend = select_shader_backend(gl_info);
3789     adapter->vertex_pipe = select_vertex_implementation(gl_info, adapter->shader_backend);
3790     adapter->fragment_pipe = select_fragment_implementation(gl_info, adapter->shader_backend);
3791
3792     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT])
3793     {
3794         gl_info->fbo_ops.glIsRenderbuffer = gl_info->gl_ops.ext.p_glIsRenderbuffer;
3795         gl_info->fbo_ops.glBindRenderbuffer = gl_info->gl_ops.ext.p_glBindRenderbuffer;
3796         gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->gl_ops.ext.p_glDeleteRenderbuffers;
3797         gl_info->fbo_ops.glGenRenderbuffers = gl_info->gl_ops.ext.p_glGenRenderbuffers;
3798         gl_info->fbo_ops.glRenderbufferStorage = gl_info->gl_ops.ext.p_glRenderbufferStorage;
3799         gl_info->fbo_ops.glRenderbufferStorageMultisample = gl_info->gl_ops.ext.p_glRenderbufferStorageMultisample;
3800         gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->gl_ops.ext.p_glGetRenderbufferParameteriv;
3801         gl_info->fbo_ops.glIsFramebuffer = gl_info->gl_ops.ext.p_glIsFramebuffer;
3802         gl_info->fbo_ops.glBindFramebuffer = gl_info->gl_ops.ext.p_glBindFramebuffer;
3803         gl_info->fbo_ops.glDeleteFramebuffers = gl_info->gl_ops.ext.p_glDeleteFramebuffers;
3804         gl_info->fbo_ops.glGenFramebuffers = gl_info->gl_ops.ext.p_glGenFramebuffers;
3805         gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->gl_ops.ext.p_glCheckFramebufferStatus;
3806         gl_info->fbo_ops.glFramebufferTexture1D = gl_info->gl_ops.ext.p_glFramebufferTexture1D;
3807         gl_info->fbo_ops.glFramebufferTexture2D = gl_info->gl_ops.ext.p_glFramebufferTexture2D;
3808         gl_info->fbo_ops.glFramebufferTexture3D = gl_info->gl_ops.ext.p_glFramebufferTexture3D;
3809         gl_info->fbo_ops.glFramebufferTextureLayer = gl_info->gl_ops.ext.p_glFramebufferTextureLayer;
3810         gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->gl_ops.ext.p_glFramebufferRenderbuffer;
3811         gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv
3812                 = gl_info->gl_ops.ext.p_glGetFramebufferAttachmentParameteriv;
3813         gl_info->fbo_ops.glBlitFramebuffer = gl_info->gl_ops.ext.p_glBlitFramebuffer;
3814         gl_info->fbo_ops.glGenerateMipmap = gl_info->gl_ops.ext.p_glGenerateMipmap;
3815         gl_info->fbo_ops.glFramebufferTexture = gl_info->gl_ops.ext.p_glFramebufferTexture;
3816     }
3817     else
3818     {
3819         if (gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
3820         {
3821             gl_info->fbo_ops.glIsRenderbuffer = gl_info->gl_ops.ext.p_glIsRenderbufferEXT;
3822             gl_info->fbo_ops.glBindRenderbuffer = gl_info->gl_ops.ext.p_glBindRenderbufferEXT;
3823             gl_info->fbo_ops.glDeleteRenderbuffers = gl_info->gl_ops.ext.p_glDeleteRenderbuffersEXT;
3824             gl_info->fbo_ops.glGenRenderbuffers = gl_info->gl_ops.ext.p_glGenRenderbuffersEXT;
3825             gl_info->fbo_ops.glRenderbufferStorage = gl_info->gl_ops.ext.p_glRenderbufferStorageEXT;
3826             gl_info->fbo_ops.glGetRenderbufferParameteriv = gl_info->gl_ops.ext.p_glGetRenderbufferParameterivEXT;
3827             gl_info->fbo_ops.glIsFramebuffer = gl_info->gl_ops.ext.p_glIsFramebufferEXT;
3828             gl_info->fbo_ops.glBindFramebuffer = gl_info->gl_ops.ext.p_glBindFramebufferEXT;
3829             gl_info->fbo_ops.glDeleteFramebuffers = gl_info->gl_ops.ext.p_glDeleteFramebuffersEXT;
3830             gl_info->fbo_ops.glGenFramebuffers = gl_info->gl_ops.ext.p_glGenFramebuffersEXT;
3831             gl_info->fbo_ops.glCheckFramebufferStatus = gl_info->gl_ops.ext.p_glCheckFramebufferStatusEXT;
3832             gl_info->fbo_ops.glFramebufferTexture1D = gl_info->gl_ops.ext.p_glFramebufferTexture1DEXT;
3833             gl_info->fbo_ops.glFramebufferTexture2D = gl_info->gl_ops.ext.p_glFramebufferTexture2DEXT;
3834             gl_info->fbo_ops.glFramebufferTexture3D = gl_info->gl_ops.ext.p_glFramebufferTexture3DEXT;
3835             gl_info->fbo_ops.glFramebufferRenderbuffer = gl_info->gl_ops.ext.p_glFramebufferRenderbufferEXT;
3836             gl_info->fbo_ops.glGetFramebufferAttachmentParameteriv
3837                     = gl_info->gl_ops.ext.p_glGetFramebufferAttachmentParameterivEXT;
3838             gl_info->fbo_ops.glGenerateMipmap = gl_info->gl_ops.ext.p_glGenerateMipmapEXT;
3839         }
3840         else if (wined3d_settings.offscreen_rendering_mode == ORM_FBO)
3841         {
3842             WARN_(d3d_perf)("Framebuffer objects not supported, falling back to backbuffer offscreen rendering mode.\n");
3843             wined3d_settings.offscreen_rendering_mode = ORM_BACKBUFFER;
3844         }
3845
3846         if (gl_info->supported[ARB_GEOMETRY_SHADER4])
3847         {
3848             gl_info->fbo_ops.glFramebufferTexture = gl_info->gl_ops.ext.p_glFramebufferTextureARB;
3849             gl_info->fbo_ops.glFramebufferTextureLayer = gl_info->gl_ops.ext.p_glFramebufferTextureLayerARB;
3850         }
3851         if (gl_info->supported[EXT_FRAMEBUFFER_BLIT])
3852         {
3853             gl_info->fbo_ops.glBlitFramebuffer = gl_info->gl_ops.ext.p_glBlitFramebufferEXT;
3854         }
3855         if (gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE])
3856         {
3857             gl_info->fbo_ops.glRenderbufferStorageMultisample
3858                     = gl_info->gl_ops.ext.p_glRenderbufferStorageMultisampleEXT;
3859         }
3860     }
3861
3862     gl_info->wrap_lookup[WINED3D_TADDRESS_WRAP - WINED3D_TADDRESS_WRAP] = GL_REPEAT;
3863     gl_info->wrap_lookup[WINED3D_TADDRESS_MIRROR - WINED3D_TADDRESS_WRAP] =
3864             gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT] ? GL_MIRRORED_REPEAT_ARB : GL_REPEAT;
3865     gl_info->wrap_lookup[WINED3D_TADDRESS_CLAMP - WINED3D_TADDRESS_WRAP] = GL_CLAMP_TO_EDGE;
3866     gl_info->wrap_lookup[WINED3D_TADDRESS_BORDER - WINED3D_TADDRESS_WRAP] =
3867             gl_info->supported[ARB_TEXTURE_BORDER_CLAMP] ? GL_CLAMP_TO_BORDER_ARB : GL_REPEAT;
3868     gl_info->wrap_lookup[WINED3D_TADDRESS_MIRROR_ONCE - WINED3D_TADDRESS_WRAP] =
3869             gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE] ? GL_MIRROR_CLAMP_TO_EDGE : GL_REPEAT;
3870
3871     if (!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT])
3872     {
3873         GLuint vao;
3874
3875         GL_EXTCALL(glGenVertexArrays(1, &vao));
3876         GL_EXTCALL(glBindVertexArray(vao));
3877         checkGLcall("creating VAO");
3878     }
3879
3880     gl_vendor = wined3d_guess_gl_vendor(gl_info, gl_vendor_str, gl_renderer_str, gl_version_str);
3881     TRACE("Guessed GL vendor %#x.\n", gl_vendor);
3882
3883     if (!(gpu_description = query_gpu_description(gl_info, &vram_bytes)))
3884     {
3885         enum wined3d_feature_level feature_level;
3886         struct fragment_caps fragment_caps;
3887         enum wined3d_pci_vendor vendor;
3888         enum wined3d_pci_device device;
3889         struct shader_caps shader_caps;
3890
3891         adapter->shader_backend->shader_get_caps(adapter, &shader_caps);
3892         adapter->fragment_pipe->get_caps(adapter, &fragment_caps);
3893         feature_level = feature_level_from_caps(gl_info, &shader_caps, &fragment_caps);
3894
3895         vendor = wined3d_guess_card_vendor(gl_vendor_str, gl_renderer_str);
3896         TRACE("Guessed vendor PCI ID 0x%04x.\n", vendor);
3897
3898         device = wined3d_guess_card(feature_level, gl_renderer_str, &gl_vendor, &vendor);
3899         TRACE("Guessed device PCI ID 0x%04x.\n", device);
3900
3901         if (!(gpu_description = wined3d_get_gpu_description(vendor, device)))
3902         {
3903             ERR("Card %04x:%04x not found in driver DB.\n", vendor, device);
3904             return FALSE;
3905         }
3906     }
3907     fixup_extensions(gl_info, caps_gl_ctx, gl_renderer_str, gl_vendor,
3908             gpu_description->vendor, gpu_description->device);
3909     wined3d_driver_info_init(driver_info, gpu_description, vram_bytes, 0);
3910     TRACE("Reporting (fake) driver version 0x%08x-0x%08x.\n",
3911             driver_info->version_high, driver_info->version_low);
3912
3913     adapter->vram_bytes_used = 0;
3914     TRACE("Emulating 0x%s bytes of video ram.\n", wine_dbgstr_longlong(driver_info->vram_bytes));
3915
3916     if (gl_info->supported[EXT_MEMORY_OBJECT])
3917     {
3918         GLint device_count = 0;
3919
3920         gl_info->gl_ops.gl.p_glGetIntegerv(GL_NUM_DEVICE_UUIDS_EXT, &device_count);
3921         if (device_count > 0)
3922         {
3923             if (device_count > 1)
3924                 FIXME("A set of %d devices is not supported.\n", device_count);
3925
3926             GL_EXTCALL(glGetUnsignedBytevEXT(GL_DRIVER_UUID_EXT, (GLubyte *)&adapter->driver_uuid));
3927             GL_EXTCALL(glGetUnsignedBytei_vEXT(GL_DEVICE_UUID_EXT, 0, (GLubyte *)&adapter->device_uuid));
3928
3929             TRACE("Driver UUID: %s, device UUID %s.\n",
3930                     debugstr_guid(&adapter->driver_uuid), debugstr_guid(&adapter->device_uuid));
3931         }
3932         else
3933         {
3934             WARN("Unexpected device count %d.\n", device_count);
3935         }
3936     }
3937
3938     gl_ext_emul_mask = adapter->vertex_pipe->vp_get_emul_mask(gl_info)
3939             | adapter->fragment_pipe->get_emul_mask(gl_info);
3940     if (gl_ext_emul_mask & GL_EXT_EMUL_ARB_MULTITEXTURE)
3941         install_gl_compat_wrapper(gl_info, ARB_MULTITEXTURE);
3942     if (gl_ext_emul_mask & GL_EXT_EMUL_EXT_FOG_COORD)
3943         install_gl_compat_wrapper(gl_info, EXT_FOG_COORD);
3944
3945     return TRUE;
3946 }
3947
3948 static void WINE_GLAPI invalid_func(const void *data)
3949 {
3950     ERR("Invalid vertex attribute function called.\n");
3951     DebugBreak();
3952 }
3953
3954 static void WINE_GLAPI invalid_texcoord_func(GLenum unit, const void *data)
3955 {
3956     ERR("Invalid texcoord function called.\n");
3957     DebugBreak();
3958 }
3959
3960 static void WINE_GLAPI invalid_generic_attrib_func(GLuint idx, const void *data)
3961 {
3962     ERR("Invalid attribute function called.\n");
3963     DebugBreak();
3964 }
3965
3966 /* Helper functions for providing vertex data to OpenGL. The arrays are
3967  * initialised based on the extension detection and are used in
3968  * draw_primitive_immediate_mode(). */
3969 static void WINE_GLAPI position_d3dcolor(const void *data)
3970 {
3971     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
3972     DWORD pos = *((const DWORD *)data);
3973
3974     FIXME("Add a test for fixed function position from d3dcolor type.\n");
3975     gl_info->gl_ops.gl.p_glVertex4s(D3DCOLOR_B_R(pos),
3976             D3DCOLOR_B_G(pos),
3977             D3DCOLOR_B_B(pos),
3978             D3DCOLOR_B_A(pos));
3979 }
3980
3981 static void WINE_GLAPI position_float4(const void *data)
3982 {
3983     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
3984     const GLfloat *pos = data;
3985
3986     if (pos[3] != 0.0f && pos[3] != 1.0f)
3987     {
3988         float w = 1.0f / pos[3];
3989
3990         gl_info->gl_ops.gl.p_glVertex4f(pos[0] * w, pos[1] * w, pos[2] * w, w);
3991     }
3992     else
3993     {
3994         gl_info->gl_ops.gl.p_glVertex3fv(pos);
3995     }
3996 }
3997
3998 static void WINE_GLAPI diffuse_d3dcolor(const void *data)
3999 {
4000     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
4001     DWORD diffuseColor = *((const DWORD *)data);
4002
4003     gl_info->gl_ops.gl.p_glColor4ub(D3DCOLOR_B_R(diffuseColor),
4004             D3DCOLOR_B_G(diffuseColor),
4005             D3DCOLOR_B_B(diffuseColor),
4006             D3DCOLOR_B_A(diffuseColor));
4007 }
4008
4009 static void WINE_GLAPI specular_d3dcolor(const void *data)
4010 {
4011     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
4012     DWORD specularColor = *((const DWORD *)data);
4013     GLubyte d[] =
4014     {
4015         D3DCOLOR_B_R(specularColor),
4016         D3DCOLOR_B_G(specularColor),
4017         D3DCOLOR_B_B(specularColor)
4018     };
4019
4020     gl_info->gl_ops.ext.p_glSecondaryColor3ubvEXT(d);
4021 }
4022
4023 static void WINE_GLAPI warn_no_specular_func(const void *data)
4024 {
4025     WARN("GL_EXT_secondary_color not supported.\n");
4026 }
4027
4028 static void WINE_GLAPI generic_d3dcolor(GLuint idx, const void *data)
4029 {
4030     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
4031     DWORD color = *((const DWORD *)data);
4032
4033     gl_info->gl_ops.ext.p_glVertexAttrib4Nub(idx,
4034             D3DCOLOR_B_R(color), D3DCOLOR_B_G(color),
4035             D3DCOLOR_B_B(color), D3DCOLOR_B_A(color));
4036 }
4037
4038 static void WINE_GLAPI generic_short2n(GLuint idx, const void *data)
4039 {
4040     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
4041     const GLshort s[] = {((const GLshort *)data)[0], ((const GLshort *)data)[1], 0, 1};
4042
4043     gl_info->gl_ops.ext.p_glVertexAttrib4Nsv(idx, s);
4044 }
4045
4046 static void WINE_GLAPI generic_ushort2n(GLuint idx, const void *data)
4047 {
4048     const GLushort s[] = {((const GLushort *)data)[0], ((const GLushort *)data)[1], 0, 1};
4049     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
4050
4051     gl_info->gl_ops.ext.p_glVertexAttrib4Nusv(idx, s);
4052 }
4053
4054 static void WINE_GLAPI generic_float16_2(GLuint idx, const void *data)
4055 {
4056     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
4057     float x = float_16_to_32(((const unsigned short *)data) + 0);
4058     float y = float_16_to_32(((const unsigned short *)data) + 1);
4059
4060     gl_info->gl_ops.ext.p_glVertexAttrib2f(idx, x, y);
4061 }
4062
4063 static void WINE_GLAPI generic_float16_4(GLuint idx, const void *data)
4064 {
4065     const struct wined3d_gl_info *gl_info = wined3d_context_gl_get_current()->gl_info;
4066     float x = float_16_to_32(((const unsigned short *)data) + 0);
4067     float y = float_16_to_32(((const unsigned short *)data) + 1);
4068     float z = float_16_to_32(((const unsigned short *)data) + 2);
4069     float w = float_16_to_32(((const unsigned short *)data) + 3);
4070
4071     gl_info->gl_ops.ext.p_glVertexAttrib4f(idx, x, y, z, w);
4072 }
4073
4074 static void wined3d_adapter_init_ffp_attrib_ops(struct wined3d_adapter *adapter)
4075 {
4076     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4077     struct wined3d_d3d_info *d3d_info = &adapter->d3d_info;
4078     struct wined3d_ffp_attrib_ops *ops = &d3d_info->ffp_attrib_ops;
4079     unsigned int i;
4080
4081     for (i = 0; i < WINED3D_FFP_EMIT_COUNT; ++i)
4082     {
4083         ops->position[i] = invalid_func;
4084         ops->diffuse[i]  = invalid_func;
4085         ops->specular[i] = invalid_func;
4086         ops->normal[i]   = invalid_func;
4087         ops->texcoord[i] = invalid_texcoord_func;
4088         ops->generic[i]  = invalid_generic_attrib_func;
4089     }
4090
4091     ops->position[WINED3D_FFP_EMIT_FLOAT3]    = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex3fv;
4092     if (!d3d_info->xyzrhw)
4093         ops->position[WINED3D_FFP_EMIT_FLOAT4]    = position_float4;
4094     else
4095         ops->position[WINED3D_FFP_EMIT_FLOAT4]    = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex4fv;
4096     ops->position[WINED3D_FFP_EMIT_D3DCOLOR]  = position_d3dcolor;
4097     ops->position[WINED3D_FFP_EMIT_SHORT4]    = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glVertex2sv;
4098
4099     ops->diffuse[WINED3D_FFP_EMIT_FLOAT3]     = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor3fv;
4100     ops->diffuse[WINED3D_FFP_EMIT_FLOAT4]     = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4fv;
4101     ops->diffuse[WINED3D_FFP_EMIT_D3DCOLOR]   = diffuse_d3dcolor;
4102     ops->diffuse[WINED3D_FFP_EMIT_UBYTE4N]    = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4ubv;
4103     ops->diffuse[WINED3D_FFP_EMIT_SHORT4N]    = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4sv;
4104     ops->diffuse[WINED3D_FFP_EMIT_USHORT4N]   = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glColor4usv;
4105
4106     /* No 4 component entry points here. */
4107     if (gl_info->supported[EXT_SECONDARY_COLOR])
4108         ops->specular[WINED3D_FFP_EMIT_FLOAT3]    = (wined3d_ffp_attrib_func)GL_EXTCALL(glSecondaryColor3fvEXT);
4109     else
4110         ops->specular[WINED3D_FFP_EMIT_FLOAT3]    = warn_no_specular_func;
4111     if (gl_info->supported[EXT_SECONDARY_COLOR])
4112         ops->specular[WINED3D_FFP_EMIT_D3DCOLOR]  = specular_d3dcolor;
4113     else
4114         ops->specular[WINED3D_FFP_EMIT_D3DCOLOR]  = warn_no_specular_func;
4115
4116     /* Only 3 component entry points here. Test how others behave. Float4
4117      * normals are used by one of our tests, trying to pass it to the pixel
4118      * shader, which fails on Windows. */
4119     ops->normal[WINED3D_FFP_EMIT_FLOAT3]      = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glNormal3fv;
4120     /* Just ignore the 4th value. */
4121     ops->normal[WINED3D_FFP_EMIT_FLOAT4]      = (wined3d_ffp_attrib_func)gl_info->gl_ops.gl.p_glNormal3fv;
4122
4123     ops->texcoord[WINED3D_FFP_EMIT_FLOAT1]    = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord1fvARB;
4124     ops->texcoord[WINED3D_FFP_EMIT_FLOAT2]    = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2fvARB;
4125     ops->texcoord[WINED3D_FFP_EMIT_FLOAT3]    = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord3fvARB;
4126     ops->texcoord[WINED3D_FFP_EMIT_FLOAT4]    = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4fvARB;
4127     ops->texcoord[WINED3D_FFP_EMIT_SHORT2]    = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2svARB;
4128     ops->texcoord[WINED3D_FFP_EMIT_SHORT4]    = (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4svARB;
4129     if (gl_info->supported[NV_HALF_FLOAT])
4130     {
4131         /* Not supported by ARB_HALF_FLOAT_VERTEX, so check for NV_HALF_FLOAT. */
4132         ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_2] =
4133                 (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord2hvNV;
4134         ops->texcoord[WINED3D_FFP_EMIT_FLOAT16_4] =
4135                 (wined3d_ffp_texcoord_func)gl_info->gl_ops.ext.p_glMultiTexCoord4hvNV;
4136     }
4137
4138     ops->generic[WINED3D_FFP_EMIT_FLOAT1]     = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib1fv;
4139     ops->generic[WINED3D_FFP_EMIT_FLOAT2]     = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib2fv;
4140     ops->generic[WINED3D_FFP_EMIT_FLOAT3]     = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib3fv;
4141     ops->generic[WINED3D_FFP_EMIT_FLOAT4]     = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4fv;
4142     if (gl_info->supported[ARB_VERTEX_ARRAY_BGRA])
4143         ops->generic[WINED3D_FFP_EMIT_D3DCOLOR] = generic_d3dcolor;
4144     else
4145         ops->generic[WINED3D_FFP_EMIT_D3DCOLOR] =
4146                 (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nubv;
4147     ops->generic[WINED3D_FFP_EMIT_UBYTE4]     = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4ubv;
4148     ops->generic[WINED3D_FFP_EMIT_SHORT2]     = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib2sv;
4149     ops->generic[WINED3D_FFP_EMIT_SHORT4]     = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4sv;
4150     ops->generic[WINED3D_FFP_EMIT_UBYTE4N]    = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nubv;
4151     ops->generic[WINED3D_FFP_EMIT_SHORT2N]    = generic_short2n;
4152     ops->generic[WINED3D_FFP_EMIT_SHORT4N]    = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nsv;
4153     ops->generic[WINED3D_FFP_EMIT_USHORT2N]   = generic_ushort2n;
4154     ops->generic[WINED3D_FFP_EMIT_USHORT4N]   = (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4Nusv;
4155     if (gl_info->supported[NV_HALF_FLOAT] && gl_info->supported[NV_VERTEX_PROGRAM])
4156     {
4157         ops->generic[WINED3D_FFP_EMIT_FLOAT16_2] =
4158                 (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib2hvNV;
4159         ops->generic[WINED3D_FFP_EMIT_FLOAT16_4] =
4160                 (wined3d_generic_attrib_func)gl_info->gl_ops.ext.p_glVertexAttrib4hvNV;
4161     }
4162     else
4163     {
4164         ops->generic[WINED3D_FFP_EMIT_FLOAT16_2] = generic_float16_2;
4165         ops->generic[WINED3D_FFP_EMIT_FLOAT16_4] = generic_float16_4;
4166     }
4167 }
4168
4169 static void wined3d_adapter_init_fb_cfgs(struct wined3d_adapter_gl *adapter_gl, HDC dc)
4170 {
4171     const struct wined3d_gl_info *gl_info = &adapter_gl->a.gl_info;
4172     int i;
4173
4174     if (gl_info->supported[WGL_ARB_PIXEL_FORMAT])
4175     {
4176         UINT attrib_count = 0;
4177         GLint cfg_count;
4178         int attribs[11];
4179         int values[11];
4180         int attribute;
4181
4182         attribute = WGL_NUMBER_PIXEL_FORMATS_ARB;
4183         GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, 0, 0, 1, &attribute, &cfg_count));
4184
4185         adapter_gl->pixel_formats = heap_calloc(cfg_count, sizeof(*adapter_gl->pixel_formats));
4186         attribs[attrib_count++] = WGL_RED_BITS_ARB;
4187         attribs[attrib_count++] = WGL_GREEN_BITS_ARB;
4188         attribs[attrib_count++] = WGL_BLUE_BITS_ARB;
4189         attribs[attrib_count++] = WGL_ALPHA_BITS_ARB;
4190         attribs[attrib_count++] = WGL_COLOR_BITS_ARB;
4191         attribs[attrib_count++] = WGL_DEPTH_BITS_ARB;
4192         attribs[attrib_count++] = WGL_STENCIL_BITS_ARB;
4193         attribs[attrib_count++] = WGL_DRAW_TO_WINDOW_ARB;
4194         attribs[attrib_count++] = WGL_PIXEL_TYPE_ARB;
4195         attribs[attrib_count++] = WGL_DOUBLE_BUFFER_ARB;
4196         attribs[attrib_count++] = WGL_AUX_BUFFERS_ARB;
4197
4198         for (i = 0, adapter_gl->pixel_format_count = 0; i < cfg_count; ++i)
4199         {
4200             struct wined3d_pixel_format *cfg = &adapter_gl->pixel_formats[adapter_gl->pixel_format_count];
4201             int format_id = i + 1;
4202
4203             if (!GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, format_id, 0, attrib_count, attribs, values)))
4204                 continue;
4205
4206             cfg->iPixelFormat = format_id;
4207             cfg->redSize = values[0];
4208             cfg->greenSize = values[1];
4209             cfg->blueSize = values[2];
4210             cfg->alphaSize = values[3];
4211             cfg->colorSize = values[4];
4212             cfg->depthSize = values[5];
4213             cfg->stencilSize = values[6];
4214             cfg->windowDrawable = values[7];
4215             cfg->iPixelType = values[8];
4216             cfg->doubleBuffer = values[9];
4217             cfg->auxBuffers = values[10];
4218
4219             cfg->numSamples = 0;
4220             /* Check multisample support. */
4221             if (gl_info->supported[ARB_MULTISAMPLE])
4222             {
4223                 int attribs[2] = {WGL_SAMPLE_BUFFERS_ARB, WGL_SAMPLES_ARB};
4224                 int values[2];
4225
4226                 if (GL_EXTCALL(wglGetPixelFormatAttribivARB(dc, format_id, 0, 2, attribs, values)))
4227                 {
4228                     /* values[0] = WGL_SAMPLE_BUFFERS_ARB which tells whether
4229                      * multisampling is supported. values[1] = number of
4230                      * multisample buffers. */
4231                     if (values[0])
4232                         cfg->numSamples = values[1];
4233                 }
4234             }
4235
4236             TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
4237                     "depth=%d, stencil=%d, samples=%d, windowDrawable=%d\n",
4238                     cfg->iPixelFormat, cfg->iPixelType, cfg->doubleBuffer,
4239                     cfg->redSize, cfg->greenSize, cfg->blueSize, cfg->alphaSize,
4240                     cfg->depthSize, cfg->stencilSize, cfg->numSamples, cfg->windowDrawable);
4241
4242             ++adapter_gl->pixel_format_count;
4243         }
4244     }
4245     else
4246     {
4247         int cfg_count;
4248
4249         cfg_count = DescribePixelFormat(dc, 0, 0, 0);
4250         adapter_gl->pixel_formats = heap_calloc(cfg_count, sizeof(*adapter_gl->pixel_formats));
4251
4252         for (i = 0, adapter_gl->pixel_format_count = 0; i < cfg_count; ++i)
4253         {
4254             struct wined3d_pixel_format *cfg = &adapter_gl->pixel_formats[adapter_gl->pixel_format_count];
4255             PIXELFORMATDESCRIPTOR pfd;
4256             int format_id = i + 1;
4257
4258             if (!DescribePixelFormat(dc, format_id, sizeof(pfd), &pfd))
4259                 continue;
4260
4261             /* We only want HW acceleration using an OpenGL ICD driver.
4262              * PFD_GENERIC_FORMAT = slow OpenGL 1.1 GDI software rendering.
4263              * PFD_GENERIC_ACCELERATED = partial hw acceleration using a MCD
4264              * driver (e.g. 3dfx minigl). */
4265             if (pfd.dwFlags & (PFD_GENERIC_FORMAT | PFD_GENERIC_ACCELERATED))
4266             {
4267                 TRACE("Skipping format %d because it isn't ICD accelerated.\n", format_id);
4268                 continue;
4269             }
4270
4271             cfg->iPixelFormat = format_id;
4272             cfg->redSize = pfd.cRedBits;
4273             cfg->greenSize = pfd.cGreenBits;
4274             cfg->blueSize = pfd.cBlueBits;
4275             cfg->alphaSize = pfd.cAlphaBits;
4276             cfg->colorSize = pfd.cColorBits;
4277             cfg->depthSize = pfd.cDepthBits;
4278             cfg->stencilSize = pfd.cStencilBits;
4279             cfg->windowDrawable = (pfd.dwFlags & PFD_DRAW_TO_WINDOW) ? 1 : 0;
4280             cfg->iPixelType = (pfd.iPixelType == PFD_TYPE_RGBA) ? WGL_TYPE_RGBA_ARB : WGL_TYPE_COLORINDEX_ARB;
4281             cfg->doubleBuffer = (pfd.dwFlags & PFD_DOUBLEBUFFER) ? 1 : 0;
4282             cfg->auxBuffers = pfd.cAuxBuffers;
4283             cfg->numSamples = 0;
4284
4285             TRACE("iPixelFormat=%d, iPixelType=%#x, doubleBuffer=%d, RGBA=%d/%d/%d/%d, "
4286                     "depth=%d, stencil=%d, windowDrawable=%d\n",
4287                     cfg->iPixelFormat, cfg->iPixelType, cfg->doubleBuffer,
4288                     cfg->redSize, cfg->greenSize, cfg->blueSize, cfg->alphaSize,
4289                     cfg->depthSize, cfg->stencilSize, cfg->windowDrawable);
4290
4291             ++adapter_gl->pixel_format_count;
4292         }
4293     }
4294 }
4295
4296 static void adapter_gl_destroy(struct wined3d_adapter *adapter)
4297 {
4298     struct wined3d_adapter_gl *adapter_gl = wined3d_adapter_gl(adapter);
4299
4300     heap_free(adapter_gl->pixel_formats);
4301     wined3d_adapter_cleanup(adapter);
4302     heap_free(adapter_gl);
4303 }
4304
4305 static HRESULT adapter_gl_create_device(struct wined3d *wined3d, const struct wined3d_adapter *adapter,
4306         enum wined3d_device_type device_type, HWND focus_window, unsigned int flags, BYTE surface_alignment,
4307         const enum wined3d_feature_level *levels, unsigned int level_count,
4308         struct wined3d_device_parent *device_parent, struct wined3d_device **device)
4309 {
4310     struct wined3d_device_gl *device_gl;
4311     HRESULT hr;
4312
4313     if (!(device_gl = heap_alloc_zero(sizeof(*device_gl))))
4314         return E_OUTOFMEMORY;
4315
4316     if (FAILED(hr = wined3d_device_init(&device_gl->d, wined3d, adapter->ordinal, device_type, focus_window,
4317             flags, surface_alignment, levels, level_count, adapter->gl_info.supported, device_parent)))
4318     {
4319         WARN("Failed to initialize device, hr %#x.\n", hr);
4320         heap_free(device_gl);
4321         return hr;
4322     }
4323
4324     *device = &device_gl->d;
4325     return WINED3D_OK;
4326 }
4327
4328 static void adapter_gl_destroy_device(struct wined3d_device *device)
4329 {
4330     struct wined3d_device_gl *device_gl = wined3d_device_gl(device);
4331
4332     wined3d_device_cleanup(&device_gl->d);
4333     heap_free(device_gl);
4334 }
4335
4336 struct wined3d_context *adapter_gl_acquire_context(struct wined3d_device *device,
4337         struct wined3d_texture *texture, unsigned int sub_resource_idx)
4338 {
4339     return wined3d_context_gl_acquire(device, texture, sub_resource_idx);
4340 }
4341
4342 void adapter_gl_release_context(struct wined3d_context *context)
4343 {
4344     return wined3d_context_gl_release(wined3d_context_gl(context));
4345 }
4346
4347 static void adapter_gl_get_wined3d_caps(const struct wined3d_adapter *adapter, struct wined3d_caps *caps)
4348 {
4349     const struct wined3d_d3d_info *d3d_info = &adapter->d3d_info;
4350     const struct wined3d_gl_info *gl_info = &adapter->gl_info;
4351
4352     caps->ddraw_caps.dds_caps |= WINEDDSCAPS_BACKBUFFER
4353             | WINEDDSCAPS_COMPLEX
4354             | WINEDDSCAPS_FRONTBUFFER
4355             | WINEDDSCAPS_3DDEVICE
4356             | WINEDDSCAPS_VIDEOMEMORY
4357             | WINEDDSCAPS_OWNDC
4358             | WINEDDSCAPS_LOCALVIDMEM
4359             | WINEDDSCAPS_NONLOCALVIDMEM;
4360
4361     caps->ddraw_caps.caps |= WINEDDCAPS_3D;
4362
4363     if (gl_info->supported[ARB_FRAMEBUFFER_OBJECT] || gl_info->supported[EXT_FRAMEBUFFER_OBJECT])
4364         caps->Caps2 |= WINED3DCAPS2_CANGENMIPMAP;
4365
4366     if (gl_info->supported[WINED3D_GL_BLEND_EQUATION])
4367         caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_BLENDOP;
4368     if (gl_info->supported[EXT_BLEND_EQUATION_SEPARATE] && gl_info->supported[EXT_BLEND_FUNC_SEPARATE])
4369         caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_SEPARATEALPHABLEND;
4370     if (gl_info->supported[EXT_DRAW_BUFFERS2])
4371         caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_INDEPENDENTWRITEMASKS;
4372     if (gl_info->supported[ARB_FRAMEBUFFER_SRGB])
4373         caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_POSTBLENDSRGBCONVERT;
4374     if (~gl_info->quirks & WINED3D_QUIRK_NO_INDEPENDENT_BIT_DEPTHS)
4375         caps->PrimitiveMiscCaps |= WINED3DPMISCCAPS_MRTINDEPENDENTBITDEPTHS;
4376
4377     if (gl_info->supported[ARB_SAMPLER_OBJECTS] || gl_info->supported[EXT_TEXTURE_LOD_BIAS])
4378         caps->RasterCaps |= WINED3DPRASTERCAPS_MIPMAPLODBIAS;
4379
4380     if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC])
4381     {
4382         caps->RasterCaps |= WINED3DPRASTERCAPS_ANISOTROPY;
4383
4384         caps->TextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
4385                 | WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4386     }
4387
4388     if (gl_info->supported[ARB_BLEND_FUNC_EXTENDED])
4389         caps->DestBlendCaps |= WINED3DPBLENDCAPS_SRCALPHASAT;
4390
4391     if (gl_info->supported[EXT_BLEND_COLOR])
4392     {
4393         caps->SrcBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4394         caps->DestBlendCaps |= WINED3DPBLENDCAPS_BLENDFACTOR;
4395     }
4396
4397     if (gl_info->supported[EXT_TEXTURE3D])
4398     {
4399         caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP
4400                 | WINED3DPTEXTURECAPS_MIPVOLUMEMAP;
4401         if (!d3d_info->texture_npot)
4402             caps->TextureCaps |= WINED3DPTEXTURECAPS_VOLUMEMAP_POW2;
4403
4404         caps->VolumeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR
4405                 | WINED3DPTFILTERCAPS_MAGFPOINT
4406                 | WINED3DPTFILTERCAPS_MINFLINEAR
4407                 | WINED3DPTFILTERCAPS_MINFPOINT
4408                 | WINED3DPTFILTERCAPS_MIPFLINEAR
4409                 | WINED3DPTFILTERCAPS_MIPFPOINT
4410                 | WINED3DPTFILTERCAPS_LINEAR
4411                 | WINED3DPTFILTERCAPS_LINEARMIPLINEAR
4412                 | WINED3DPTFILTERCAPS_LINEARMIPNEAREST
4413                 | WINED3DPTFILTERCAPS_MIPLINEAR
4414                 | WINED3DPTFILTERCAPS_MIPNEAREST
4415                 | WINED3DPTFILTERCAPS_NEAREST;
4416
4417         caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_INDEPENDENTUV
4418                 | WINED3DPTADDRESSCAPS_CLAMP
4419                 | WINED3DPTADDRESSCAPS_WRAP;
4420
4421         if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4422         {
4423             caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4424         }
4425         if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4426         {
4427             caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4428         }
4429         if (gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE])
4430         {
4431             caps->VolumeTextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4432         }
4433
4434         caps->MaxVolumeExtent = gl_info->limits.texture3d_size;
4435     }
4436
4437     if (gl_info->supported[ARB_TEXTURE_CUBE_MAP])
4438     {
4439         caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP
4440                 | WINED3DPTEXTURECAPS_MIPCUBEMAP;
4441         if (!d3d_info->texture_npot)
4442             caps->TextureCaps |= WINED3DPTEXTURECAPS_CUBEMAP_POW2;
4443
4444         caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFLINEAR
4445                 | WINED3DPTFILTERCAPS_MAGFPOINT
4446                 | WINED3DPTFILTERCAPS_MINFLINEAR
4447                 | WINED3DPTFILTERCAPS_MINFPOINT
4448                 | WINED3DPTFILTERCAPS_MIPFLINEAR
4449                 | WINED3DPTFILTERCAPS_MIPFPOINT
4450                 | WINED3DPTFILTERCAPS_LINEAR
4451                 | WINED3DPTFILTERCAPS_LINEARMIPLINEAR
4452                 | WINED3DPTFILTERCAPS_LINEARMIPNEAREST
4453                 | WINED3DPTFILTERCAPS_MIPLINEAR
4454                 | WINED3DPTFILTERCAPS_MIPNEAREST
4455                 | WINED3DPTFILTERCAPS_NEAREST;
4456
4457         if (gl_info->supported[ARB_TEXTURE_FILTER_ANISOTROPIC])
4458         {
4459             caps->CubeTextureFilterCaps |= WINED3DPTFILTERCAPS_MAGFANISOTROPIC
4460                     | WINED3DPTFILTERCAPS_MINFANISOTROPIC;
4461         }
4462     }
4463
4464     if (gl_info->supported[ARB_TEXTURE_BORDER_CLAMP])
4465     {
4466         caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_BORDER;
4467     }
4468     if (gl_info->supported[ARB_TEXTURE_MIRRORED_REPEAT])
4469     {
4470         caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRROR;
4471     }
4472     if (gl_info->supported[ARB_TEXTURE_MIRROR_CLAMP_TO_EDGE])
4473     {
4474         caps->TextureAddressCaps |= WINED3DPTADDRESSCAPS_MIRRORONCE;
4475     }
4476
4477     if (gl_info->supported[EXT_STENCIL_WRAP])
4478     {
4479         caps->StencilCaps |= WINED3DSTENCILCAPS_DECR
4480                 | WINED3DSTENCILCAPS_INCR;
4481     }
4482
4483     if (gl_info->supported[WINED3D_GL_VERSION_2_0]
4484             || gl_info->supported[EXT_STENCIL_TWO_SIDE]
4485             || gl_info->supported[ATI_SEPARATE_STENCIL])
4486     {
4487         caps->StencilCaps |= WINED3DSTENCILCAPS_TWOSIDED;
4488     }
4489
4490     caps->MaxAnisotropy = gl_info->limits.anisotropy;
4491
4492     if (caps->VertexShaderVersion >= 3)
4493     {
4494         caps->MaxVertexShader30InstructionSlots
4495                 = max(caps->MaxVertexShader30InstructionSlots, gl_info->limits.arb_vs_instructions);
4496     }
4497     if (caps->VertexShaderVersion >= 2)
4498     {
4499         caps->VS20Caps.temp_count = max(caps->VS20Caps.temp_count, gl_info->limits.arb_vs_temps);
4500
4501         if (gl_info->supported[ARB_HALF_FLOAT_VERTEX])
4502             caps->DeclTypes |= WINED3DDTCAPS_FLOAT16_2 | WINED3DDTCAPS_FLOAT16_4;
4503     }
4504
4505     if (caps->PixelShaderVersion >= 3)
4506     {
4507         caps->MaxPixelShader30InstructionSlots
4508                 = max(caps->MaxPixelShader30InstructionSlots, gl_info->limits.arb_ps_instructions);
4509     }
4510     if (caps->PixelShaderVersion >= 2)
4511     {
4512         caps->PS20Caps.temp_count = max(caps->PS20Caps.temp_count, gl_info->limits.arb_ps_temps);
4513     }
4514 }
4515
4516 static BOOL wined3d_check_pixel_format_color(const struct wined3d_pixel_format *cfg,
4517         const struct wined3d_format *format)
4518 {
4519     /* Float formats need FBOs. If FBOs are used this function isn't called */
4520     if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)
4521         return FALSE;
4522
4523     /* Probably a RGBA_float or color index mode. */
4524     if (cfg->iPixelType != WGL_TYPE_RGBA_ARB)
4525         return FALSE;
4526
4527     if (cfg->redSize < format->red_size
4528             || cfg->greenSize < format->green_size
4529             || cfg->blueSize < format->blue_size
4530             || cfg->alphaSize < format->alpha_size)
4531         return FALSE;
4532
4533     return TRUE;
4534 }
4535
4536 static BOOL wined3d_check_pixel_format_depth(const struct wined3d_pixel_format *cfg,
4537         const struct wined3d_format *format)
4538 {
4539     BOOL lockable = FALSE;
4540
4541     /* Float formats need FBOs. If FBOs are used this function isn't called */
4542     if (format->flags[WINED3D_GL_RES_TYPE_TEX_2D] & WINED3DFMT_FLAG_FLOAT)
4543         return FALSE;
4544
4545     if ((format->id == WINED3DFMT_D16_LOCKABLE) || (format->id == WINED3DFMT_D32_FLOAT))
4546         lockable = TRUE;
4547
4548     /* On some modern cards like the Geforce8/9, GLX doesn't offer some
4549      * depth/stencil formats which D3D9 reports. We can safely report
4550      * "compatible" formats (e.g. D24 can be used for D16) as long as we
4551      * aren't dealing with a lockable format. This also helps D3D <= 7 as they
4552      * expect D16 which isn't offered without this on Geforce8 cards. */
4553     if (!(cfg->depthSize == format->depth_size || (!lockable && cfg->depthSize > format->depth_size)))
4554         return FALSE;
4555
4556     /* Some cards like Intel i915 ones only offer D24S8 but lots of games also
4557      * need a format without stencil. We can allow a mismatch if the format
4558      * doesn't have any stencil bits. If it does have stencil bits the size
4559      * must match, or stencil wrapping would break. */
4560     if (format->stencil_size && cfg->stencilSize != format->stencil_size)
4561         return FALSE;
4562
4563     return TRUE;
4564 }
4565
4566 static BOOL adapter_gl_check_format(const struct wined3d_adapter *adapter,
4567         const struct wined3d_format *adapter_format, const struct wined3d_format *rt_format,
4568         const struct wined3d_format *ds_format)
4569 {
4570     const struct wined3d_adapter_gl *adapter_gl = wined3d_adapter_gl_const(adapter);
4571     unsigned int i;
4572
4573     if (wined3d_settings.offscreen_rendering_mode != ORM_BACKBUFFER)
4574         return TRUE;
4575
4576     if (adapter_format && rt_format)
4577     {
4578         /* In backbuffer mode the front and backbuffer share the same WGL
4579          * pixelformat. The format must match in RGB, alpha is allowed to be
4580          * different. (Only the backbuffer can have alpha.) */
4581         if (adapter_format->red_size != rt_format->red_size
4582                 || adapter_format->green_size != rt_format->green_size
4583                 || adapter_format->blue_size != rt_format->blue_size)
4584         {
4585             TRACE("Render target format %s doesn't match with adapter format %s.\n",
4586                     debug_d3dformat(rt_format->id), debug_d3dformat(adapter_format->id));
4587             return FALSE;
4588         }
4589     }
4590
4591     for (i = 0; i < adapter_gl->pixel_format_count; ++i)
4592     {
4593         const struct wined3d_pixel_format *cfg = &adapter_gl->pixel_formats[i];
4594
4595         /* Check if there is a WGL pixel format matching the requirements, the format should also be window
4596          * drawable (not offscreen; e.g. Nvidia offers R5G6B5 for pbuffers even when X is running at 24bit) */
4597         if (adapter_format && rt_format && !cfg->windowDrawable)
4598             continue;
4599
4600         if ((!adapter_format || wined3d_check_pixel_format_color(cfg, adapter_format))
4601                 && (!rt_format || wined3d_check_pixel_format_color(cfg, rt_format))
4602                 && (!ds_format || wined3d_check_pixel_format_depth(cfg, ds_format)))
4603         {
4604             TRACE("Pixel format %d is compatible.\n", cfg->iPixelFormat);
4605             return TRUE;
4606         }
4607     }
4608
4609     return FALSE;
4610 }
4611
4612 static HRESULT adapter_gl_init_3d(struct wined3d_device *device)
4613 {
4614     TRACE("device %p.\n", device);
4615
4616     wined3d_cs_init_object(device->cs, wined3d_device_create_primary_opengl_context_cs, device);
4617     wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
4618     if (!wined3d_swapchain_gl(device->swapchains[0])->context_count)
4619         return E_FAIL;
4620
4621     device->d3d_initialized = TRUE;
4622
4623     return WINED3D_OK;
4624 }
4625
4626 static void adapter_gl_uninit_3d(struct wined3d_device *device)
4627 {
4628     TRACE("device %p.\n", device);
4629
4630     wined3d_cs_destroy_object(device->cs, wined3d_device_delete_opengl_contexts_cs, device);
4631     wined3d_cs_finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
4632 }
4633
4634 static void *adapter_gl_map_bo_address(struct wined3d_context *context,
4635         const struct wined3d_bo_address *data, size_t size, uint32_t map_flags)
4636 {
4637     return wined3d_context_gl_map_bo_address(wined3d_context_gl(context), data, size, map_flags);
4638 }
4639
4640 static void adapter_gl_unmap_bo_address(struct wined3d_context *context,
4641         const struct wined3d_bo_address *data, unsigned int range_count, const struct wined3d_range *ranges)
4642 {
4643     wined3d_context_gl_unmap_bo_address(wined3d_context_gl(context), data, range_count, ranges);
4644 }
4645
4646 static void adapter_gl_copy_bo_address(struct wined3d_context *context,
4647         const struct wined3d_bo_address *dst, const struct wined3d_bo_address *src, size_t size)
4648 {
4649     wined3d_context_gl_copy_bo_address(wined3d_context_gl(context), dst, src, size);
4650 }
4651
4652 static HRESULT adapter_gl_create_swapchain(struct wined3d_device *device, struct wined3d_swapchain_desc *desc,
4653         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_swapchain **swapchain)
4654 {
4655     struct wined3d_swapchain_gl *swapchain_gl;
4656     HRESULT hr;
4657
4658     TRACE("device %p, desc %p, parent %p, parent_ops %p, swapchain %p.\n",
4659             device, desc, parent, parent_ops, swapchain);
4660
4661     if (!(swapchain_gl = heap_alloc_zero(sizeof(*swapchain_gl))))
4662         return E_OUTOFMEMORY;
4663
4664     if (FAILED(hr = wined3d_swapchain_gl_init(swapchain_gl, device, desc, parent, parent_ops)))
4665     {
4666         WARN("Failed to initialise swapchain, hr %#x.\n", hr);
4667         heap_free(swapchain_gl);
4668         return hr;
4669     }
4670
4671     TRACE("Created swapchain %p.\n", swapchain_gl);
4672     *swapchain = &swapchain_gl->s;
4673
4674     return hr;
4675 }
4676
4677 static void adapter_gl_destroy_swapchain(struct wined3d_swapchain *swapchain)
4678 {
4679     struct wined3d_swapchain_gl *swapchain_gl = wined3d_swapchain_gl(swapchain);
4680
4681     wined3d_swapchain_gl_cleanup(swapchain_gl);
4682     heap_free(swapchain_gl);
4683 }
4684
4685 static HRESULT adapter_gl_create_buffer(struct wined3d_device *device,
4686         const struct wined3d_buffer_desc *desc, const struct wined3d_sub_resource_data *data,
4687         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_buffer **buffer)
4688 {
4689     struct wined3d_buffer_gl *buffer_gl;
4690     HRESULT hr;
4691
4692     TRACE("device %p, desc %p, data %p, parent %p, parent_ops %p, buffer %p.\n",
4693             device, desc, data, parent, parent_ops, buffer);
4694
4695     if (!(buffer_gl = heap_alloc_zero(sizeof(*buffer_gl))))
4696         return E_OUTOFMEMORY;
4697
4698     if (FAILED(hr = wined3d_buffer_gl_init(buffer_gl, device, desc, data, parent, parent_ops)))
4699     {
4700         WARN("Failed to initialise buffer, hr %#x.\n", hr);
4701         heap_free(buffer_gl);
4702         return hr;
4703     }
4704
4705     TRACE("Created buffer %p.\n", buffer_gl);
4706     *buffer = &buffer_gl->b;
4707
4708     return hr;
4709 }
4710
4711 static void adapter_gl_destroy_buffer(struct wined3d_buffer *buffer)
4712 {
4713     struct wined3d_buffer_gl *buffer_gl = wined3d_buffer_gl(buffer);
4714     struct wined3d_device *device = buffer_gl->b.resource.device;
4715     unsigned int swapchain_count = device->swapchain_count;
4716
4717     TRACE("buffer_gl %p.\n", buffer_gl);
4718
4719     /* Take a reference to the device, in case releasing the buffer would
4720      * cause the device to be destroyed. However, swapchain resources don't
4721      * take a reference to the device, and we wouldn't want to increment the
4722      * refcount on a device that's in the process of being destroyed. */
4723     if (swapchain_count)
4724         wined3d_device_incref(device);
4725     wined3d_buffer_cleanup(&buffer_gl->b);
4726     wined3d_cs_destroy_object(device->cs, heap_free, buffer_gl);
4727     if (swapchain_count)
4728         wined3d_device_decref(device);
4729 }
4730
4731 static HRESULT adapter_gl_create_texture(struct wined3d_device *device,
4732         const struct wined3d_resource_desc *desc, unsigned int layer_count, unsigned int level_count,
4733         uint32_t flags, void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_texture **texture)
4734 {
4735     struct wined3d_texture_gl *texture_gl;
4736     HRESULT hr;
4737
4738     TRACE("device %p, desc %p, layer_count %u, level_count %u, flags %#x, parent %p, parent_ops %p, texture %p.\n",
4739             device, desc, layer_count, level_count, flags, parent, parent_ops, texture);
4740
4741     if (!(texture_gl = wined3d_texture_allocate_object_memory(sizeof(*texture_gl), level_count, layer_count)))
4742         return E_OUTOFMEMORY;
4743
4744     if (FAILED(hr = wined3d_texture_gl_init(texture_gl, device, desc,
4745             layer_count, level_count, flags, parent, parent_ops)))
4746     {
4747         WARN("Failed to initialise texture, hr %#x.\n", hr);
4748         heap_free(texture_gl);
4749         return hr;
4750     }
4751
4752     TRACE("Created texture %p.\n", texture_gl);
4753     *texture = &texture_gl->t;
4754
4755     return hr;
4756 }
4757
4758 static void adapter_gl_destroy_texture(struct wined3d_texture *texture)
4759 {
4760     struct wined3d_texture_gl *texture_gl = wined3d_texture_gl(texture);
4761     struct wined3d_device *device = texture_gl->t.resource.device;
4762     unsigned int swapchain_count = device->swapchain_count;
4763
4764     TRACE("texture_gl %p.\n", texture_gl);
4765
4766     /* Take a reference to the device, in case releasing the texture would
4767      * cause the device to be destroyed. However, swapchain resources don't
4768      * take a reference to the device, and we wouldn't want to increment the
4769      * refcount on a device that's in the process of being destroyed. */
4770     if (swapchain_count)
4771         wined3d_device_incref(device);
4772
4773     wined3d_texture_sub_resources_destroyed(texture);
4774     texture->resource.parent_ops->wined3d_object_destroyed(texture->resource.parent);
4775
4776     wined3d_texture_cleanup(&texture_gl->t);
4777     wined3d_cs_destroy_object(device->cs, heap_free, texture_gl);
4778
4779     if (swapchain_count)
4780         wined3d_device_decref(device);
4781 }
4782
4783 static HRESULT adapter_gl_create_rendertarget_view(const struct wined3d_view_desc *desc,
4784         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
4785         struct wined3d_rendertarget_view **view)
4786 {
4787     struct wined3d_rendertarget_view_gl *view_gl;
4788     HRESULT hr;
4789
4790     TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
4791             wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
4792
4793     if (!(view_gl = heap_alloc_zero(sizeof(*view_gl))))
4794         return E_OUTOFMEMORY;
4795
4796     if (FAILED(hr = wined3d_rendertarget_view_gl_init(view_gl, desc, resource, parent, parent_ops)))
4797     {
4798         WARN("Failed to initialise view, hr %#x.\n", hr);
4799         heap_free(view_gl);
4800         return hr;
4801     }
4802
4803     TRACE("Created render target view %p.\n", view_gl);
4804     *view = &view_gl->v;
4805
4806     return hr;
4807 }
4808
4809 struct wined3d_view_gl_destroy_ctx
4810 {
4811     struct wined3d_device *device;
4812     const struct wined3d_gl_view *gl_view;
4813     struct wined3d_bo_gl *counter_bo;
4814     void *object;
4815     struct wined3d_view_gl_destroy_ctx *free;
4816 };
4817
4818 static void wined3d_view_gl_destroy_object(void *object)
4819 {
4820     struct wined3d_view_gl_destroy_ctx *ctx = object;
4821     const struct wined3d_gl_info *gl_info;
4822     struct wined3d_context *context;
4823     struct wined3d_device *device;
4824     GLuint counter_id;
4825
4826     device = ctx->device;
4827
4828     counter_id = ctx->counter_bo ? ctx->counter_bo->id : 0;
4829     if (ctx->gl_view->name || counter_id)
4830     {
4831         context = context_acquire(device, NULL, 0);
4832         gl_info = wined3d_context_gl(context)->gl_info;
4833         if (ctx->gl_view->name)
4834         {
4835             context_gl_resource_released(device, ctx->gl_view->name, FALSE);
4836             gl_info->gl_ops.gl.p_glDeleteTextures(1, &ctx->gl_view->name);
4837         }
4838         if (counter_id)
4839             GL_EXTCALL(glDeleteBuffers(1, &counter_id));
4840         checkGLcall("delete resources");
4841         context_release(context);
4842     }
4843
4844     heap_free(ctx->object);
4845     heap_free(ctx->free);
4846 }
4847
4848 static void wined3d_view_gl_destroy(struct wined3d_device *device,
4849         const struct wined3d_gl_view *gl_view, struct wined3d_bo_gl *counter_bo, void *object)
4850 {
4851     struct wined3d_view_gl_destroy_ctx *ctx, c;
4852
4853     if (!(ctx = heap_alloc(sizeof(*ctx))))
4854         ctx = &c;
4855     ctx->device = device;
4856     ctx->gl_view = gl_view;
4857     ctx->counter_bo = counter_bo;
4858     ctx->object = object;
4859     ctx->free = ctx != &c ? ctx : NULL;
4860
4861     wined3d_cs_destroy_object(device->cs, wined3d_view_gl_destroy_object, ctx);
4862     if (ctx == &c)
4863         device->cs->ops->finish(device->cs, WINED3D_CS_QUEUE_DEFAULT);
4864 }
4865
4866 static void adapter_gl_destroy_rendertarget_view(struct wined3d_rendertarget_view *view)
4867 {
4868     struct wined3d_rendertarget_view_gl *view_gl = wined3d_rendertarget_view_gl(view);
4869     struct wined3d_device *device = view_gl->v.resource->device;
4870     unsigned int swapchain_count = device->swapchain_count;
4871
4872     TRACE("view_gl %p.\n", view_gl);
4873
4874     /* Take a reference to the device, in case releasing the view's resource
4875      * would cause the device to be destroyed. However, swapchain resources
4876      * don't take a reference to the device, and we wouldn't want to increment
4877      * the refcount on a device that's in the process of being destroyed. */
4878     if (swapchain_count)
4879         wined3d_device_incref(device);
4880     wined3d_rendertarget_view_cleanup(&view_gl->v);
4881     wined3d_view_gl_destroy(device, &view_gl->gl_view, NULL, view_gl);
4882     if (swapchain_count)
4883         wined3d_device_decref(device);
4884 }
4885
4886 static HRESULT adapter_gl_create_shader_resource_view(const struct wined3d_view_desc *desc,
4887         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
4888         struct wined3d_shader_resource_view **view)
4889 {
4890     struct wined3d_shader_resource_view_gl *view_gl;
4891     HRESULT hr;
4892
4893     TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
4894             wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
4895
4896     if (!(view_gl = heap_alloc_zero(sizeof(*view_gl))))
4897         return E_OUTOFMEMORY;
4898
4899     if (FAILED(hr = wined3d_shader_resource_view_gl_init(view_gl, desc, resource, parent, parent_ops)))
4900     {
4901         WARN("Failed to initialise view, hr %#x.\n", hr);
4902         heap_free(view_gl);
4903         return hr;
4904     }
4905
4906     TRACE("Created shader resource view %p.\n", view_gl);
4907     *view = &view_gl->v;
4908
4909     return hr;
4910 }
4911
4912 static void adapter_gl_destroy_shader_resource_view(struct wined3d_shader_resource_view *view)
4913 {
4914     struct wined3d_shader_resource_view_gl *view_gl = wined3d_shader_resource_view_gl(view);
4915     struct wined3d_device *device = view_gl->v.resource->device;
4916     unsigned int swapchain_count = device->swapchain_count;
4917
4918     TRACE("view_gl %p.\n", view_gl);
4919
4920     /* Take a reference to the device, in case releasing the view's resource
4921      * would cause the device to be destroyed. However, swapchain resources
4922      * don't take a reference to the device, and we wouldn't want to increment
4923      * the refcount on a device that's in the process of being destroyed. */
4924     if (swapchain_count)
4925         wined3d_device_incref(device);
4926     wined3d_shader_resource_view_cleanup(&view_gl->v);
4927     wined3d_view_gl_destroy(device, &view_gl->gl_view, NULL, view_gl);
4928     if (swapchain_count)
4929         wined3d_device_decref(device);
4930 }
4931
4932 static HRESULT adapter_gl_create_unordered_access_view(const struct wined3d_view_desc *desc,
4933         struct wined3d_resource *resource, void *parent, const struct wined3d_parent_ops *parent_ops,
4934         struct wined3d_unordered_access_view **view)
4935 {
4936     struct wined3d_unordered_access_view_gl *view_gl;
4937     HRESULT hr;
4938
4939     TRACE("desc %s, resource %p, parent %p, parent_ops %p, view %p.\n",
4940             wined3d_debug_view_desc(desc, resource), resource, parent, parent_ops, view);
4941
4942     if (!(view_gl = heap_alloc_zero(sizeof(*view_gl))))
4943         return E_OUTOFMEMORY;
4944
4945     if (FAILED(hr = wined3d_unordered_access_view_gl_init(view_gl, desc, resource, parent, parent_ops)))
4946     {
4947         WARN("Failed to initialise view, hr %#x.\n", hr);
4948         heap_free(view_gl);
4949         return hr;
4950     }
4951
4952     TRACE("Created unordered access view %p.\n", view_gl);
4953     *view = &view_gl->v;
4954
4955     return hr;
4956 }
4957
4958 static void adapter_gl_destroy_unordered_access_view(struct wined3d_unordered_access_view *view)
4959 {
4960     struct wined3d_unordered_access_view_gl *view_gl = wined3d_unordered_access_view_gl(view);
4961     struct wined3d_device *device = view_gl->v.resource->device;
4962     unsigned int swapchain_count = device->swapchain_count;
4963
4964     TRACE("view_gl %p.\n", view_gl);
4965
4966     /* Take a reference to the device, in case releasing the view's resource
4967      * would cause the device to be destroyed. However, swapchain resources
4968      * don't take a reference to the device, and we wouldn't want to increment
4969      * the refcount on a device that's in the process of being destroyed. */
4970     if (swapchain_count)
4971         wined3d_device_incref(device);
4972     wined3d_unordered_access_view_cleanup(&view_gl->v);
4973     wined3d_view_gl_destroy(device, &view_gl->gl_view, &view_gl->counter_bo, view_gl);
4974     if (swapchain_count)
4975         wined3d_device_decref(device);
4976 }
4977
4978 static HRESULT adapter_gl_create_sampler(struct wined3d_device *device, const struct wined3d_sampler_desc *desc,
4979         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_sampler **sampler)
4980 {
4981     struct wined3d_sampler_gl *sampler_gl;
4982
4983     TRACE("device %p, desc %p, parent %p, parent_ops %p, sampler %p.\n",
4984             device, desc, parent, parent_ops, sampler);
4985
4986     if (!(sampler_gl = heap_alloc_zero(sizeof(*sampler_gl))))
4987         return E_OUTOFMEMORY;
4988
4989     wined3d_sampler_gl_init(sampler_gl, device, desc, parent, parent_ops);
4990
4991     TRACE("Created sampler %p.\n", sampler_gl);
4992     *sampler = &sampler_gl->s;
4993
4994     return WINED3D_OK;
4995 }
4996
4997 static void wined3d_sampler_gl_destroy_object(void *object)
4998 {
4999     struct wined3d_sampler_gl *sampler_gl = object;
5000     const struct wined3d_gl_info *gl_info;
5001     struct wined3d_context *context;
5002
5003     if (sampler_gl->name)
5004     {
5005         context = context_acquire(sampler_gl->s.device, NULL, 0);
5006         gl_info = wined3d_context_gl(context)->gl_info;
5007         GL_EXTCALL(glDeleteSamplers(1, &sampler_gl->name));
5008         context_release(context);
5009     }
5010
5011     heap_free(sampler_gl);
5012 }
5013
5014 static void adapter_gl_destroy_sampler(struct wined3d_sampler *sampler)
5015 {
5016     struct wined3d_sampler_gl *sampler_gl = wined3d_sampler_gl(sampler);
5017
5018     TRACE("sampler_gl %p.\n", sampler_gl);
5019
5020     wined3d_cs_destroy_object(sampler->device->cs, wined3d_sampler_gl_destroy_object, sampler_gl);
5021 }
5022
5023 static HRESULT adapter_gl_create_query(struct wined3d_device *device, enum wined3d_query_type type,
5024         void *parent, const struct wined3d_parent_ops *parent_ops, struct wined3d_query **query)
5025 {
5026     TRACE("device %p, type %#x, parent %p, parent_ops %p, query %p.\n",
5027             device, type, parent, parent_ops, query);
5028
5029     return wined3d_query_gl_create(device, type, parent, parent_ops, query);
5030 }
5031
5032 static void wined3d_query_gl_destroy_object(void *object)
5033 {
5034     struct wined3d_query *query = object;
5035
5036     if (query->buffer_object)
5037     {
5038         struct wined3d_context *context;
5039
5040         context = context_acquire(query->device, NULL, 0);
5041         wined3d_query_gl_destroy_buffer_object(wined3d_context_gl(context), query);
5042         context_release(context);
5043     }
5044
5045     /* Queries are specific to the GL context that created them. Not
5046      * deleting the query will obviously leak it, but that's still better
5047      * than potentially deleting a different query with the same id in this
5048      * context, and (still) leaking the actual query. */
5049     query->query_ops->query_destroy(query);
5050 }
5051
5052 static void adapter_gl_destroy_query(struct wined3d_query *query)
5053 {
5054     TRACE("query %p.\n", query);
5055
5056     wined3d_cs_destroy_object(query->device->cs, wined3d_query_gl_destroy_object, query);
5057 }
5058
5059 static void adapter_gl_flush_context(struct wined3d_context *context)
5060 {
5061     struct wined3d_context_gl *context_gl = wined3d_context_gl(context);
5062
5063     TRACE("context_gl %p.\n", context_gl);
5064
5065     if (context_gl->valid)
5066         context_gl->gl_info->gl_ops.gl.p_glFlush();
5067 }
5068
5069 void adapter_gl_clear_uav(struct wined3d_context *context,
5070         struct wined3d_unordered_access_view *view, const struct wined3d_uvec4 *clear_value)
5071 {
5072     TRACE("context %p, view %p, clear_value %s.\n", context, view, debug_uvec4(clear_value));
5073
5074     wined3d_unordered_access_view_gl_clear_uint(wined3d_unordered_access_view_gl(view),
5075             clear_value, wined3d_context_gl(context));
5076 }
5077
5078 static const struct wined3d_adapter_ops wined3d_adapter_gl_ops =
5079 {
5080     .adapter_destroy = adapter_gl_destroy,
5081     .adapter_create_device = adapter_gl_create_device,
5082     .adapter_destroy_device = adapter_gl_destroy_device,
5083     .adapter_acquire_context = adapter_gl_acquire_context,
5084     .adapter_release_context = adapter_gl_release_context,
5085     .adapter_get_wined3d_caps = adapter_gl_get_wined3d_caps,
5086     .adapter_check_format = adapter_gl_check_format,
5087     .adapter_init_3d = adapter_gl_init_3d,
5088     .adapter_uninit_3d = adapter_gl_uninit_3d,
5089     .adapter_map_bo_address = adapter_gl_map_bo_address,
5090     .adapter_unmap_bo_address = adapter_gl_unmap_bo_address,
5091     .adapter_copy_bo_address = adapter_gl_copy_bo_address,
5092     .adapter_create_swapchain = adapter_gl_create_swapchain,
5093     .adapter_destroy_swapchain = adapter_gl_destroy_swapchain,
5094     .adapter_create_buffer = adapter_gl_create_buffer,
5095     .adapter_destroy_buffer = adapter_gl_destroy_buffer,
5096     .adapter_create_texture = adapter_gl_create_texture,
5097     .adapter_destroy_texture = adapter_gl_destroy_texture,
5098     .adapter_create_rendertarget_view = adapter_gl_create_rendertarget_view,
5099     .adapter_destroy_rendertarget_view = adapter_gl_destroy_rendertarget_view,
5100     .adapter_create_shader_resource_view = adapter_gl_create_shader_resource_view,
5101     .adapter_destroy_shader_resource_view = adapter_gl_destroy_shader_resource_view,
5102     .adapter_create_unordered_access_view = adapter_gl_create_unordered_access_view,
5103     .adapter_destroy_unordered_access_view = adapter_gl_destroy_unordered_access_view,
5104     .adapter_create_sampler = adapter_gl_create_sampler,
5105     .adapter_destroy_sampler = adapter_gl_destroy_sampler,
5106     .adapter_create_query = adapter_gl_create_query,
5107     .adapter_destroy_query = adapter_gl_destroy_query,
5108     .adapter_flush_context = adapter_gl_flush_context,
5109     .adapter_draw_primitive = draw_primitive,
5110     .adapter_dispatch_compute = dispatch_compute,
5111     .adapter_clear_uav = adapter_gl_clear_uav,
5112 };
5113
5114 static void wined3d_adapter_gl_init_d3d_info(struct wined3d_adapter_gl *adapter_gl, uint32_t wined3d_creation_flags)
5115 {
5116     const struct wined3d_gl_info *gl_info = &adapter_gl->a.gl_info;
5117     struct wined3d_d3d_info *d3d_info = &adapter_gl->a.d3d_info;
5118     struct wined3d_vertex_caps vertex_caps;
5119     struct fragment_caps fragment_caps;
5120     struct shader_caps shader_caps;
5121     GLfloat f[2];
5122
5123     adapter_gl->a.shader_backend->shader_get_caps(&adapter_gl->a, &shader_caps);
5124     adapter_gl->a.vertex_pipe->vp_get_caps(&adapter_gl->a, &vertex_caps);
5125     adapter_gl->a.misc_state_template = misc_state_template_gl;
5126     adapter_gl->a.fragment_pipe->get_caps(&adapter_gl->a, &fragment_caps);
5127
5128     d3d_info->limits.vs_version = shader_caps.vs_version;
5129     d3d_info->limits.hs_version = shader_caps.hs_version;
5130     d3d_info->limits.ds_version = shader_caps.ds_version;
5131     d3d_info->limits.gs_version = shader_caps.gs_version;
5132     d3d_info->limits.ps_version = shader_caps.ps_version;
5133     d3d_info->limits.cs_version = shader_caps.cs_version;
5134     d3d_info->limits.vs_uniform_count = shader_caps.vs_uniform_count;
5135     d3d_info->limits.ps_uniform_count = shader_caps.ps_uniform_count;
5136     d3d_info->limits.varying_count = shader_caps.varying_count;
5137     d3d_info->limits.ffp_textures = fragment_caps.MaxSimultaneousTextures;
5138     d3d_info->limits.ffp_blend_stages = fragment_caps.MaxTextureBlendStages;
5139     TRACE("Max texture stages: %u.\n", d3d_info->limits.ffp_blend_stages);
5140     d3d_info->limits.ffp_vertex_blend_matrices = vertex_caps.max_vertex_blend_matrices;
5141     d3d_info->limits.active_light_count = vertex_caps.max_active_lights;
5142
5143     d3d_info->limits.max_rt_count = gl_info->limits.buffers;
5144     d3d_info->limits.max_clip_distances = gl_info->limits.user_clip_distances;
5145     d3d_info->limits.texture_size = gl_info->limits.texture_size;
5146
5147     gl_info->gl_ops.gl.p_glGetFloatv(gl_info->supported[WINED3D_GL_LEGACY_CONTEXT]
5148             ? GL_ALIASED_POINT_SIZE_RANGE : GL_POINT_SIZE_RANGE, f);
5149     d3d_info->limits.pointsize_max = f[1];
5150     TRACE("Maximum point size support - max point size %.8e.\n", f[1]);
5151
5152     d3d_info->wined3d_creation_flags = wined3d_creation_flags;
5153     d3d_info->xyzrhw = vertex_caps.xyzrhw;
5154     d3d_info->emulated_flatshading = vertex_caps.emulated_flatshading;
5155     d3d_info->ffp_generic_attributes = vertex_caps.ffp_generic_attributes;
5156     d3d_info->ffp_alpha_test = !!gl_info->supported[WINED3D_GL_LEGACY_CONTEXT];
5157     d3d_info->vs_clipping = shader_caps.wined3d_caps & WINED3D_SHADER_CAP_VS_CLIPPING;
5158     d3d_info->shader_color_key = !!(fragment_caps.wined3d_caps & WINED3D_FRAGMENT_CAP_COLOR_KEY);
5159     d3d_info->shader_double_precision = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_DOUBLE_PRECISION);
5160     d3d_info->shader_output_interpolation = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_OUTPUT_INTERPOLATION);
5161     d3d_info->viewport_array_index_any_shader = !!gl_info->supported[ARB_SHADER_VIEWPORT_LAYER_ARRAY];
5162     d3d_info->texture_npot = !!gl_info->supported[ARB_TEXTURE_NON_POWER_OF_TWO];
5163     d3d_info->texture_npot_conditional = gl_info->supported[WINED3D_GL_NORMALIZED_TEXRECT]
5164             || gl_info->supported[ARB_TEXTURE_RECTANGLE];
5165     d3d_info->draw_base_vertex_offset = !!gl_info->supported[ARB_DRAW_ELEMENTS_BASE_VERTEX];
5166     d3d_info->vertex_bgra = !!gl_info->supported[ARB_VERTEX_ARRAY_BGRA];
5167     d3d_info->texture_swizzle = !!gl_info->supported[ARB_TEXTURE_SWIZZLE];
5168     d3d_info->srgb_read_control = !!gl_info->supported[EXT_TEXTURE_SRGB_DECODE];
5169     d3d_info->srgb_write_control = !!gl_info->supported[ARB_FRAMEBUFFER_SRGB];
5170     d3d_info->clip_control = !!gl_info->supported[ARB_CLIP_CONTROL];
5171     d3d_info->full_ffp_varyings = !!(shader_caps.wined3d_caps & WINED3D_SHADER_CAP_FULL_FFP_VARYINGS);
5172     d3d_info->scaled_resolve = !!gl_info->supported[EXT_FRAMEBUFFER_MULTISAMPLE_BLIT_SCALED];
5173     d3d_info->feature_level = feature_level_from_caps(gl_info, &shader_caps, &fragment_caps);
5174
5175     if (gl_info->supported[ARB_TEXTURE_MULTISAMPLE])
5176         d3d_info->multisample_draw_location = WINED3D_LOCATION_TEXTURE_RGB;
5177     else
5178         d3d_info->multisample_draw_location = WINED3D_LOCATION_RB_MULTISAMPLE;
5179 }
5180
5181 static BOOL wined3d_adapter_gl_init(struct wined3d_adapter_gl *adapter_gl,
5182         unsigned int ordinal, unsigned int wined3d_creation_flags)
5183 {
5184     static const DWORD supported_gl_versions[] =
5185     {
5186         MAKEDWORD_VERSION(4, 4),
5187         MAKEDWORD_VERSION(3, 2),
5188         MAKEDWORD_VERSION(1, 0),
5189     };
5190     struct wined3d_gl_info *gl_info = &adapter_gl->a.gl_info;
5191     struct wined3d_caps_gl_ctx caps_gl_ctx = {0};
5192     unsigned int i;
5193
5194     TRACE("adapter_gl %p, ordinal %u, wined3d_creation_flags %#x.\n",
5195             adapter_gl, ordinal, wined3d_creation_flags);
5196
5197     if (!wined3d_adapter_init(&adapter_gl->a, ordinal, &wined3d_adapter_gl_ops))
5198         return FALSE;
5199
5200     /* Dynamically load all GL core functions */
5201 #ifdef USE_WIN32_OPENGL
5202     {
5203         HMODULE mod_gl = GetModuleHandleA("opengl32.dll");
5204 #define USE_GL_FUNC(f) gl_info->gl_ops.gl.p_##f = (void *)GetProcAddress(mod_gl, #f);
5205         ALL_WGL_FUNCS
5206 #undef USE_GL_FUNC
5207         gl_info->gl_ops.wgl.p_wglSwapBuffers = (void *)GetProcAddress(mod_gl, "wglSwapBuffers");
5208         gl_info->gl_ops.wgl.p_wglGetPixelFormat = (void *)GetProcAddress(mod_gl, "wglGetPixelFormat");
5209     }
5210 #else
5211     /* To bypass the opengl32 thunks retrieve functions from the WGL driver instead of opengl32 */
5212     {
5213         HDC hdc = GetDC( 0 );
5214         const struct opengl_funcs *wgl_driver = __wine_get_wgl_driver( hdc, WINE_WGL_DRIVER_VERSION );
5215         ReleaseDC( 0, hdc );
5216         if (!wgl_driver || wgl_driver == (void *)-1) return FALSE;
5217         gl_info->gl_ops.wgl = wgl_driver->wgl;
5218         gl_info->gl_ops.gl = wgl_driver->gl;
5219     }
5220 #endif
5221
5222     gl_info->p_glEnableWINE = gl_info->gl_ops.gl.p_glEnable;
5223     gl_info->p_glDisableWINE = gl_info->gl_ops.gl.p_glDisable;
5224
5225     if (!wined3d_caps_gl_ctx_create(&adapter_gl->a, &caps_gl_ctx))
5226     {
5227         ERR("Failed to get a GL context for adapter %p.\n", adapter_gl);
5228         return FALSE;
5229     }
5230
5231     for (i = 0; i < ARRAY_SIZE(supported_gl_versions); ++i)
5232     {
5233         if (supported_gl_versions[i] <= wined3d_settings.max_gl_version)
5234             break;
5235     }
5236     if (i == ARRAY_SIZE(supported_gl_versions))
5237     {
5238         ERR_(winediag)("Requested invalid GL version %u.%u.\n",
5239                 wined3d_settings.max_gl_version >> 16, wined3d_settings.max_gl_version & 0xffff);
5240         i = ARRAY_SIZE(supported_gl_versions) - 1;
5241     }
5242
5243     for (; i < ARRAY_SIZE(supported_gl_versions); ++i)
5244     {
5245         gl_info->selected_gl_version = supported_gl_versions[i];
5246
5247         if (wined3d_caps_gl_ctx_create_attribs(&caps_gl_ctx, gl_info))
5248             break;
5249
5250         WARN("Couldn't create an OpenGL %u.%u context, trying fallback to a lower version.\n",
5251                 supported_gl_versions[i] >> 16, supported_gl_versions[i] & 0xffff);
5252     }
5253
5254     if (!wined3d_adapter_init_gl_caps(&adapter_gl->a, &caps_gl_ctx, wined3d_creation_flags))
5255     {
5256         ERR("Failed to initialize GL caps for adapter %p.\n", adapter_gl);
5257         wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5258         return FALSE;
5259     }
5260
5261     wined3d_adapter_gl_init_d3d_info(adapter_gl, wined3d_creation_flags);
5262     if (!adapter_gl->a.d3d_info.shader_color_key)
5263     {
5264         /* We do not want to deal with re-creating immutable texture storage
5265          * for colour-keying emulation. */
5266         WARN("Disabling ARB_texture_storage because fragment pipe doesn't support colour-keying.\n");
5267         gl_info->supported[ARB_TEXTURE_STORAGE] = FALSE;
5268     }
5269
5270     if (wined3d_settings.offscreen_rendering_mode == ORM_BACKBUFFER)
5271         ERR_(winediag)("You are using the backbuffer for offscreen rendering. "
5272                 "This is unsupported, and will be removed in a future version.\n");
5273
5274     wined3d_adapter_init_fb_cfgs(adapter_gl, caps_gl_ctx.dc);
5275     /* We haven't found any suitable formats. This should only happen in
5276      * case of GDI software rendering, which is pretty useless anyway. */
5277     if (!adapter_gl->pixel_format_count)
5278     {
5279         WARN("No suitable pixel formats found.\n");
5280         wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5281         heap_free(adapter_gl->pixel_formats);
5282         return FALSE;
5283     }
5284
5285     if (!wined3d_adapter_gl_init_format_info(&adapter_gl->a, &caps_gl_ctx))
5286     {
5287         ERR("Failed to initialize GL format info.\n");
5288         wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5289         heap_free(adapter_gl->pixel_formats);
5290         return FALSE;
5291     }
5292
5293     wined3d_caps_gl_ctx_destroy(&caps_gl_ctx);
5294
5295     wined3d_adapter_init_ffp_attrib_ops(&adapter_gl->a);
5296
5297     return TRUE;
5298 }
5299
5300 struct wined3d_adapter *wined3d_adapter_gl_create(unsigned int ordinal, unsigned int wined3d_creation_flags)
5301 {
5302     struct wined3d_adapter_gl *adapter;
5303
5304     if (!(adapter = heap_alloc_zero(sizeof(*adapter))))
5305         return NULL;
5306
5307     if (!wined3d_adapter_gl_init(adapter, ordinal, wined3d_creation_flags))
5308     {
5309         heap_free(adapter);
5310         return NULL;
5311     }
5312
5313     TRACE("Created adapter %p.\n", adapter);
5314
5315     return &adapter->a;
5316 }