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
  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 /**
  53  * \brief Table of supported OpenGL extensions for all API's.
  54  */
  55 const struct mesa_extension _mesa_extension_table[] = {
  56 #define EXT(name_str, driver_cap, gll_ver, glc_ver, gles_ver, gles2_ver, yyyy) \
  57         { .name = "GL_" #name_str, .offset = o(driver_cap), \
  58           .version = { \
  59             [API_OPENGL_COMPAT] = gll_ver, \
  60             [API_OPENGL_CORE]   = glc_ver, \
  61             [API_OPENGLES]      = gles_ver, \
  62             [API_OPENGLES2]     = gles2_ver, \
  63            }, \
  64            .year = yyyy \
  65         },
  66 #include "extensions_table.h"
  67 #undef EXT
  68 };
  69
  70 static bool disabled_extensions[ARRAY_SIZE(_mesa_extension_table)];
  71
  72 /**
  73  * Given an extension name, lookup up the corresponding member of struct
  74  * gl_extensions and return that member's index.  If the name is
  75  * not found in the \c _mesa_extension_table, return -1.
  76  *
  77  * \param name Name of extension.
  78  * \return Index of member in struct gl_extensions.
  79  */
  80 static int
  81 name_to_index(const char* name)
  82 {
  83    unsigned i;
  84
  85    if (name == 0)
  86       return -1;
  87
  88    for (i = 0; i < ARRAY_SIZE(_mesa_extension_table); ++i) {
  89       if (strcmp(name, _mesa_extension_table[i].name) == 0)
  90          return i;
  91    }
  92
  93    return -1;
  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, int i, GLboolean state)
 210 {
 211    size_t offset;
 212
 213    offset = i < 0 ? 0 : _mesa_extension_table[i].offset;
 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 (extra_extensions == NULL) {
 244       return calloc(1, sizeof(char));
 245    } else {
 246       _mesa_problem(ctx, "Trying to enable unknown extensions: %s",
 247                     extra_extensions);
 248       return strdup(extra_extensions);
 249    }
 250 }
 251
 252
 253 /**
 254  * \brief Free extra_extensions string
 255  *
 256  * These strings are allocated early during the first context creation by
 257  * _mesa_one_time_init_extension_overrides.
 258  */
 259 static void
 260 free_unknown_extensions_strings(void)
 261 {
 262    free(extra_extensions);
 263 }
 264
 265
 266 /**
 267  * \brief Initialize extension override tables.
 268  *
 269  * This should be called one time early during first context initialization.
 270  */
 271 void
 272 _mesa_one_time_init_extension_overrides(void)
 273 {
 274    const char *env_const = getenv("MESA_EXTENSION_OVERRIDE");
 275    char *env;
 276    char *ext;
 277    int len;
 278    size_t offset;
 279
 280    atexit(free_unknown_extensions_strings);
 281
 282    memset(&_mesa_extension_override_enables, 0, sizeof(struct gl_extensions));
 283    memset(&_mesa_extension_override_disables, 0, sizeof(struct gl_extensions));
 284
 285    if (env_const == NULL) {
 286       return;
 287    }
 288
 289    /* extra_exts: List of unrecognized extensions. */
 290    extra_extensions = calloc(ALIGN(strlen(env_const) + 2, 4), sizeof(char));
 291
 292    /* Copy env_const because strtok() is destructive. */
 293    env = strdup(env_const);
 294
 295    if (env == NULL ||
 296        extra_extensions == NULL) {
 297       free(env);
 298       free(extra_extensions);
 299       return;
 300    }
 301
 302    for (ext = strtok(env, " "); ext != NULL; ext = strtok(NULL, " ")) {
 303       int enable;
 304       int i;
 305       bool recognized;
 306       switch (ext[0]) {
 307       case '+':
 308          enable = 1;
 309          ++ext;
 310          break;
 311       case '-':
 312          enable = 0;
 313          ++ext;
 314          break;
 315       default:
 316          enable = 1;
 317          break;
 318       }
 319
 320       i = name_to_index(ext);
 321       offset = set_extension(&_mesa_extension_override_enables, i, enable);
 322       if (offset != 0 && (offset != o(dummy_true) || enable != GL_FALSE)) {
 323          ((GLboolean *) &_mesa_extension_override_disables)[offset] = !enable;
 324          recognized = true;
 325       } else {
 326          recognized = false;
 327       }
 328
 329       if (i >= 0)
 330          disabled_extensions[i] = !enable;
 331
 332       if (!recognized && enable) {
 333          strcat(extra_extensions, ext);
 334          strcat(extra_extensions, " ");
 335       }
 336    }
 337
 338    free(env);
 339
 340    /* Remove trailing space, and free if unused. */
 341    len = strlen(extra_extensions);
 342    if (len == 0) {
 343       free(extra_extensions);
 344       extra_extensions = NULL;
 345    } else if (extra_extensions[len - 1] == ' ') {
 346       extra_extensions[len - 1] = '\0';
 347    }
 348 }
 349
 350
 351 /**
 352  * \brief Initialize extension tables and enable default extensions.
 353  *
 354  * This should be called during context initialization.
 355  * Note: Sets gl_extensions.dummy_true to true.
 356  */
 357 void
 358 _mesa_init_extensions(struct gl_extensions *extensions)
 359 {
 360    GLboolean *base = (GLboolean *) extensions;
 361    GLboolean *sentinel = base + o(extension_sentinel);
 362    GLboolean *i;
 363
 364    /* First, turn all extensions off. */
 365    for (i = base; i != sentinel; ++i)
 366       *i = GL_FALSE;
 367
 368    /* Then, selectively turn default extensions on. */
 369    extensions->dummy_true = GL_TRUE;
 370 }
 371
 372
 373 typedef unsigned short extension_index;
 374
 375
 376 /**
 377  * Given an extension enum, return whether or not the extension is supported
 378  * dependent on the following factors:
 379  * There's driver support and the OpenGL/ES version is at least that
 380  * specified in the _mesa_extension_table.
 381  */
 382 static inline bool
 383 _mesa_extension_supported(const struct gl_context *ctx, extension_index i)
 384 {
 385    const bool *base = (bool *) &ctx->Extensions;
 386    const struct mesa_extension *ext = _mesa_extension_table + i;
 387
 388    return !disabled_extensions[i] &&
 389           (ctx->Version >= ext->version[ctx->API]) && base[ext->offset];
 390 }
 391
 392 /**
 393  * Compare two entries of the extensions table.  Sorts first by year,
 394  * then by name.
 395  *
 396  * Arguments are indices into _mesa_extension_table.
 397  */
 398 static int
 399 extension_compare(const void *p1, const void *p2)
 400 {
 401    extension_index i1 = * (const extension_index *) p1;
 402    extension_index i2 = * (const extension_index *) p2;
 403    const struct mesa_extension *e1 = &_mesa_extension_table[i1];
 404    const struct mesa_extension *e2 = &_mesa_extension_table[i2];
 405    int res;
 406
 407    res = (int)e1->year - (int)e2->year;
 408
 409    if (res == 0) {
 410       res = strcmp(e1->name, e2->name);
 411    }
 412
 413    return res;
 414 }
 415
 416
 417 /**
 418  * Construct the GL_EXTENSIONS string.  Called the first time that
 419  * glGetString(GL_EXTENSIONS) is called.
 420  */
 421 GLubyte*
 422 _mesa_make_extension_string(struct gl_context *ctx)
 423 {
 424    /* The extension string. */
 425    char *exts = 0;
 426    /* Length of extension string. */
 427    size_t length = 0;
 428    /* Number of extensions */
 429    unsigned count;
 430    /* Indices of the extensions sorted by year */
 431    extension_index *extension_indices;
 432    /* String of extra extensions. */
 433    char *extra_extensions = get_extension_override(ctx);
 434    unsigned k;
 435    unsigned j;
 436    unsigned maxYear = ~0;
 437
 438    /* Check if the MESA_EXTENSION_MAX_YEAR env var is set */
 439    {
 440       const char *env = getenv("MESA_EXTENSION_MAX_YEAR");
 441       if (env) {
 442          maxYear = atoi(env);
 443          _mesa_debug(ctx, "Note: limiting GL extensions to %u or earlier\n",
 444                      maxYear);
 445       }
 446    }
 447
 448    /* Compute length of the extension string. */
 449    count = 0;
 450    for (k = 0; k < ARRAY_SIZE(_mesa_extension_table); ++k) {
 451       const struct mesa_extension *i = _mesa_extension_table + k;
 452
 453       if (i->year <= maxYear &&
 454           _mesa_extension_supported(ctx, k)) {
 455          length += strlen(i->name) + 1; /* +1 for space */
 456          ++count;
 457       }
 458    }
 459    if (extra_extensions != NULL)
 460       length += 1 + strlen(extra_extensions); /* +1 for space */
 461
 462    exts = calloc(ALIGN(length + 1, 4), sizeof(char));
 463    if (exts == NULL) {
 464       free(extra_extensions);
 465       return NULL;
 466    }
 467
 468    extension_indices = malloc(count * sizeof(extension_index));
 469    if (extension_indices == NULL) {
 470       free(exts);
 471       free(extra_extensions);
 472       return NULL;
 473    }
 474
 475    /* Sort extensions in chronological order because certain old applications
 476     * (e.g., Quake3 demo) store the extension list in a static size buffer so
 477     * chronologically order ensure that the extensions that such applications
 478     * expect will fit into that buffer.
 479     */
 480    j = 0;
 481    for (k = 0; k < ARRAY_SIZE(_mesa_extension_table); ++k) {
 482       if (_mesa_extension_table[k].year <= maxYear &&
 483          _mesa_extension_supported(ctx, k)) {
 484          extension_indices[j++] = k;
 485       }
 486    }
 487    assert(j == count);
 488    qsort(extension_indices, count,
 489          sizeof *extension_indices, extension_compare);
 490
 491    /* Build the extension string.*/
 492    for (j = 0; j < count; ++j) {
 493       const struct mesa_extension *i = &_mesa_extension_table[extension_indices[j]];
 494       assert(_mesa_extension_supported(ctx, extension_indices[j]));
 495       strcat(exts, i->name);
 496       strcat(exts, " ");
 497    }
 498    free(extension_indices);
 499    if (extra_extensions != 0) {
 500       strcat(exts, extra_extensions);
 501       free(extra_extensions);
 502    }
 503
 504    return (GLubyte *) exts;
 505 }
 506
 507 /**
 508  * Return number of enabled extensions.
 509  */
 510 GLuint
 511 _mesa_get_extension_count(struct gl_context *ctx)
 512 {
 513    unsigned k;
 514
 515    /* only count once */
 516    if (ctx->Extensions.Count != 0)
 517       return ctx->Extensions.Count;
 518
 519    for (k = 0; k < ARRAY_SIZE(_mesa_extension_table); ++k) {
 520       if (_mesa_extension_supported(ctx, k))
 521          ctx->Extensions.Count++;
 522    }
 523    return ctx->Extensions.Count;
 524 }
 525
 526 /**
 527  * Return name of i-th enabled extension
 528  */
 529 const GLubyte *
 530 _mesa_get_enabled_extension(struct gl_context *ctx, GLuint index)
 531 {
 532    size_t n = 0;
 533    unsigned i;
 534
 535    for (i = 0; i < ARRAY_SIZE(_mesa_extension_table); ++i) {
 536       if (_mesa_extension_supported(ctx, i)) {
 537          if (n == index)
 538             return (const GLubyte*) _mesa_extension_table[i].name;
 539          else
 540             ++n;
 541       }
 542    }
 543
 544    return NULL;
 545 }