src/mesa/main/extensions.c

   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 struct gl_extensions _mesa_extension_override_enables;
  41 struct gl_extensions _mesa_extension_override_disables;
  42 static char *unrecognized_extensions = NULL;
  43
  44
  45 /**
  46  * Given a member \c x of struct gl_extensions, return offset of
  47  * \c x in bytes.
  48  */
  49 #define o(x) offsetof(struct gl_extensions, x)
  50
  51 /**
  52  * Given an extension name, lookup up the corresponding member of struct
  53  * gl_extensions and return that member's index.  If the name is
  54  * not found in the \c _mesa_extension_table, return -1.
  55  *
  56  * \param name Name of extension.
  57  * \return Index of member in struct gl_extensions.
  58  */
  59 static int
  60 name_to_index(const char* name)
  61 {
  62    unsigned i;
  63
  64    if (name == 0)
  65       return -1;
  66
  67    for (i = 0; i < MESA_EXTENSION_COUNT; ++i) {
  68       if (strcmp(name, _mesa_extension_table[i].name) == 0)
  69          return i;
  70    }
  71
  72    return -1;
  73 }
  74
  75 /**
  76  * Overrides extensions in \c ctx based on the values in
  77  * _mesa_extension_override_enables and _mesa_extension_override_disables.
  78  */
  79 void
  80 _mesa_override_extensions(struct gl_context *ctx)
  81 {
  82    unsigned i;
  83    const GLboolean *enables =
  84       (GLboolean*) &_mesa_extension_override_enables;
  85    const GLboolean *disables =
  86       (GLboolean*) &_mesa_extension_override_disables;
  87    GLboolean *ctx_ext = (GLboolean*)&ctx->Extensions;
  88
  89    for (i = 0; i < MESA_EXTENSION_COUNT; ++i) {
  90       size_t offset = _mesa_extension_table[i].offset;
  91
  92       assert(!enables[offset] || !disables[offset]);
  93       if (enables[offset]) {
  94          ctx_ext[offset] = 1;
  95       } else if (disables[offset]) {
  96          ctx_ext[offset] = 0;
  97       }
  98    }
  99 }
 100
 101
 102 /**
 103  * Enable all extensions suitable for a software-only renderer.
 104  * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.
 105  */
 106 void
 107 _mesa_enable_sw_extensions(struct gl_context *ctx)
 108 {
 109    ctx->Extensions.ARB_depth_clamp = GL_TRUE;
 110    ctx->Extensions.ARB_depth_texture = GL_TRUE;
 111    ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
 112    ctx->Extensions.ARB_draw_instanced = GL_TRUE;
 113    ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
 114    ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
 115    ctx->Extensions.ARB_fragment_program = GL_TRUE;
 116    ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
 117    ctx->Extensions.ARB_fragment_shader = GL_TRUE;
 118    ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
 119    ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
 120    ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
 121    ctx->Extensions.ARB_occlusion_query = GL_TRUE;
 122    ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
 123    ctx->Extensions.ARB_point_sprite = GL_TRUE;
 124    ctx->Extensions.ARB_shadow = GL_TRUE;
 125    ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
 126    ctx->Extensions.ARB_texture_compression_bptc = GL_TRUE;
 127    ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
 128    ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
 129    ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
 130    ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
 131    ctx->Extensions.ARB_texture_filter_anisotropic = GL_TRUE;
 132 #ifdef TEXTURE_FLOAT_ENABLED
 133    ctx->Extensions.ARB_texture_float = GL_TRUE;
 134 #endif
 135    ctx->Extensions.ARB_texture_mirror_clamp_to_edge = GL_TRUE;
 136    ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
 137    ctx->Extensions.ARB_texture_rg = GL_TRUE;
 138    ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
 139    ctx->Extensions.ARB_vertex_program = GL_TRUE;
 140    ctx->Extensions.ARB_vertex_shader = GL_TRUE;
 141    ctx->Extensions.ARB_sync = GL_TRUE;
 142    ctx->Extensions.APPLE_object_purgeable = GL_TRUE;
 143    ctx->Extensions.ATI_fragment_shader = GL_TRUE;
 144    ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
 145    ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
 146    ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
 147    ctx->Extensions.ATI_separate_stencil = GL_TRUE;
 148    ctx->Extensions.EXT_blend_color = GL_TRUE;
 149    ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
 150    ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
 151    ctx->Extensions.EXT_blend_minmax = GL_TRUE;
 152    ctx->Extensions.EXT_depth_bounds_test = GL_TRUE;
 153    ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
 154    ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
 155    ctx->Extensions.EXT_point_parameters = GL_TRUE;
 156    ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
 157    ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
 158    ctx->Extensions.EXT_texture_array = GL_TRUE;
 159    ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
 160    ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
 161    ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;
 162    ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
 163    ctx->Extensions.EXT_texture_shared_exponent = GL_TRUE;
 164    ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
 165    ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
 166    ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
 167    /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/
 168    ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
 169    ctx->Extensions.MESA_pack_invert = GL_TRUE;
 170    ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
 171    ctx->Extensions.NV_conditional_render = GL_TRUE;
 172    ctx->Extensions.NV_point_sprite = GL_TRUE;
 173    ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
 174    ctx->Extensions.NV_texture_rectangle = GL_TRUE;
 175    ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
 176    ctx->Extensions.OES_standard_derivatives = GL_TRUE;
 177    ctx->Extensions.TDFX_texture_compression_FXT1 = GL_TRUE;
 178    ctx->Extensions.ANGLE_texture_compression_dxt = GL_TRUE;
 179    ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
 180 }
 181
 182 /**
 183  * Either enable or disable the named extension.
 184  * \return offset of extensions withint `ext' or 0 if extension is not known
 185  */
 186 static size_t
 187 set_extension(struct gl_extensions *ext, int i, GLboolean state)
 188 {
 189    size_t offset;
 190
 191    offset = i < 0 ? 0 : _mesa_extension_table[i].offset;
 192    if (offset != 0 && (offset != o(dummy_true) || state != GL_FALSE)) {
 193       ((GLboolean *) ext)[offset] = state;
 194    }
 195
 196    return offset;
 197 }
 198
 199
 200 /**
 201  * \brief Free string pointed by unrecognized_extensions
 202  *
 203  * This string is allocated early during the first context creation by
 204  * _mesa_one_time_init_extension_overrides.
 205  */
 206 static void
 207 free_unknown_extensions_strings(void)
 208 {
 209    free(unrecognized_extensions);
 210 }
 211
 212
 213 /**
 214  * \brief Initialize extension override tables based on \c MESA_EXTENSION_OVERRIDE
 215  *
 216  * This should be called one time early during first context initialization.
 217
 218  * \c MESA_EXTENSION_OVERRIDE is a space-separated list of extensions to
 219  * enable or disable. The list is processed thus:
 220  *    - Enable recognized extension names that are prefixed with '+'.
 221  *    - Disable recognized extension names that are prefixed with '-'.
 222  *    - Enable recognized extension names that are not prefixed.
 223  *    - Collect unrecognized extension names in a new string.
 224  */
 225 void
 226 _mesa_one_time_init_extension_overrides(struct gl_context *ctx)
 227 {
 228    const char *env_const = getenv("MESA_EXTENSION_OVERRIDE");
 229    char *env;
 230    char *ext;
 231    size_t offset;
 232    unsigned unknown_ext = 0;
 233
 234    memset(&_mesa_extension_override_enables, 0, sizeof(struct gl_extensions));
 235    memset(&_mesa_extension_override_disables, 0, sizeof(struct gl_extensions));
 236
 237    if (env_const == NULL) {
 238       return;
 239    }
 240
 241    /* Copy env_const because strtok() is destructive. */
 242    env = strdup(env_const);
 243
 244    if (env == NULL)
 245       return;
 246
 247    for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {
 248       int enable;
 249       int i;
 250       bool recognized;
 251       switch (ext[0]) {
 252       case '+':
 253          enable = 1;
 254          ++ext;
 255          break;
 256       case '-':
 257          enable = 0;
 258          ++ext;
 259          break;
 260       default:
 261          enable = 1;
 262          break;
 263       }
 264
 265       i = name_to_index(ext);
 266       offset = set_extension(&_mesa_extension_override_enables, i, enable);
 267       offset = set_extension(&_mesa_extension_override_disables, i, !enable);
 268       if (offset != 0)
 269          recognized = true;
 270       else
 271          recognized = false;
 272
 273       if (!recognized && enable) {
 274          if (unknown_ext >= MAX_UNRECOGNIZED_EXTENSIONS) {
 275             static bool warned;
 276
 277             if (!warned) {
 278                warned = true;
 279                _mesa_problem(ctx, "Trying to enable too many unknown extension. "
 280                                   "Only the first %d will be honoured",
 281                                   MAX_UNRECOGNIZED_EXTENSIONS);
 282             }
 283          } else {
 284             ctx->Extensions.unrecognized_extensions[unknown_ext] = ext;
 285             unknown_ext++;
 286
 287             _mesa_problem(ctx, "Trying to enable unknown extension: %s", ext);
 288          }
 289       }
 290    }
 291
 292    if (!unknown_ext) {
 293       free(env);
 294    } else {
 295       unrecognized_extensions = env;
 296       atexit(free_unknown_extensions_strings);
 297    }
 298 }
 299
 300
 301 /**
 302  * \brief Initialize extension tables and enable default extensions.
 303  *
 304  * This should be called during context initialization.
 305  * Note: Sets gl_extensions.dummy_true to true.
 306  */
 307 void
 308 _mesa_init_extensions(struct gl_extensions *extensions)
 309 {
 310    GLboolean *base = (GLboolean *) extensions;
 311    GLboolean *sentinel = base + o(extension_sentinel);
 312    GLboolean *i;
 313
 314    /* First, turn all extensions off. */
 315    for (i = base; i != sentinel; ++i)
 316       *i = GL_FALSE;
 317
 318    /* Then, selectively turn default extensions on. */
 319    extensions->dummy_true = GL_TRUE;
 320 }
 321
 322
 323 typedef unsigned short extension_index;
 324
 325
 326 /**
 327  * Given an extension enum, return whether or not the extension is supported
 328  * dependent on the following factors:
 329  * There's driver support and the OpenGL/ES version is at least that
 330  * specified in the _mesa_extension_table.
 331  */
 332 static inline bool
 333 _mesa_extension_supported(const struct gl_context *ctx, extension_index i)
 334 {
 335    const bool *base = (bool *) &ctx->Extensions;
 336    const struct mesa_extension *ext = _mesa_extension_table + i;
 337
 338    return (ctx->Version >= ext->version[ctx->API]) && base[ext->offset];
 339 }
 340
 341
 342 /**
 343  * Construct the GL_EXTENSIONS string.  Called the first time that
 344  * glGetString(GL_EXTENSIONS) is called.
 345  */
 346 GLubyte*
 347 _mesa_make_extension_string(struct gl_context *ctx)
 348 {
 349    /* The extension string. */
 350    char *exts = 0;
 351    /* Length of extension string. */
 352    size_t length = 0;
 353    /* Number of extensions */
 354    unsigned count;
 355    /* Indices of the extensions sorted by year */
 356    extension_index extension_indices[MESA_EXTENSION_COUNT];
 357    unsigned k;
 358    unsigned j;
 359    unsigned maxYear = ~0;
 360
 361    /* Check if the MESA_EXTENSION_MAX_YEAR env var is set */
 362    {
 363       const char *env = getenv("MESA_EXTENSION_MAX_YEAR");
 364       if (env) {
 365          maxYear = atoi(env);
 366          _mesa_debug(ctx, "Note: limiting GL extensions to %u or earlier\n",
 367                      maxYear);
 368       }
 369    }
 370
 371    /* Compute length of the extension string. */
 372    count = 0;
 373    for (k = 0; k < MESA_EXTENSION_COUNT; ++k) {
 374       const struct mesa_extension *i = _mesa_extension_table + k;
 375
 376       if (i->year <= maxYear &&
 377           _mesa_extension_supported(ctx, k)) {
 378          length += strlen(i->name) + 1; /* +1 for space */
 379          extension_indices[count++] = k;
 380       }
 381    }
 382    for (k = 0; k < MAX_UNRECOGNIZED_EXTENSIONS; k++)
 383       if (ctx->Extensions.unrecognized_extensions[k])
 384          length += 1 + strlen(ctx->Extensions.unrecognized_extensions[k]); /* +1 for space */
 385
 386    exts = calloc(ALIGN(length + 1, 4), sizeof(char));
 387    if (exts == NULL) {
 388       return NULL;
 389    }
 390
 391    /* Build the extension string.*/
 392    for (j = 0; j < count; ++j) {
 393       const struct mesa_extension *i = &_mesa_extension_table[extension_indices[j]];
 394       assert(_mesa_extension_supported(ctx, extension_indices[j]));
 395       strcat(exts, i->name);
 396       strcat(exts, " ");
 397    }
 398    for (j = 0; j < MAX_UNRECOGNIZED_EXTENSIONS; j++) {
 399       if (ctx->Extensions.unrecognized_extensions[j]) {
 400          strcat(exts, ctx->Extensions.unrecognized_extensions[j]);
 401          strcat(exts, " ");
 402       }
 403    }
 404
 405    return (GLubyte *) exts;
 406 }
 407
 408 /**
 409  * Return number of enabled extensions.
 410  */
 411 GLuint
 412 _mesa_get_extension_count(struct gl_context *ctx)
 413 {
 414    unsigned k;
 415
 416    /* only count once */
 417    if (ctx->Extensions.Count != 0)
 418       return ctx->Extensions.Count;
 419
 420    for (k = 0; k < MESA_EXTENSION_COUNT; ++k) {
 421       if (_mesa_extension_supported(ctx, k))
 422          ctx->Extensions.Count++;
 423    }
 424
 425    for (k = 0; k < MAX_UNRECOGNIZED_EXTENSIONS; ++k) {
 426       if (ctx->Extensions.unrecognized_extensions[k])
 427          ctx->Extensions.Count++;
 428    }
 429    return ctx->Extensions.Count;
 430 }
 431
 432 /**
 433  * Return name of i-th enabled extension
 434  */
 435 const GLubyte *
 436 _mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
 437 {
 438    size_t n = 0;
 439    unsigned i;
 440
 441    for (i = 0; i < MESA_EXTENSION_COUNT; ++i) {
 442       if (_mesa_extension_supported(ctx, i)) {
 443          if (n == index)
 444             return (const GLubyte*) _mesa_extension_table[i].name;
 445          else
 446             ++n;
 447       }
 448    }
 449
 450    for (i = 0; i < MAX_UNRECOGNIZED_EXTENSIONS; ++i) {
 451       if (ctx->Extensions.unrecognized_extensions[i]) {
 452          if (n == index)
 453             return (const GLubyte*) ctx->Extensions.unrecognized_extensions[i];
 454          else
 455             ++n;
 456       }
 457    }
 458    return NULL;
 459 }