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