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 *extra_extensions = NULL;
  43 static char *cant_disable_extensions = NULL;
  44
  45
  46 /**
  47  * Given a member \c x of struct gl_extensions, return offset of
  48  * \c x in bytes.
  49  */
  50 #define o(x) offsetof(struct gl_extensions, x)
  51
  52
  53 /**
  54  * \brief Table of supported OpenGL extensions for all API's.
  55  */
  56 const struct mesa_extension _mesa_extension_table[] = {
  57 #define EXT(name_str, driver_cap, gll_ver, glc_ver, gles_ver, gles2_ver, yyyy) \
  58         { .name = "GL_" #name_str, .offset = o(driver_cap), \
  59           .version = { \
  60             [API_OPENGL_COMPAT] = gll_ver, \
  61             [API_OPENGL_CORE]   = glc_ver, \
  62             [API_OPENGLES]      = gles_ver, \
  63             [API_OPENGLES2]     = gles2_ver, \
  64            }, \
  65            .year = yyyy \
  66         },
  67 #include "extensions_table.h"
  68 #undef EXT
  69 };
  70
  71
  72 /**
  73  * Given an extension name, lookup up the corresponding member of struct
  74  * gl_extensions and return that member's offset (in bytes).  If the name is
  75  * not found in the \c _mesa_extension_table, return 0.
  76  *
  77  * \param name Name of extension.
  78  * \return Offset of member in struct gl_extensions.
  79  */
  80 static size_t
  81 name_to_offset(const char* name)
  82 {
  83    unsigned i;
  84
  85    if (name == 0)
  86       return 0;
  87
  88    for (i = 0; i < ARRAY_SIZE(_mesa_extension_table); ++i) {
  89       if (strcmp(name, _mesa_extension_table[i].name) == 0)
  90          return _mesa_extension_table[i].offset;
  91    }
  92
  93    return 0;
  94 }
  95
  96 /**
  97  * Overrides extensions in \c ctx based on the values in
  98  * _mesa_extension_override_enables and _mesa_extension_override_disables.
  99  */
 100 static void
 101 override_extensions_in_context(struct gl_context *ctx)
 102 {
 103    unsigned i;
 104    const GLboolean *enables =
 105       (GLboolean*) &_mesa_extension_override_enables;
 106    const GLboolean *disables =
 107       (GLboolean*) &_mesa_extension_override_disables;
 108    GLboolean *ctx_ext = (GLboolean*)&ctx->Extensions;
 109
 110    for (i = 0; i < ARRAY_SIZE(_mesa_extension_table); ++i) {
 111       size_t offset = _mesa_extension_table[i].offset;
 112
 113       assert(!enables[offset] || !disables[offset]);
 114       if (enables[offset]) {
 115          ctx_ext[offset] = 1;
 116       } else if (disables[offset]) {
 117          ctx_ext[offset] = 0;
 118       }
 119    }
 120 }
 121
 122
 123 /**
 124  * Enable all extensions suitable for a software-only renderer.
 125  * This is a convenience function used by the XMesa, OSMesa, GGI drivers, etc.
 126  */
 127 void
 128 _mesa_enable_sw_extensions(struct gl_context *ctx)
 129 {
 130    ctx->Extensions.ARB_depth_clamp = GL_TRUE;
 131    ctx->Extensions.ARB_depth_texture = GL_TRUE;
 132    ctx->Extensions.ARB_draw_elements_base_vertex = GL_TRUE;
 133    ctx->Extensions.ARB_draw_instanced = GL_TRUE;
 134    ctx->Extensions.ARB_explicit_attrib_location = GL_TRUE;
 135    ctx->Extensions.ARB_fragment_coord_conventions = GL_TRUE;
 136    ctx->Extensions.ARB_fragment_program = GL_TRUE;
 137    ctx->Extensions.ARB_fragment_program_shadow = GL_TRUE;
 138    ctx->Extensions.ARB_fragment_shader = GL_TRUE;
 139    ctx->Extensions.ARB_framebuffer_object = GL_TRUE;
 140    ctx->Extensions.ARB_half_float_vertex = GL_TRUE;
 141    ctx->Extensions.ARB_map_buffer_range = GL_TRUE;
 142    ctx->Extensions.ARB_occlusion_query = GL_TRUE;
 143    ctx->Extensions.ARB_occlusion_query2 = GL_TRUE;
 144    ctx->Extensions.ARB_point_sprite = GL_TRUE;
 145    ctx->Extensions.ARB_shadow = GL_TRUE;
 146    ctx->Extensions.ARB_texture_border_clamp = GL_TRUE;
 147    ctx->Extensions.ARB_texture_compression_bptc = GL_TRUE;
 148    ctx->Extensions.ARB_texture_cube_map = GL_TRUE;
 149    ctx->Extensions.ARB_texture_env_combine = GL_TRUE;
 150    ctx->Extensions.ARB_texture_env_crossbar = GL_TRUE;
 151    ctx->Extensions.ARB_texture_env_dot3 = GL_TRUE;
 152 #ifdef TEXTURE_FLOAT_ENABLED
 153    ctx->Extensions.ARB_texture_float = GL_TRUE;
 154 #endif
 155    ctx->Extensions.ARB_texture_mirror_clamp_to_edge = GL_TRUE;
 156    ctx->Extensions.ARB_texture_non_power_of_two = GL_TRUE;
 157    ctx->Extensions.ARB_texture_rg = GL_TRUE;
 158    ctx->Extensions.ARB_texture_compression_rgtc = GL_TRUE;
 159    ctx->Extensions.ARB_vertex_program = GL_TRUE;
 160    ctx->Extensions.ARB_vertex_shader = GL_TRUE;
 161    ctx->Extensions.ARB_sync = GL_TRUE;
 162    ctx->Extensions.APPLE_object_purgeable = GL_TRUE;
 163    ctx->Extensions.ATI_fragment_shader = GL_TRUE;
 164    ctx->Extensions.ATI_texture_compression_3dc = GL_TRUE;
 165    ctx->Extensions.ATI_texture_env_combine3 = GL_TRUE;
 166    ctx->Extensions.ATI_texture_mirror_once = GL_TRUE;
 167    ctx->Extensions.ATI_separate_stencil = GL_TRUE;
 168    ctx->Extensions.EXT_blend_color = GL_TRUE;
 169    ctx->Extensions.EXT_blend_equation_separate = GL_TRUE;
 170    ctx->Extensions.EXT_blend_func_separate = GL_TRUE;
 171    ctx->Extensions.EXT_blend_minmax = GL_TRUE;
 172    ctx->Extensions.EXT_depth_bounds_test = GL_TRUE;
 173    ctx->Extensions.EXT_draw_buffers2 = GL_TRUE;
 174    ctx->Extensions.EXT_pixel_buffer_object = GL_TRUE;
 175    ctx->Extensions.EXT_point_parameters = GL_TRUE;
 176    ctx->Extensions.EXT_provoking_vertex = GL_TRUE;
 177    ctx->Extensions.EXT_stencil_two_side = GL_TRUE;
 178    ctx->Extensions.EXT_texture_array = GL_TRUE;
 179    ctx->Extensions.EXT_texture_compression_latc = GL_TRUE;
 180    ctx->Extensions.EXT_texture_env_dot3 = GL_TRUE;
 181    ctx->Extensions.EXT_texture_filter_anisotropic = GL_TRUE;
 182    ctx->Extensions.EXT_texture_mirror_clamp = GL_TRUE;
 183    ctx->Extensions.EXT_texture_shared_exponent = GL_TRUE;
 184    ctx->Extensions.EXT_texture_sRGB = GL_TRUE;
 185    ctx->Extensions.EXT_texture_sRGB_decode = GL_TRUE;
 186    ctx->Extensions.EXT_texture_swizzle = GL_TRUE;
 187    /*ctx->Extensions.EXT_transform_feedback = GL_TRUE;*/
 188    ctx->Extensions.EXT_vertex_array_bgra = GL_TRUE;
 189    ctx->Extensions.MESA_pack_invert = GL_TRUE;
 190    ctx->Extensions.MESA_ycbcr_texture = GL_TRUE;
 191    ctx->Extensions.NV_conditional_render = GL_TRUE;
 192    ctx->Extensions.NV_point_sprite = GL_TRUE;
 193    ctx->Extensions.NV_texture_env_combine4 = GL_TRUE;
 194    ctx->Extensions.NV_texture_rectangle = GL_TRUE;
 195    ctx->Extensions.EXT_gpu_program_parameters = GL_TRUE;
 196    ctx->Extensions.OES_standard_derivatives = GL_TRUE;
 197    ctx->Extensions.TDFX_texture_compression_FXT1 = GL_TRUE;
 198    if (ctx->Mesa_DXTn) {
 199       ctx->Extensions.ANGLE_texture_compression_dxt = GL_TRUE;
 200       ctx->Extensions.EXT_texture_compression_s3tc = GL_TRUE;
 201    }
 202 }
 203
 204 /**
 205  * Either enable or disable the named extension.
 206  * \return offset of extensions withint `ext' or 0 if extension is not known
 207  */
 208 static size_t
 209 set_extension(struct gl_extensions *ext, const char *name, GLboolean state)
 210 {
 211    size_t offset;
 212
 213    offset = name_to_offset(name);
 214    if (offset != 0 && (offset != o(dummy_true) || state != GL_FALSE)) {
 215       ((GLboolean *) ext)[offset] = state;
 216    }
 217
 218    return offset;
 219 }
 220
 221 /**
 222  * \brief Apply the \c MESA_EXTENSION_OVERRIDE environment variable.
 223  *
 224  * \c MESA_EXTENSION_OVERRIDE is a space-separated list of extensions to
 225  * enable or disable. The list is processed thus:
 226  *    - Enable recognized extension names that are prefixed with '+'.
 227  *    - Disable recognized extension names that are prefixed with '-'.
 228  *    - Enable recognized extension names that are not prefixed.
 229  *    - Collect unrecognized extension names in a new string.
 230  *
 231  * \c MESA_EXTENSION_OVERRIDE was previously parsed during
 232  * _mesa_one_time_init_extension_overrides. We just use the results of that
 233  * parsing in this function.
 234  *
 235  * \return Space-separated list of unrecognized extension names (which must
 236  *    be freed). Does not return \c NULL.
 237  */
 238 static char *
 239 get_extension_override( struct gl_context *ctx )
 240 {
 241    override_extensions_in_context(ctx);
 242
 243    if (cant_disable_extensions != NULL) {
 244       _mesa_problem(ctx,
 245                     "Trying to disable permanently enabled extensions: %s",
 246                     cant_disable_extensions);
 247    }
 248
 249    if (extra_extensions == NULL) {
 250       return calloc(1, sizeof(char));
 251    } else {
 252       _mesa_problem(ctx, "Trying to enable unknown extensions: %s",
 253                     extra_extensions);
 254       return strdup(extra_extensions);
 255    }
 256 }
 257
 258
 259 /**
 260  * \brief Free extra_extensions and cant_disable_extensions strings
 261  *
 262  * These strings are allocated early during the first context creation by
 263  * _mesa_one_time_init_extension_overrides.
 264  */
 265 static void
 266 free_unknown_extensions_strings(void)
 267 {
 268    free(extra_extensions);
 269    free(cant_disable_extensions);
 270 }
 271
 272
 273 /**
 274  * \brief Initialize extension override tables.
 275  *
 276  * This should be called one time early during first context initialization.
 277  */
 278 void
 279 _mesa_one_time_init_extension_overrides(void)
 280 {
 281    const char *env_const = getenv("MESA_EXTENSION_OVERRIDE");
 282    char *env;
 283    char *ext;
 284    int len;
 285    size_t offset;
 286
 287    atexit(free_unknown_extensions_strings);
 288
 289    memset(&_mesa_extension_override_enables, 0, sizeof(struct gl_extensions));
 290    memset(&_mesa_extension_override_disables, 0, sizeof(struct gl_extensions));
 291
 292    if (env_const == NULL) {
 293       return;
 294    }
 295
 296    /* extra_exts: List of unrecognized extensions. */
 297    extra_extensions = calloc(ALIGN(strlen(env_const) + 2, 4), sizeof(char));
 298    cant_disable_extensions = calloc(ALIGN(strlen(env_const) + 2, 4), sizeof(char));
 299
 300    /* Copy env_const because strtok() is destructive. */
 301    env = strdup(env_const);
 302
 303    if (env == NULL ||
 304        extra_extensions == NULL ||
 305        cant_disable_extensions == NULL) {
 306       free(env);
 307       free(extra_extensions);
 308       free(cant_disable_extensions);
 309       return;
 310    }
 311
 312    for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {
 313       int enable;
 314       bool recognized;
 315       switch (ext[0]) {
 316       case '+':
 317          enable = 1;
 318          ++ext;
 319          break;
 320       case '-':
 321          enable = 0;
 322          ++ext;
 323          break;
 324       default:
 325          enable = 1;
 326          break;
 327       }
 328
 329       offset = set_extension(&_mesa_extension_override_enables, ext, enable);
 330       if (offset != 0 && (offset != o(dummy_true) || enable != GL_FALSE)) {
 331          ((GLboolean *) &_mesa_extension_override_disables)[offset] = !enable;
 332          recognized = true;
 333       } else {
 334          recognized = false;
 335       }
 336
 337       if (!recognized) {
 338          if (enable) {
 339             strcat(extra_extensions, ext);
 340             strcat(extra_extensions, " ");
 341          } else if (offset == o(dummy_true)) {
 342             strcat(cant_disable_extensions, ext);
 343             strcat(cant_disable_extensions, " ");
 344          }
 345       }
 346    }
 347
 348    free(env);
 349
 350    /* Remove trailing space, and free if unused. */
 351    len = strlen(extra_extensions);
 352    if (len == 0) {
 353       free(extra_extensions);
 354       extra_extensions = NULL;
 355    } else if (extra_extensions[len - 1] == ' ') {
 356       extra_extensions[len - 1] = '\0';
 357    }
 358    len = strlen(cant_disable_extensions);
 359    if (len == 0) {
 360       free(cant_disable_extensions);
 361       cant_disable_extensions = NULL;
 362    } else if (cant_disable_extensions[len - 1] == ' ') {
 363       cant_disable_extensions[len - 1] = '\0';
 364    }
 365 }
 366
 367
 368 /**
 369  * \brief Initialize extension tables and enable default extensions.
 370  *
 371  * This should be called during context initialization.
 372  * Note: Sets gl_extensions.dummy_true to true.
 373  */
 374 void
 375 _mesa_init_extensions(struct gl_extensions *extensions)
 376 {
 377    GLboolean *base = (GLboolean *) extensions;
 378    GLboolean *sentinel = base + o(extension_sentinel);
 379    GLboolean *i;
 380
 381    /* First, turn all extensions off. */
 382    for (i = base; i != sentinel; ++i)
 383       *i = GL_FALSE;
 384
 385    /* Then, selectively turn default extensions on. */
 386    extensions->dummy_true = GL_TRUE;
 387 }
 388
 389
 390 typedef unsigned short extension_index;
 391
 392
 393 /**
 394  * Given an extension enum, return whether or not the extension is supported
 395  * dependent on the following factors:
 396  * There's driver support and the OpenGL/ES version is at least that
 397  * specified in the _mesa_extension_table.
 398  */
 399 static inline bool
 400 _mesa_extension_supported(const struct gl_context *ctx, extension_index i)
 401 {
 402    const bool *base = (bool *) &ctx->Extensions;
 403    const struct mesa_extension *ext = _mesa_extension_table + i;
 404
 405    return (ctx->Version >= ext->version[ctx->API]) && base[ext->offset];
 406 }
 407
 408 /**
 409  * Compare two entries of the extensions table.  Sorts first by year,
 410  * then by name.
 411  *
 412  * Arguments are indices into _mesa_extension_table.
 413  */
 414 static int
 415 extension_compare(const void *p1, const void *p2)
 416 {
 417    extension_index i1 = * (const extension_index *) p1;
 418    extension_index i2 = * (const extension_index *) p2;
 419    const struct mesa_extension *e1 = &_mesa_extension_table[i1];
 420    const struct mesa_extension *e2 = &_mesa_extension_table[i2];
 421    int res;
 422
 423    res = (int)e1->year - (int)e2->year;
 424
 425    if (res == 0) {
 426       res = strcmp(e1->name, e2->name);
 427    }
 428
 429    return res;
 430 }
 431
 432
 433 /**
 434  * Construct the GL_EXTENSIONS string.  Called the first time that
 435  * glGetString(GL_EXTENSIONS) is called.
 436  */
 437 GLubyte*
 438 _mesa_make_extension_string(struct gl_context *ctx)
 439 {
 440    /* The extension string. */
 441    char *exts = 0;
 442    /* Length of extension string. */
 443    size_t length = 0;
 444    /* Number of extensions */
 445    unsigned count;
 446    /* Indices of the extensions sorted by year */
 447    extension_index *extension_indices;
 448    /* String of extra extensions. */
 449    char *extra_extensions = get_extension_override(ctx);
 450    unsigned k;
 451    unsigned j;
 452    unsigned maxYear = ~0;
 453
 454    /* Check if the MESA_EXTENSION_MAX_YEAR env var is set */
 455    {
 456       const char *env = getenv("MESA_EXTENSION_MAX_YEAR");
 457       if (env) {
 458          maxYear = atoi(env);
 459          _mesa_debug(ctx, "Note: limiting GL extensions to %u or earlier\n",
 460                      maxYear);
 461       }
 462    }
 463
 464    /* Compute length of the extension string. */
 465    count = 0;
 466    for (k = 0; k < ARRAY_SIZE(_mesa_extension_table); ++k) {
 467       const struct mesa_extension *i = _mesa_extension_table + k;
 468
 469       if (i->year <= maxYear &&
 470           _mesa_extension_supported(ctx, k)) {
 471          length += strlen(i->name) + 1; /* +1 for space */
 472          ++count;
 473       }
 474    }
 475    if (extra_extensions != NULL)
 476       length += 1 + strlen(extra_extensions); /* +1 for space */
 477
 478    exts = calloc(ALIGN(length + 1, 4), sizeof(char));
 479    if (exts == NULL) {
 480       free(extra_extensions);
 481       return NULL;
 482    }
 483
 484    extension_indices = malloc(count * sizeof(extension_index));
 485    if (extension_indices == NULL) {
 486       free(exts);
 487       free(extra_extensions);
 488       return NULL;
 489    }
 490
 491    /* Sort extensions in chronological order because certain old applications
 492     * (e.g., Quake3 demo) store the extension list in a static size buffer so
 493     * chronologically order ensure that the extensions that such applications
 494     * expect will fit into that buffer.
 495     */
 496    j = 0;
 497    for (k = 0; k < ARRAY_SIZE(_mesa_extension_table); ++k) {
 498       if (_mesa_extension_table[k].year <= maxYear &&
 499          _mesa_extension_supported(ctx, k)) {
 500          extension_indices[j++] = k;
 501       }
 502    }
 503    assert(j == count);
 504    qsort(extension_indices, count,
 505          sizeof *extension_indices, extension_compare);
 506
 507    /* Build the extension string.*/
 508    for (j = 0; j < count; ++j) {
 509       const struct mesa_extension *i = &_mesa_extension_table[extension_indices[j]];
 510       assert(_mesa_extension_supported(ctx, extension_indices[j]));
 511       strcat(exts, i->name);
 512       strcat(exts, " ");
 513    }
 514    free(extension_indices);
 515    if (extra_extensions != 0) {
 516       strcat(exts, extra_extensions);
 517       free(extra_extensions);
 518    }
 519
 520    return (GLubyte *) exts;
 521 }
 522
 523 /**
 524  * Return number of enabled extensions.
 525  */
 526 GLuint
 527 _mesa_get_extension_count(struct gl_context *ctx)
 528 {
 529    unsigned k;
 530
 531    /* only count once */
 532    if (ctx->Extensions.Count != 0)
 533       return ctx->Extensions.Count;
 534
 535    for (k = 0; k < ARRAY_SIZE(_mesa_extension_table); ++k) {
 536       if (_mesa_extension_supported(ctx, k))
 537          ctx->Extensions.Count++;
 538    }
 539    return ctx->Extensions.Count;
 540 }
 541
 542 /**
 543  * Return name of i-th enabled extension
 544  */
 545 const GLubyte *
 546 _mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
 547 {
 548    size_t n = 0;
 549    unsigned i;
 550
 551    for (i = 0; i < ARRAY_SIZE(_mesa_extension_table); ++i) {
 552       if (_mesa_extension_supported(ctx, i)) {
 553          if (n == index)
 554             return (const GLubyte*) _mesa_extension_table[i].name;
 555          else
 556             ++n;
 557       }
 558    }
 559
 560    return NULL;
 561 }