Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
  5.  * Copyright (C) 2009  VMware, Inc.  All Rights Reserved.
  6.  *
  7.  * Permission is hereby granted, free of charge, to any person obtaining a
  8.  * copy of this software and associated documentation files (the "Software"),
  9.  * to deal in the Software without restriction, including without limitation
  10.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11.  * and/or sell copies of the Software, and to permit persons to whom the
  12.  * Software is furnished to do so, subject to the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice shall be included
  15.  * in all copies or substantial portions of the Software.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23.  * OTHER DEALINGS IN THE SOFTWARE.
  24.  */
  25.  
  26.  
  27. /**
  28.  * \file
  29.  * \brief Extension handling
  30.  */
  31.  
  32.  
  33. #include "glheader.h"
  34. #include "imports.h"
  35. #include "context.h"
  36. #include "extensions.h"
  37. #include "macros.h"
  38. #include "mtypes.h"
  39.  
  40. enum {
  41.    DISABLE = 0,
  42.    GLL = 1 << API_OPENGL_COMPAT,       /* GL Legacy / Compatibility */
  43.    GLC = 1 << API_OPENGL_CORE,  /* GL Core */
  44.    GL  = (1 << API_OPENGL_COMPAT) | (1 << API_OPENGL_CORE),
  45.    ES1 = 1 << API_OPENGLES,
  46.    ES2 = 1 << API_OPENGLES2,
  47.    ES3 = 1 << (API_OPENGL_LAST + 1),
  48. };
  49.  
  50. /**
  51.  * \brief An element of the \c extension_table.
  52.  */
  53. struct extension {
  54.    /** Name of extension, such as "GL_ARB_depth_clamp". */
  55.    const char *name;
  56.  
  57.    /** Offset (in bytes) of the corresponding member in struct gl_extensions. */
  58.    size_t offset;
  59.  
  60.    /** Set of API's in which the extension exists, as a bitset. */
  61.    uint8_t api_set;
  62.  
  63.    /** Year the extension was proposed or approved.  Used to sort the
  64.     * extension string chronologically. */
  65.    uint16_t year;
  66. };
  67.  
  68.  
  69. /**
  70.  * Given a member \c x of struct gl_extensions, return offset of
  71.  * \c x in bytes.
  72.  */
  73. #define o(x) offsetof(struct gl_extensions, x)
  74.  
  75.  
  76. /**
  77.  * \brief Table of supported OpenGL extensions for all API's.
  78.  */
  79. static const struct extension extension_table[] = {
  80.    /* ARB Extensions */
  81.    { "GL_ARB_ES2_compatibility",                   o(ARB_ES2_compatibility),                   GL,             2009 },
  82.    { "GL_ARB_ES3_compatibility",                   o(ARB_ES3_compatibility),                   GL,             2012 },
  83.    { "GL_ARB_base_instance",                       o(ARB_base_instance),                       GL,             2011 },
  84.    { "GL_ARB_blend_func_extended",                 o(ARB_blend_func_extended),                 GL,             2009 },
  85.    { "GL_ARB_color_buffer_float",                  o(ARB_color_buffer_float),                  GL,             2004 },
  86.    { "GL_ARB_copy_buffer",                         o(dummy_true),                              GL,             2008 },
  87.    { "GL_ARB_conservative_depth",                  o(ARB_conservative_depth),                  GL,             2011 },
  88.    { "GL_ARB_debug_output",                        o(dummy_true),                              GL,             2009 },
  89.    { "GL_ARB_depth_buffer_float",                  o(ARB_depth_buffer_float),                  GL,             2008 },
  90.    { "GL_ARB_depth_clamp",                         o(ARB_depth_clamp),                         GL,             2003 },
  91.    { "GL_ARB_depth_texture",                       o(ARB_depth_texture),                       GLL,            2001 },
  92.    { "GL_ARB_draw_buffers",                        o(dummy_true),                              GL,             2002 },
  93.    { "GL_ARB_draw_buffers_blend",                  o(ARB_draw_buffers_blend),                  GL,             2009 },
  94.    { "GL_ARB_draw_elements_base_vertex",           o(ARB_draw_elements_base_vertex),           GL,             2009 },
  95.    { "GL_ARB_draw_instanced",                      o(ARB_draw_instanced),                      GL,             2008 },
  96.    { "GL_ARB_explicit_attrib_location",            o(ARB_explicit_attrib_location),            GL,             2009 },
  97.    { "GL_ARB_fragment_coord_conventions",          o(ARB_fragment_coord_conventions),          GL,             2009 },
  98.    { "GL_ARB_fragment_program",                    o(ARB_fragment_program),                    GLL,            2002 },
  99.    { "GL_ARB_fragment_program_shadow",             o(ARB_fragment_program_shadow),             GLL,            2003 },
  100.    { "GL_ARB_fragment_shader",                     o(ARB_fragment_shader),                     GL,             2002 },
  101.    { "GL_ARB_framebuffer_object",                  o(ARB_framebuffer_object),                  GL,             2005 },
  102.    { "GL_ARB_framebuffer_sRGB",                    o(EXT_framebuffer_sRGB),                    GL,             1998 },
  103.    { "GL_ARB_get_program_binary",                  o(dummy_true),                              GL,             2010 },
  104.    { "GL_ARB_gpu_shader5",                         o(ARB_gpu_shader5),                         GL,             2010 },
  105.    { "GL_ARB_half_float_pixel",                    o(ARB_half_float_pixel),                    GL,             2003 },
  106.    { "GL_ARB_half_float_vertex",                   o(ARB_half_float_vertex),                   GL,             2008 },
  107.    { "GL_ARB_instanced_arrays",                    o(ARB_instanced_arrays),                    GL,             2008 },
  108.    { "GL_ARB_internalformat_query",                o(ARB_internalformat_query),                GL,             2011 },
  109.    { "GL_ARB_invalidate_subdata",                  o(dummy_true),                              GL,             2012 },
  110.    { "GL_ARB_map_buffer_alignment",                o(ARB_map_buffer_alignment),                GL,             2011 },
  111.    { "GL_ARB_map_buffer_range",                    o(ARB_map_buffer_range),                    GL,             2008 },
  112.    { "GL_ARB_multisample",                         o(dummy_true),                              GLL,            1994 },
  113.    { "GL_ARB_multitexture",                        o(dummy_true),                              GLL,            1998 },
  114.    { "GL_ARB_occlusion_query2",                    o(ARB_occlusion_query2),                    GL,             2003 },
  115.    { "GL_ARB_occlusion_query",                     o(ARB_occlusion_query),                     GLL,            2001 },
  116.    { "GL_ARB_pixel_buffer_object",                 o(EXT_pixel_buffer_object),                 GL,             2004 },
  117.    { "GL_ARB_point_parameters",                    o(EXT_point_parameters),                    GLL,            1997 },
  118.    { "GL_ARB_point_sprite",                        o(ARB_point_sprite),                        GL,             2003 },
  119.    { "GL_ARB_provoking_vertex",                    o(EXT_provoking_vertex),                    GL,             2009 },
  120.    { "GL_ARB_robustness",                          o(dummy_true),                              GL,             2010 },
  121.    { "GL_ARB_sampler_objects",                     o(dummy_true),                              GL,             2009 },
  122.    { "GL_ARB_seamless_cube_map",                   o(ARB_seamless_cube_map),                   GL,             2009 },
  123.    { "GL_ARB_shader_bit_encoding",                 o(ARB_shader_bit_encoding),                 GL,             2010 },
  124.    { "GL_ARB_shader_objects",                      o(dummy_true),                              GL,             2002 },
  125.    { "GL_ARB_shader_stencil_export",               o(ARB_shader_stencil_export),               GL,             2009 },
  126.    { "GL_ARB_shader_texture_lod",                  o(ARB_shader_texture_lod),                  GL,             2009 },
  127.    { "GL_ARB_shading_language_100",                o(dummy_true),                              GLL,            2003 },
  128.    { "GL_ARB_shading_language_packing",            o(ARB_shading_language_packing),            GL,             2011 },
  129.    { "GL_ARB_shading_language_420pack",            o(ARB_shading_language_420pack),            GL,             2011 },
  130.    { "GL_ARB_shadow",                              o(ARB_shadow),                              GLL,            2001 },
  131.    { "GL_ARB_sync",                                o(ARB_sync),                                GL,             2003 },
  132.    { "GL_ARB_texture_border_clamp",                o(ARB_texture_border_clamp),                GLL,            2000 },
  133.    { "GL_ARB_texture_buffer_object",               o(ARB_texture_buffer_object),               GLC,            2008 },
  134.    { "GL_ARB_texture_buffer_object_rgb32",         o(ARB_texture_buffer_object_rgb32),         GLC,            2009 },
  135.    { "GL_ARB_texture_buffer_range",                o(ARB_texture_buffer_range),                GLC,            2012 },
  136.    { "GL_ARB_texture_compression",                 o(dummy_true),                              GLL,            2000 },
  137.    { "GL_ARB_texture_compression_rgtc",            o(ARB_texture_compression_rgtc),            GL,             2004 },
  138.    { "GL_ARB_texture_cube_map",                    o(ARB_texture_cube_map),                    GLL,            1999 },
  139.    { "GL_ARB_texture_cube_map_array",              o(ARB_texture_cube_map_array),              GL,             2009 },
  140.    { "GL_ARB_texture_env_add",                     o(dummy_true),                              GLL,            1999 },
  141.    { "GL_ARB_texture_env_combine",                 o(ARB_texture_env_combine),                 GLL,            2001 },
  142.    { "GL_ARB_texture_env_crossbar",                o(ARB_texture_env_crossbar),                GLL,            2001 },
  143.    { "GL_ARB_texture_env_dot3",                    o(ARB_texture_env_dot3),                    GLL,            2001 },
  144.    { "GL_ARB_texture_float",                       o(ARB_texture_float),                       GL,             2004 },
  145.    { "GL_ARB_texture_mirrored_repeat",             o(dummy_true),                              GLL,            2001 },
  146.    { "GL_ARB_texture_multisample",                 o(ARB_texture_multisample),                 GL,             2009 },
  147.    { "GL_ARB_texture_non_power_of_two",            o(ARB_texture_non_power_of_two),            GL,             2003 },
  148.    { "GL_ARB_texture_query_lod",                   o(ARB_texture_query_lod),                   GL,             2009 },
  149.    { "GL_ARB_texture_rectangle",                   o(NV_texture_rectangle),                    GL,             2004 },
  150.    { "GL_ARB_texture_rgb10_a2ui",                  o(ARB_texture_rgb10_a2ui),                  GL,             2009 },
  151.    { "GL_ARB_texture_rg",                          o(ARB_texture_rg),                          GL,             2008 },
  152.    { "GL_ARB_texture_storage",                     o(dummy_true),                              GL,             2011 },
  153.    { "GL_ARB_texture_storage_multisample",         o(ARB_texture_multisample),                 GL,             2012 },
  154.    { "GL_ARB_texture_swizzle",                     o(EXT_texture_swizzle),                     GL,             2008 },
  155.    { "GL_ARB_timer_query",                         o(ARB_timer_query),                         GL,             2010 },
  156.    { "GL_ARB_transform_feedback2",                 o(ARB_transform_feedback2),                 GL,             2010 },
  157.    { "GL_ARB_transform_feedback3",                 o(ARB_transform_feedback3),                 GL,             2010 },
  158.    { "GL_ARB_transform_feedback_instanced",        o(ARB_transform_feedback_instanced),        GL,             2011 },
  159.    { "GL_ARB_transpose_matrix",                    o(dummy_true),                              GLL,            1999 },
  160.    { "GL_ARB_uniform_buffer_object",               o(ARB_uniform_buffer_object),               GL,             2009 },
  161.    { "GL_ARB_vertex_array_bgra",                   o(EXT_vertex_array_bgra),                   GL,             2008 },
  162.    { "GL_ARB_vertex_array_object",                 o(dummy_true),                              GL,             2006 },
  163.    { "GL_ARB_vertex_buffer_object",                o(dummy_true),                              GLL,            2003 },
  164.    { "GL_ARB_vertex_program",                      o(ARB_vertex_program),                      GLL,            2002 },
  165.    { "GL_ARB_vertex_shader",                       o(ARB_vertex_shader),                       GL,             2002 },
  166.    { "GL_ARB_vertex_type_2_10_10_10_rev",          o(ARB_vertex_type_2_10_10_10_rev),          GL,             2009 },
  167.    { "GL_ARB_window_pos",                          o(dummy_true),                              GLL,            2001 },
  168.    /* EXT extensions */
  169.    { "GL_EXT_abgr",                                o(dummy_true),                              GL,             1995 },
  170.    { "GL_EXT_bgra",                                o(dummy_true),                              GLL,            1995 },
  171.    { "GL_EXT_blend_color",                         o(EXT_blend_color),                         GLL,            1995 },
  172.    { "GL_EXT_blend_equation_separate",             o(EXT_blend_equation_separate),             GL,             2003 },
  173.    { "GL_EXT_blend_func_separate",                 o(EXT_blend_func_separate),                 GLL,            1999 },
  174.    { "GL_EXT_discard_framebuffer",                 o(dummy_true),                                    ES1 | ES2, 2009 },
  175.    { "GL_EXT_blend_minmax",                        o(EXT_blend_minmax),                        GLL | ES1 | ES2, 1995 },
  176.    { "GL_EXT_blend_subtract",                      o(dummy_true),                              GLL,            1995 },
  177.    { "GL_EXT_compiled_vertex_array",               o(dummy_true),                              GLL,            1996 },
  178.    { "GL_EXT_copy_texture",                        o(dummy_true),                              GLL,            1995 },
  179.    { "GL_EXT_depth_bounds_test",                   o(EXT_depth_bounds_test),                   GL,             2002 },
  180.    { "GL_EXT_draw_buffers2",                       o(EXT_draw_buffers2),                       GL,             2006 },
  181.    { "GL_EXT_draw_instanced",                      o(ARB_draw_instanced),                      GL,             2006 },
  182.    { "GL_EXT_draw_range_elements",                 o(dummy_true),                              GLL,            1997 },
  183.    { "GL_EXT_fog_coord",                           o(dummy_true),                              GLL,            1999 },
  184.    { "GL_EXT_framebuffer_blit",                    o(EXT_framebuffer_blit),                    GL,             2005 },
  185.    { "GL_EXT_framebuffer_multisample",             o(EXT_framebuffer_multisample),             GL,             2005 },
  186.    { "GL_EXT_framebuffer_multisample_blit_scaled", o(EXT_framebuffer_multisample_blit_scaled), GL,             2011 },
  187.    { "GL_EXT_framebuffer_object",                  o(dummy_true),                              GLL,            2000 },
  188.    { "GL_EXT_framebuffer_sRGB",                    o(EXT_framebuffer_sRGB),                    GL,             1998 },
  189.    { "GL_EXT_gpu_program_parameters",              o(EXT_gpu_program_parameters),              GLL,            2006 },
  190.    { "GL_EXT_gpu_shader4",                         o(EXT_gpu_shader4),                         GL,             2006 },
  191.    { "GL_EXT_map_buffer_range",                    o(ARB_map_buffer_range),                          ES1 | ES2, 2012 },
  192.    { "GL_EXT_multi_draw_arrays",                   o(dummy_true),                              GLL | ES1 | ES2, 1999 },
  193.    { "GL_EXT_packed_depth_stencil",                o(EXT_packed_depth_stencil),                GL,             2005 },
  194.    { "GL_EXT_packed_float",                        o(EXT_packed_float),                        GL,             2004 },
  195.    { "GL_EXT_packed_pixels",                       o(dummy_true),                              GLL,            1997 },
  196.    { "GL_EXT_pixel_buffer_object",                 o(EXT_pixel_buffer_object),                 GL,             2004 },
  197.    { "GL_EXT_point_parameters",                    o(EXT_point_parameters),                    GLL,            1997 },
  198.    { "GL_EXT_polygon_offset",                      o(dummy_true),                              GLL,            1995 },
  199.    { "GL_EXT_provoking_vertex",                    o(EXT_provoking_vertex),                    GL,             2009 },
  200.    { "GL_EXT_rescale_normal",                      o(dummy_true),                              GLL,            1997 },
  201.    { "GL_EXT_secondary_color",                     o(dummy_true),                              GLL,            1999 },
  202.    { "GL_EXT_separate_shader_objects",             o(EXT_separate_shader_objects),             GLL,            2008 },
  203.    { "GL_EXT_separate_specular_color",             o(dummy_true),                              GLL,            1997 },
  204.    { "GL_EXT_shadow_funcs",                        o(ARB_shadow),                              GLL,            2002 },
  205.    { "GL_EXT_stencil_two_side",                    o(EXT_stencil_two_side),                    GLL,            2001 },
  206.    { "GL_EXT_stencil_wrap",                        o(dummy_true),                              GLL,            2002 },
  207.    { "GL_EXT_subtexture",                          o(dummy_true),                              GLL,            1995 },
  208.    { "GL_EXT_texture3D",                           o(EXT_texture3D),                           GLL,            1996 },
  209.    { "GL_EXT_texture_array",                       o(EXT_texture_array),                       GL,             2006 },
  210.    { "GL_EXT_texture_compression_dxt1",            o(ANGLE_texture_compression_dxt),           GL | ES1 | ES2, 2004 },
  211.    { "GL_ANGLE_texture_compression_dxt3",          o(ANGLE_texture_compression_dxt),           GL | ES1 | ES2, 2011 },
  212.    { "GL_ANGLE_texture_compression_dxt5",          o(ANGLE_texture_compression_dxt),           GL | ES1 | ES2, 2011 },
  213.    { "GL_EXT_texture_compression_latc",            o(EXT_texture_compression_latc),            GL,             2006 },
  214.    { "GL_EXT_texture_compression_rgtc",            o(ARB_texture_compression_rgtc),            GL,             2004 },
  215.    { "GL_EXT_texture_compression_s3tc",            o(EXT_texture_compression_s3tc),            GL,             2000 },
  216.    { "GL_EXT_texture_cube_map",                    o(ARB_texture_cube_map),                    GLL,            2001 },
  217.    { "GL_EXT_texture_edge_clamp",                  o(dummy_true),                              GLL,            1997 },
  218.    { "GL_EXT_texture_env_add",                     o(dummy_true),                              GLL,            1999 },
  219.    { "GL_EXT_texture_env_combine",                 o(dummy_true),                              GLL,            2000 },
  220.    { "GL_EXT_texture_env_dot3",                    o(EXT_texture_env_dot3),                    GLL,            2000 },
  221.    { "GL_EXT_texture_filter_anisotropic",          o(EXT_texture_filter_anisotropic),          GL | ES1 | ES2, 1999 },
  222.    { "GL_EXT_texture_format_BGRA8888",             o(dummy_true),                                   ES1 | ES2, 2005 },
  223.    { "GL_EXT_texture_rg",                          o(ARB_texture_rg),                                     ES2, 2011 },
  224.    { "GL_EXT_read_format_bgra",                    o(dummy_true),                                   ES1 | ES2, 2009 },
  225.    { "GL_EXT_texture_integer",                     o(EXT_texture_integer),                     GL,             2006 },
  226.    { "GL_EXT_texture_lod_bias",                    o(dummy_true),                              GLL | ES1,      1999 },
  227.    { "GL_EXT_texture_mirror_clamp",                o(EXT_texture_mirror_clamp),                GL,             2004 },
  228.    { "GL_EXT_texture_object",                      o(dummy_true),                              GLL,            1995 },
  229.    { "GL_EXT_texture",                             o(dummy_true),                              GLL,            1996 },
  230.    { "GL_EXT_texture_rectangle",                   o(NV_texture_rectangle),                    GLL,            2004 },
  231.    { "GL_EXT_texture_shared_exponent",             o(EXT_texture_shared_exponent),             GL,             2004 },
  232.    { "GL_EXT_texture_snorm",                       o(EXT_texture_snorm),                       GL,             2009 },
  233.    { "GL_EXT_texture_sRGB",                        o(EXT_texture_sRGB),                        GL,             2004 },
  234.    { "GL_EXT_texture_sRGB_decode",                 o(EXT_texture_sRGB_decode),                        GL,      2006 },
  235.    { "GL_EXT_texture_swizzle",                     o(EXT_texture_swizzle),                     GL,             2008 },
  236.    { "GL_EXT_texture_type_2_10_10_10_REV",         o(dummy_true),                                         ES2, 2008 },
  237.    { "GL_EXT_timer_query",                         o(EXT_timer_query),                         GL,             2006 },
  238.    { "GL_EXT_transform_feedback",                  o(EXT_transform_feedback),                  GL,             2011 },
  239.    { "GL_EXT_unpack_subimage",                     o(dummy_true),                                         ES2, 2011 },
  240.    { "GL_EXT_vertex_array_bgra",                   o(EXT_vertex_array_bgra),                   GL,             2008 },
  241.    { "GL_EXT_vertex_array",                        o(dummy_true),                              GLL,            1995 },
  242.    { "GL_EXT_color_buffer_float",                  o(dummy_true),                                         ES3, 2013 },
  243.  
  244.    /* OES extensions */
  245.    { "GL_OES_blend_equation_separate",             o(EXT_blend_equation_separate),                  ES1,       2009 },
  246.    { "GL_OES_blend_func_separate",                 o(EXT_blend_func_separate),                      ES1,       2009 },
  247.    { "GL_OES_blend_subtract",                      o(dummy_true),                                   ES1,       2009 },
  248.    { "GL_OES_byte_coordinates",                    o(dummy_true),                                   ES1,       2002 },
  249.    { "GL_OES_compressed_ETC1_RGB8_texture",        o(OES_compressed_ETC1_RGB8_texture),             ES1 | ES2, 2005 },
  250.    { "GL_OES_compressed_paletted_texture",         o(dummy_true),                                   ES1,       2003 },
  251.    { "GL_OES_depth24",                             o(dummy_true),                                   ES1 | ES2, 2005 },
  252.    { "GL_OES_depth32",                             o(dummy_false),                     DISABLE,                2005 },
  253.    { "GL_OES_depth_texture",                       o(ARB_depth_texture),                                  ES2, 2006 },
  254.    { "GL_OES_depth_texture_cube_map",              o(OES_depth_texture_cube_map),                         ES2, 2012 },
  255.    { "GL_OES_draw_texture",                        o(OES_draw_texture),                             ES1,       2004 },
  256.    /*  FIXME: Mesa expects GL_OES_EGL_image to be available in OpenGL contexts. */
  257.    { "GL_OES_EGL_image",                           o(OES_EGL_image),                           GL | ES1 | ES2, 2006 },
  258.    { "GL_OES_EGL_image_external",                  o(OES_EGL_image_external),                       ES1 | ES2, 2010 },
  259.    { "GL_OES_element_index_uint",                  o(dummy_true),                                   ES1 | ES2, 2005 },
  260.    { "GL_OES_fbo_render_mipmap",                   o(dummy_true),                                   ES1 | ES2, 2005 },
  261.    { "GL_OES_fixed_point",                         o(dummy_true),                                   ES1,       2002 },
  262.    { "GL_OES_framebuffer_object",                  o(dummy_true),                                   ES1,       2005 },
  263.    { "GL_OES_get_program_binary",                  o(dummy_true),                                         ES2, 2008 },
  264.    { "GL_OES_mapbuffer",                           o(dummy_true),                                   ES1 | ES2, 2005 },
  265.    { "GL_OES_packed_depth_stencil",                o(EXT_packed_depth_stencil),                     ES1 | ES2, 2007 },
  266.    { "GL_OES_point_size_array",                    o(dummy_true),                                   ES1,       2004 },
  267.    { "GL_OES_point_sprite",                        o(ARB_point_sprite),                             ES1,       2004 },
  268.    { "GL_OES_query_matrix",                        o(dummy_true),                                   ES1,       2003 },
  269.    { "GL_OES_read_format",                         o(dummy_true),                              GL | ES1,       2003 },
  270.    { "GL_OES_rgb8_rgba8",                          o(dummy_true),                                   ES1 | ES2, 2005 },
  271.    { "GL_OES_single_precision",                    o(dummy_true),                                   ES1,       2003 },
  272.    { "GL_OES_standard_derivatives",                o(OES_standard_derivatives),                           ES2, 2005 },
  273.    { "GL_OES_stencil1",                            o(dummy_false),                     DISABLE,                2005 },
  274.    { "GL_OES_stencil4",                            o(dummy_false),                     DISABLE,                2005 },
  275.    { "GL_OES_stencil8",                            o(dummy_true),                                   ES1 | ES2, 2005 },
  276.    { "GL_OES_stencil_wrap",                        o(dummy_true),                                   ES1,       2002 },
  277.    { "GL_OES_texture_3D",                          o(EXT_texture3D),                                      ES2, 2005 },
  278.    { "GL_OES_texture_cube_map",                    o(ARB_texture_cube_map),                         ES1,       2007 },
  279.    { "GL_OES_texture_env_crossbar",                o(ARB_texture_env_crossbar),                     ES1,       2005 },
  280.    { "GL_OES_texture_mirrored_repeat",             o(dummy_true),                                   ES1,       2005 },
  281.    { "GL_OES_texture_npot",                        o(ARB_texture_non_power_of_two),                 ES1 | ES2, 2005 },
  282.    { "GL_OES_vertex_array_object",                 o(dummy_true),                                   ES1 | ES2, 2010 },
  283.  
  284.    /* Vendor extensions */
  285.    { "GL_3DFX_texture_compression_FXT1",           o(TDFX_texture_compression_FXT1),           GL,             1999 },
  286.    { "GL_AMD_conservative_depth",                  o(ARB_conservative_depth),                  GL,             2009 },
  287.    { "GL_AMD_draw_buffers_blend",                  o(ARB_draw_buffers_blend),                  GL,             2009 },
  288.    { "GL_AMD_seamless_cubemap_per_texture",        o(AMD_seamless_cubemap_per_texture),        GL,             2009 },
  289.    { "GL_AMD_shader_stencil_export",               o(ARB_shader_stencil_export),               GL,             2009 },
  290.    { "GL_AMD_vertex_shader_layer",                 o(AMD_vertex_shader_layer),                 GL,             2012 },
  291.    { "GL_APPLE_object_purgeable",                  o(APPLE_object_purgeable),                  GL,             2006 },
  292.    { "GL_APPLE_packed_pixels",                     o(dummy_true),                              GLL,            2002 },
  293.    { "GL_APPLE_texture_max_level",                 o(dummy_true),                                   ES1 | ES2, 2009 },
  294.    { "GL_APPLE_vertex_array_object",               o(dummy_true),                              GLL,            2002 },
  295.    { "GL_ATI_blend_equation_separate",             o(EXT_blend_equation_separate),             GL,             2003 },
  296.    { "GL_ATI_draw_buffers",                        o(dummy_true),                              GLL,            2002 },
  297.    { "GL_ATI_envmap_bumpmap",                      o(ATI_envmap_bumpmap),                      GLL,            2001 },
  298.    { "GL_ATI_fragment_shader",                     o(ATI_fragment_shader),                     GLL,            2001 },
  299.    { "GL_ATI_separate_stencil",                    o(ATI_separate_stencil),                    GLL,            2006 },
  300.    { "GL_ATI_texture_compression_3dc",             o(ATI_texture_compression_3dc),             GL,             2004 },
  301.    { "GL_ATI_texture_env_combine3",                o(ATI_texture_env_combine3),                GLL,            2002 },
  302.    { "GL_ATI_texture_float",                       o(ARB_texture_float),                       GL,             2002 },
  303.    { "GL_ATI_texture_mirror_once",                 o(ATI_texture_mirror_once),                 GL,             2006 },
  304.    { "GL_IBM_multimode_draw_arrays",               o(dummy_true),                              GL,             1998 },
  305.    { "GL_IBM_rasterpos_clip",                      o(dummy_true),                              GLL,            1996 },
  306.    { "GL_IBM_texture_mirrored_repeat",             o(dummy_true),                              GLL,            1998 },
  307.    { "GL_INGR_blend_func_separate",                o(EXT_blend_func_separate),                 GLL,            1999 },
  308.    { "GL_MESA_pack_invert",                        o(MESA_pack_invert),                        GL,             2002 },
  309.    { "GL_MESA_texture_array",                      o(MESA_texture_array),                      GLL,            2007 },
  310.    { "GL_MESA_texture_signed_rgba",                o(EXT_texture_snorm),                       GL,             2009 },
  311.    { "GL_MESA_window_pos",                         o(dummy_true),                              GLL,            2000 },
  312.    { "GL_MESA_ycbcr_texture",                      o(MESA_ycbcr_texture),                      GL,             2002 },
  313.    { "GL_NV_blend_square",                         o(dummy_true),                              GLL,            1999 },
  314.    { "GL_NV_conditional_render",                   o(NV_conditional_render),                   GL,             2008 },
  315.    { "GL_NV_depth_clamp",                          o(ARB_depth_clamp),                         GL,             2001 },
  316.    { "GL_NV_draw_buffers",                         o(dummy_true),                                         ES2, 2011 },
  317.    { "GL_NV_fbo_color_attachments",                o(dummy_true),                                         ES2, 2010 },
  318.    { "GL_NV_fog_distance",                         o(NV_fog_distance),                         GLL,            2001 },
  319.    { "GL_NV_fragment_program_option",              o(NV_fragment_program_option),              GLL,            2005 },
  320.    { "GL_NV_light_max_exponent",                   o(dummy_true),                              GLL,            1999 },
  321.    { "GL_NV_packed_depth_stencil",                 o(EXT_packed_depth_stencil),                GL,             2000 },
  322.    { "GL_NV_point_sprite",                         o(NV_point_sprite),                         GL,             2001 },
  323.    { "GL_NV_primitive_restart",                    o(NV_primitive_restart),                    GLL,            2002 },
  324.    { "GL_NV_read_buffer",                          o(dummy_true),                              ES2,            2011 },
  325.    { "GL_NV_texgen_reflection",                    o(dummy_true),                              GLL,            1999 },
  326.    { "GL_NV_texture_barrier",                      o(NV_texture_barrier),                      GL,             2009 },
  327.    { "GL_NV_texture_env_combine4",                 o(NV_texture_env_combine4),                 GLL,            1999 },
  328.    { "GL_NV_texture_rectangle",                    o(NV_texture_rectangle),                    GLL,            2000 },
  329.    { "GL_S3_s3tc",                                 o(ANGLE_texture_compression_dxt),           GL,             1999 },
  330.    { "GL_SGIS_generate_mipmap",                    o(dummy_true),                              GLL,            1997 },
  331.    { "GL_SGIS_texture_border_clamp",               o(ARB_texture_border_clamp),                GLL,            1997 },
  332.    { "GL_SGIS_texture_edge_clamp",                 o(dummy_true),                              GLL,            1997 },
  333.    { "GL_SGIS_texture_lod",                        o(dummy_true),                              GLL,            1997 },
  334.    { "GL_SUN_multi_draw_arrays",                   o(dummy_true),                              GLL,            1999 },
  335.  
  336.    { 0, 0, 0, 0 },
  337. };
  338.  
  339.  
  340. /**
  341.  * Given an extension name, lookup up the corresponding member of struct
  342.  * gl_extensions and return that member's offset (in bytes).  If the name is
  343.  * not found in the \c extension_table, return 0.
  344.  *
  345.  * \param name Name of extension.
  346.  * \return Offset of member in struct gl_extensions.
  347.  */
  348. static size_t
  349. name_to_offset(const char* name)
  350. {
  351.    const struct extension *i;
  352.  
  353.    if (name == 0)
  354.       return 0;
  355.  
  356.    for (i = extension_table; i->name != 0; ++i) {
  357.       if (strcmp(name, i->name) == 0)
  358.          return i->offset;
  359.    }
  360.  
  361.    return 0;
  362. }
  363.  
  364.  
  365. /**
  366.  * Enable all extensions suitable for a software-only renderer.
  367.  * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.
  368.  */
  369. void
  370. _mesa_enable_sw_extensions(struct gl_context *ctx)
  371. {
  372.    ctx->Extensions.ARB_depth_clamp = GL_TRUE;
  373.    ctx->Extensions.ARB_depth_texture = GL_TRUE;
  374.    ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
  375.    ctx->Extensions.ARB_draw_instanced = GL_TRUE;
  376.    ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
  377.    ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
  378.    ctx->Extensions.ARB_fragment_program = GL_TRUE;
  379.    ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
  380.    ctx->Extensions.ARB_fragment_shader = GL_TRUE;
  381.    ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
  382.    /* XXX re-enable when GLSL compiler again supports geometry shaders */
  383. #if 0
  384.    ctx->Extensions.ARB_geometry_shader4 = GL_TRUE;
  385. #endif
  386.    ctx->Extensions.ARB_half_float_pixel = GL_TRUE;
  387.    ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
  388.    ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
  389.    ctx->Extensions.ARB_occlusion_query = GL_TRUE;
  390.    ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
  391.    ctx->Extensions.ARB_point_sprite = GL_TRUE;
  392.    ctx->Extensions.EXT_separate_shader_objects = GL_TRUE;
  393.    ctx->Extensions.ARB_shadow = GL_TRUE;
  394.    ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
  395.    ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
  396.    ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
  397.    ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
  398.    ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
  399. #ifdef TEXTURE_FLOAT_ENABLED
  400.    ctx->Extensions.ARB_texture_float = GL_TRUE;
  401. #endif
  402.    ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
  403.    ctx->Extensions.ARB_texture_rg = GL_TRUE;
  404.    ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
  405.    ctx->Extensions.ARB_vertex_program = GL_TRUE;
  406.    ctx->Extensions.ARB_vertex_shader = GL_TRUE;
  407.    ctx->Extensions.ARB_sync = GL_TRUE;
  408.    ctx->Extensions.APPLE_object_purgeable = GL_TRUE;
  409.    ctx->Extensions.ATI_envmap_bumpmap = GL_TRUE;
  410.    ctx->Extensions.ATI_fragment_shader = GL_TRUE;
  411.    ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
  412.    ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
  413.    ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
  414.    ctx->Extensions.ATI_separate_stencil = GL_TRUE;
  415.    ctx->Extensions.EXT_blend_color = GL_TRUE;
  416.    ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
  417.    ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
  418.    ctx->Extensions.EXT_blend_minmax = GL_TRUE;
  419.    ctx->Extensions.EXT_depth_bounds_test = GL_TRUE;
  420.    ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
  421.    ctx->Extensions.EXT_framebuffer_blit = GL_TRUE;
  422.    ctx->Extensions.EXT_packed_depth_stencil = GL_TRUE;
  423.    ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
  424.    ctx->Extensions.EXT_point_parameters = GL_TRUE;
  425.    ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
  426.    ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
  427.    ctx->Extensions.EXT_texture_array = GL_TRUE;
  428.    ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
  429.    ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
  430.    ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;
  431.    ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
  432.    ctx->Extensions.EXT_texture_shared_exponent = GL_TRUE;
  433.    ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
  434.    ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
  435.    ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
  436.    /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/
  437.    ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
  438.    ctx->Extensions.MESA_pack_invert = GL_TRUE;
  439.    ctx->Extensions.MESA_texture_array = GL_TRUE;
  440.    ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
  441.    ctx->Extensions.NV_conditional_render = GL_TRUE;
  442.    ctx->Extensions.NV_point_sprite = GL_TRUE;
  443.    ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
  444.    ctx->Extensions.NV_texture_rectangle = GL_TRUE;
  445.    ctx->Extensions.NV_fragment_program_option = GL_TRUE;
  446.    ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
  447.    ctx->Extensions.OES_standard_derivatives = GL_TRUE;
  448.    ctx->Extensions.TDFX_texture_compression_FXT1 = GL_TRUE;
  449.    if (ctx->Mesa_DXTn) {
  450.       ctx->Extensions.ANGLE_texture_compression_dxt = GL_TRUE;
  451.       ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
  452.    }
  453. }
  454.  
  455. /**
  456.  * Either enable or disable the named extension.
  457.  * \return GL_TRUE for success, GL_FALSE if invalid extension name
  458.  */
  459. static GLboolean
  460. set_extension( struct gl_context *ctx, const char *name, GLboolean state )
  461. {
  462.    size_t offset;
  463.  
  464.    if (ctx->Extensions.String) {
  465.       /* The string was already queried - can't change it now! */
  466.       _mesa_problem(ctx, "Trying to enable/disable extension after glGetString(GL_EXTENSIONS): %s", name);
  467.       return GL_FALSE;
  468.    }
  469.  
  470.    offset = name_to_offset(name);
  471.    if (offset == 0) {
  472.       _mesa_problem(ctx, "Trying to enable/disable unknown extension %s",
  473.                     name);
  474.       return GL_FALSE;
  475.    } else if (offset == o(dummy_true) && state == GL_FALSE) {
  476.       _mesa_problem(ctx, "Trying to disable a permanently enabled extension: "
  477.                           "%s", name);
  478.       return GL_FALSE;
  479.    } else {
  480.       GLboolean *base = (GLboolean *) &ctx->Extensions;
  481.       base[offset] = state;
  482.       return GL_TRUE;
  483.    }
  484. }
  485.  
  486. /**
  487.  * \brief Apply the \c MESA_EXTENSION_OVERRIDE environment variable.
  488.  *
  489.  * \c MESA_EXTENSION_OVERRIDE is a space-separated list of extensions to
  490.  * enable or disable. The list is processed thus:
  491.  *    - Enable recognized extension names that are prefixed with '+'.
  492.  *    - Disable recognized extension names that are prefixed with '-'.
  493.  *    - Enable recognized extension names that are not prefixed.
  494.  *    - Collect unrecognized extension names in a new string.
  495.  *
  496.  * \return Space-separated list of unrecognized extension names (which must
  497.  *    be freed). Does not return \c NULL.
  498.  */
  499. static char *
  500. get_extension_override( struct gl_context *ctx )
  501. {
  502.    const char *env_const = _mesa_getenv("MESA_EXTENSION_OVERRIDE");
  503.    char *env;
  504.    char *ext;
  505.    char *extra_exts;
  506.    int len;
  507.  
  508.    if (env_const == NULL) {
  509.       /* Return the empty string rather than NULL. This simplifies the logic
  510.        * of client functions. */
  511.       return calloc(4, sizeof(char));
  512.    }
  513.  
  514.    /* extra_exts: List of unrecognized extensions. */
  515.    extra_exts = calloc(ALIGN(strlen(env_const) + 2, 4), sizeof(char));
  516.  
  517.    /* Copy env_const because strtok() is destructive. */
  518.    env = strdup(env_const);
  519.    for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {
  520.       int enable;
  521.       int recognized;
  522.       switch (ext[0]) {
  523.       case '+':
  524.          enable = 1;
  525.          ++ext;
  526.          break;
  527.       case '-':
  528.          enable = 0;
  529.          ++ext;
  530.          break;
  531.       default:
  532.          enable = 1;
  533.          break;
  534.       }
  535.       recognized = set_extension(ctx, ext, enable);
  536.       if (!recognized) {
  537.          strcat(extra_exts, ext);
  538.          strcat(extra_exts, " ");
  539.       }
  540.    }
  541.  
  542.    free(env);
  543.  
  544.    /* Remove trailing space. */
  545.    len = strlen(extra_exts);
  546.    if (len > 0 && extra_exts[len - 1] == ' ')
  547.       extra_exts[len - 1] = '\0';
  548.  
  549.    return extra_exts;
  550. }
  551.  
  552.  
  553. /**
  554.  * \brief Initialize extension tables and enable default extensions.
  555.  *
  556.  * This should be called during context initialization.
  557.  * Note: Sets gl_extensions.dummy_true to true.
  558.  */
  559. void
  560. _mesa_init_extensions( struct gl_context *ctx )
  561. {
  562.    GLboolean *base = (GLboolean *) &ctx->Extensions;
  563.    GLboolean *sentinel = base + o(extension_sentinel);
  564.    GLboolean *i;
  565.  
  566.    /* First, turn all extensions off. */
  567.    for (i = base; i != sentinel; ++i)
  568.       *i = GL_FALSE;
  569.  
  570.    /* Then, selectively turn default extensions on. */
  571.    ctx->Extensions.dummy_true = GL_TRUE;
  572.    ctx->Extensions.EXT_texture3D = GL_TRUE;
  573. }
  574.  
  575.  
  576. typedef unsigned short extension_index;
  577.  
  578.  
  579. /**
  580.  * Compare two entries of the extensions table.  Sorts first by year,
  581.  * then by name.
  582.  *
  583.  * Arguments are indices into extension_table.
  584.  */
  585. static int
  586. extension_compare(const void *p1, const void *p2)
  587. {
  588.    extension_index i1 = * (const extension_index *) p1;
  589.    extension_index i2 = * (const extension_index *) p2;
  590.    const struct extension *e1 = &extension_table[i1];
  591.    const struct extension *e2 = &extension_table[i2];
  592.    int res;
  593.  
  594.    res = (int)e1->year - (int)e2->year;
  595.  
  596.    if (res == 0) {
  597.       res = strcmp(e1->name, e2->name);
  598.    }
  599.  
  600.    return res;
  601. }
  602.  
  603.  
  604. /**
  605.  * Construct the GL_EXTENSIONS string.  Called the first time that
  606.  * glGetString(GL_EXTENSIONS) is called.
  607.  */
  608. GLubyte*
  609. _mesa_make_extension_string(struct gl_context *ctx)
  610. {
  611.    /* The extension string. */
  612.    char *exts = 0;
  613.    /* Length of extension string. */
  614.    size_t length = 0;
  615.    /* Number of extensions */
  616.    unsigned count;
  617.    /* Indices of the extensions sorted by year */
  618.    extension_index *extension_indices;
  619.    /* String of extra extensions. */
  620.    char *extra_extensions = get_extension_override(ctx);
  621.    GLboolean *base = (GLboolean *) &ctx->Extensions;
  622.    const struct extension *i;
  623.    unsigned j;
  624.    unsigned maxYear = ~0;
  625.    unsigned api_set = (1 << ctx->API);
  626.    if (_mesa_is_gles3(ctx))
  627.       api_set |= ES3;
  628.  
  629.    /* Check if the MESA_EXTENSION_MAX_YEAR env var is set */
  630.    {
  631.       const char *env = getenv("MESA_EXTENSION_MAX_YEAR");
  632.       if (env) {
  633.          maxYear = atoi(env);
  634.          _mesa_debug(ctx, "Note: limiting GL extensions to %u or earlier\n",
  635.                      maxYear);
  636.       }
  637.    }
  638.  
  639.    /* Compute length of the extension string. */
  640.    count = 0;
  641.    for (i = extension_table; i->name != 0; ++i) {
  642.       if (base[i->offset] &&
  643.           i->year <= maxYear &&
  644.           (i->api_set & api_set)) {
  645.          length += strlen(i->name) + 1; /* +1 for space */
  646.          ++count;
  647.       }
  648.    }
  649.    if (extra_extensions != NULL)
  650.       length += 1 + strlen(extra_extensions); /* +1 for space */
  651.  
  652.    exts = calloc(ALIGN(length + 1, 4), sizeof(char));
  653.    if (exts == NULL) {
  654.       free(extra_extensions);
  655.       return NULL;
  656.    }
  657.  
  658.    extension_indices = malloc(count * sizeof(extension_index));
  659.    if (extension_indices == NULL) {
  660.       free(exts);
  661.       free(extra_extensions);
  662.       return NULL;
  663.    }
  664.  
  665.    /* Sort extensions in chronological order because certain old applications (e.g.,
  666.     * Quake3 demo) store the extension list in a static size buffer so chronologically
  667.     * order ensure that the extensions that such applications expect will fit into
  668.     * that buffer.
  669.     */
  670.    j = 0;
  671.    for (i = extension_table; i->name != 0; ++i) {
  672.       if (base[i->offset] &&
  673.           i->year <= maxYear &&
  674.           (i->api_set & api_set)) {
  675.          extension_indices[j++] = i - extension_table;
  676.       }
  677.    }
  678.    assert(j == count);
  679.    qsort(extension_indices, count, sizeof *extension_indices, extension_compare);
  680.  
  681.    /* Build the extension string.*/
  682.    for (j = 0; j < count; ++j) {
  683.       i = &extension_table[extension_indices[j]];
  684.       assert(base[i->offset] && (i->api_set & api_set));
  685.       strcat(exts, i->name);
  686.       strcat(exts, " ");
  687.    }
  688.    free(extension_indices);
  689.    if (extra_extensions != 0) {
  690.       strcat(exts, extra_extensions);
  691.       free(extra_extensions);
  692.    }
  693.  
  694.    return (GLubyte *) exts;
  695. }
  696.  
  697. /**
  698.  * Return number of enabled extensions.
  699.  */
  700. GLuint
  701. _mesa_get_extension_count(struct gl_context *ctx)
  702. {
  703.    GLboolean *base;
  704.    const struct extension *i;
  705.    unsigned api_set = (1 << ctx->API);
  706.    if (_mesa_is_gles3(ctx))
  707.       api_set |= ES3;
  708.  
  709.    /* only count once */
  710.    if (ctx->Extensions.Count != 0)
  711.       return ctx->Extensions.Count;
  712.  
  713.    base = (GLboolean *) &ctx->Extensions;
  714.    for (i = extension_table; i->name != 0; ++i) {
  715.       if (base[i->offset] && (i->api_set & api_set)) {
  716.          ctx->Extensions.Count++;
  717.       }
  718.    }
  719.    return ctx->Extensions.Count;
  720. }
  721.  
  722. /**
  723.  * Return name of i-th enabled extension
  724.  */
  725. const GLubyte *
  726. _mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
  727. {
  728.    const GLboolean *base;
  729.    size_t n;
  730.    const struct extension *i;
  731.    unsigned api_set = (1 << ctx->API);
  732.    if (_mesa_is_gles3(ctx))
  733.       api_set |= ES3;
  734.  
  735.    base = (GLboolean*) &ctx->Extensions;
  736.    n = 0;
  737.    for (i = extension_table; i->name != 0; ++i) {
  738.       if (base[i->offset] && (i->api_set & api_set)) {
  739.          if (n == index)
  740.             return (const GLubyte*) i->name;
  741.          else
  742.             ++n;
  743.       }
  744.    }
  745.  
  746.    return NULL;
  747. }
  748.