get.c revision 848b8605
1/* 2 * Copyright (C) 2010 Brian Paul All Rights Reserved. 3 * Copyright (C) 2010 Intel Corporation 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included 13 * in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR 19 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 20 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 21 * OTHER DEALINGS IN THE SOFTWARE. 22 * 23 * Author: Kristian Høgsberg <krh@bitplanet.net> 24 */ 25 26#include "glheader.h" 27#include "context.h" 28#include "blend.h" 29#include "enable.h" 30#include "enums.h" 31#include "errors.h" 32#include "extensions.h" 33#include "get.h" 34#include "macros.h" 35#include "mtypes.h" 36#include "state.h" 37#include "texcompress.h" 38#include "framebuffer.h" 39#include "samplerobj.h" 40#include "stencil.h" 41 42/* This is a table driven implemetation of the glGet*v() functions. 43 * The basic idea is that most getters just look up an int somewhere 44 * in struct gl_context and then convert it to a bool or float according to 45 * which of glGetIntegerv() glGetBooleanv() etc is being called. 46 * Instead of generating code to do this, we can just record the enum 47 * value and the offset into struct gl_context in an array of structs. Then 48 * in glGet*(), we lookup the struct for the enum in question, and use 49 * the offset to get the int we need. 50 * 51 * Sometimes we need to look up a float, a boolean, a bit in a 52 * bitfield, a matrix or other types instead, so we need to track the 53 * type of the value in struct gl_context. And sometimes the value isn't in 54 * struct gl_context but in the drawbuffer, the array object, current texture 55 * unit, or maybe it's a computed value. So we need to also track 56 * where or how to find the value. Finally, we sometimes need to 57 * check that one of a number of extensions are enabled, the GL 58 * version or flush or call _mesa_update_state(). This is done by 59 * attaching optional extra information to the value description 60 * struct, it's sort of like an array of opcodes that describe extra 61 * checks or actions. 62 * 63 * Putting all this together we end up with struct value_desc below, 64 * and with a couple of macros to help, the table of struct value_desc 65 * is about as concise as the specification in the old python script. 66 */ 67 68#define FLOAT_TO_BOOLEAN(X) ( (X) ? GL_TRUE : GL_FALSE ) 69#define FLOAT_TO_FIXED(F) ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \ 70 ((F) * 65536.0f < INT_MIN) ? INT_MIN : \ 71 (GLint) ((F) * 65536.0f) ) 72 73#define INT_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE ) 74#define INT_TO_FIXED(I) ( ((I) > SHRT_MAX) ? INT_MAX : \ 75 ((I) < SHRT_MIN) ? INT_MIN : \ 76 (GLint) ((I) * 65536) ) 77 78#define INT64_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE ) 79#define INT64_TO_INT(I) ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) ) 80 81#define BOOLEAN_TO_INT(B) ( (GLint) (B) ) 82#define BOOLEAN_TO_INT64(B) ( (GLint64) (B) ) 83#define BOOLEAN_TO_FLOAT(B) ( (B) ? 1.0F : 0.0F ) 84#define BOOLEAN_TO_FIXED(B) ( (GLint) ((B) ? 1 : 0) << 16 ) 85 86#define ENUM_TO_INT64(E) ( (GLint64) (E) ) 87#define ENUM_TO_FIXED(E) (E) 88 89enum value_type { 90 TYPE_INVALID, 91 TYPE_INT, 92 TYPE_INT_2, 93 TYPE_INT_3, 94 TYPE_INT_4, 95 TYPE_INT_N, 96 TYPE_INT64, 97 TYPE_ENUM, 98 TYPE_ENUM_2, 99 TYPE_BOOLEAN, 100 TYPE_BIT_0, 101 TYPE_BIT_1, 102 TYPE_BIT_2, 103 TYPE_BIT_3, 104 TYPE_BIT_4, 105 TYPE_BIT_5, 106 TYPE_BIT_6, 107 TYPE_BIT_7, 108 TYPE_FLOAT, 109 TYPE_FLOAT_2, 110 TYPE_FLOAT_3, 111 TYPE_FLOAT_4, 112 TYPE_FLOATN, 113 TYPE_FLOATN_2, 114 TYPE_FLOATN_3, 115 TYPE_FLOATN_4, 116 TYPE_DOUBLEN, 117 TYPE_DOUBLEN_2, 118 TYPE_MATRIX, 119 TYPE_MATRIX_T, 120 TYPE_CONST 121}; 122 123enum value_location { 124 LOC_BUFFER, 125 LOC_CONTEXT, 126 LOC_ARRAY, 127 LOC_TEXUNIT, 128 LOC_CUSTOM 129}; 130 131enum value_extra { 132 EXTRA_END = 0x8000, 133 EXTRA_VERSION_30, 134 EXTRA_VERSION_31, 135 EXTRA_VERSION_32, 136 EXTRA_VERSION_40, 137 EXTRA_API_GL, 138 EXTRA_API_GL_CORE, 139 EXTRA_API_ES2, 140 EXTRA_API_ES3, 141 EXTRA_NEW_BUFFERS, 142 EXTRA_NEW_FRAG_CLAMP, 143 EXTRA_VALID_DRAW_BUFFER, 144 EXTRA_VALID_TEXTURE_UNIT, 145 EXTRA_VALID_CLIP_DISTANCE, 146 EXTRA_FLUSH_CURRENT, 147 EXTRA_GLSL_130, 148 EXTRA_EXT_UBO_GS4, 149 EXTRA_EXT_ATOMICS_GS4, 150 EXTRA_EXT_SHADER_IMAGE_GS4, 151}; 152 153#define NO_EXTRA NULL 154#define NO_OFFSET 0 155 156struct value_desc { 157 GLenum pname; 158 GLubyte location; /**< enum value_location */ 159 GLubyte type; /**< enum value_type */ 160 int offset; 161 const int *extra; 162}; 163 164union value { 165 GLfloat value_float; 166 GLfloat value_float_4[4]; 167 GLdouble value_double_2[2]; 168 GLmatrix *value_matrix; 169 GLint value_int; 170 GLint value_int_4[4]; 171 GLint64 value_int64; 172 GLenum value_enum; 173 174 /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */ 175 struct { 176 GLint n, ints[100]; 177 } value_int_n; 178 GLboolean value_bool; 179}; 180 181#define BUFFER_FIELD(field, type) \ 182 LOC_BUFFER, type, offsetof(struct gl_framebuffer, field) 183#define CONTEXT_FIELD(field, type) \ 184 LOC_CONTEXT, type, offsetof(struct gl_context, field) 185#define ARRAY_FIELD(field, type) \ 186 LOC_ARRAY, type, offsetof(struct gl_vertex_array_object, field) 187#undef CONST /* already defined through windows.h */ 188#define CONST(value) \ 189 LOC_CONTEXT, TYPE_CONST, value 190 191#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT) 192#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM) 193#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN) 194 195#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT) 196#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2) 197#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64) 198#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM) 199#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2) 200#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN) 201#define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0) 202#define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1) 203#define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2) 204#define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3) 205#define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4) 206#define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5) 207#define CONTEXT_BIT6(field) CONTEXT_FIELD(field, TYPE_BIT_6) 208#define CONTEXT_BIT7(field) CONTEXT_FIELD(field, TYPE_BIT_7) 209#define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT) 210#define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2) 211#define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3) 212#define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4) 213#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX) 214#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T) 215 216#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT) 217#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM) 218#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN) 219 220#define EXT(f) \ 221 offsetof(struct gl_extensions, f) 222 223#define EXTRA_EXT(e) \ 224 static const int extra_##e[] = { \ 225 EXT(e), EXTRA_END \ 226 } 227 228#define EXTRA_EXT2(e1, e2) \ 229 static const int extra_##e1##_##e2[] = { \ 230 EXT(e1), EXT(e2), EXTRA_END \ 231 } 232 233/* The 'extra' mechanism is a way to specify extra checks (such as 234 * extensions or specific gl versions) or actions (flush current, new 235 * buffers) that we need to do before looking up an enum. We need to 236 * declare them all up front so we can refer to them in the value_desc 237 * structs below. 238 * 239 * Each EXTRA_ will be executed. For EXTRA_* enums of extensions and API 240 * versions, listing multiple ones in an array means an error will be thrown 241 * only if none of them are available. If you need to check for "AND" 242 * behavior, you would need to make a custom EXTRA_ enum. 243 */ 244 245static const int extra_new_buffers[] = { 246 EXTRA_NEW_BUFFERS, 247 EXTRA_END 248}; 249 250static const int extra_new_frag_clamp[] = { 251 EXTRA_NEW_FRAG_CLAMP, 252 EXTRA_END 253}; 254 255static const int extra_valid_draw_buffer[] = { 256 EXTRA_VALID_DRAW_BUFFER, 257 EXTRA_END 258}; 259 260static const int extra_valid_texture_unit[] = { 261 EXTRA_VALID_TEXTURE_UNIT, 262 EXTRA_END 263}; 264 265static const int extra_valid_clip_distance[] = { 266 EXTRA_VALID_CLIP_DISTANCE, 267 EXTRA_END 268}; 269 270static const int extra_flush_current_valid_texture_unit[] = { 271 EXTRA_FLUSH_CURRENT, 272 EXTRA_VALID_TEXTURE_UNIT, 273 EXTRA_END 274}; 275 276static const int extra_flush_current[] = { 277 EXTRA_FLUSH_CURRENT, 278 EXTRA_END 279}; 280 281static const int extra_EXT_texture_integer_and_new_buffers[] = { 282 EXT(EXT_texture_integer), 283 EXTRA_NEW_BUFFERS, 284 EXTRA_END 285}; 286 287static const int extra_GLSL_130_es3[] = { 288 EXTRA_GLSL_130, 289 EXTRA_API_ES3, 290 EXTRA_END 291}; 292 293static const int extra_texture_buffer_object[] = { 294 EXTRA_API_GL_CORE, 295 EXTRA_VERSION_31, 296 EXT(ARB_texture_buffer_object), 297 EXTRA_END 298}; 299 300static const int extra_ARB_transform_feedback2_api_es3[] = { 301 EXT(ARB_transform_feedback2), 302 EXTRA_API_ES3, 303 EXTRA_END 304}; 305 306static const int extra_ARB_uniform_buffer_object_and_geometry_shader[] = { 307 EXTRA_EXT_UBO_GS4, 308 EXTRA_END 309}; 310 311static const int extra_ARB_ES2_compatibility_api_es2[] = { 312 EXT(ARB_ES2_compatibility), 313 EXTRA_API_ES2, 314 EXTRA_END 315}; 316 317static const int extra_ARB_ES3_compatibility_api_es3[] = { 318 EXT(ARB_ES3_compatibility), 319 EXTRA_API_ES3, 320 EXTRA_END 321}; 322 323static const int extra_EXT_framebuffer_sRGB_and_new_buffers[] = { 324 EXT(EXT_framebuffer_sRGB), 325 EXTRA_NEW_BUFFERS, 326 EXTRA_END 327}; 328 329static const int extra_EXT_packed_float[] = { 330 EXT(EXT_packed_float), 331 EXTRA_NEW_BUFFERS, 332 EXTRA_END 333}; 334 335static const int extra_EXT_texture_array_es3[] = { 336 EXT(EXT_texture_array), 337 EXTRA_API_ES3, 338 EXTRA_END 339}; 340 341static const int extra_ARB_shader_atomic_counters_and_geometry_shader[] = { 342 EXTRA_EXT_ATOMICS_GS4, 343 EXTRA_END 344}; 345 346static const int extra_ARB_shader_image_load_store_and_geometry_shader[] = { 347 EXTRA_EXT_SHADER_IMAGE_GS4, 348 EXTRA_END 349}; 350 351EXTRA_EXT(ARB_texture_cube_map); 352EXTRA_EXT(EXT_texture_array); 353EXTRA_EXT(NV_fog_distance); 354EXTRA_EXT(EXT_texture_filter_anisotropic); 355EXTRA_EXT(NV_point_sprite); 356EXTRA_EXT(NV_texture_rectangle); 357EXTRA_EXT(EXT_stencil_two_side); 358EXTRA_EXT(EXT_depth_bounds_test); 359EXTRA_EXT(ARB_depth_clamp); 360EXTRA_EXT(ATI_fragment_shader); 361EXTRA_EXT(EXT_provoking_vertex); 362EXTRA_EXT(ARB_fragment_shader); 363EXTRA_EXT(ARB_fragment_program); 364EXTRA_EXT2(ARB_framebuffer_object, EXT_framebuffer_multisample); 365EXTRA_EXT(ARB_seamless_cube_map); 366EXTRA_EXT(ARB_sync); 367EXTRA_EXT(ARB_vertex_shader); 368EXTRA_EXT(EXT_transform_feedback); 369EXTRA_EXT(ARB_transform_feedback3); 370EXTRA_EXT(EXT_pixel_buffer_object); 371EXTRA_EXT(ARB_vertex_program); 372EXTRA_EXT2(NV_point_sprite, ARB_point_sprite); 373EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program); 374EXTRA_EXT(ARB_geometry_shader4); 375EXTRA_EXT(ARB_color_buffer_float); 376EXTRA_EXT(EXT_framebuffer_sRGB); 377EXTRA_EXT(OES_EGL_image_external); 378EXTRA_EXT(ARB_blend_func_extended); 379EXTRA_EXT(ARB_uniform_buffer_object); 380EXTRA_EXT(ARB_timer_query); 381EXTRA_EXT(ARB_texture_cube_map_array); 382EXTRA_EXT(ARB_texture_buffer_range); 383EXTRA_EXT(ARB_texture_multisample); 384EXTRA_EXT(ARB_texture_gather); 385EXTRA_EXT(ARB_shader_atomic_counters); 386EXTRA_EXT(ARB_draw_indirect); 387EXTRA_EXT(ARB_shader_image_load_store); 388EXTRA_EXT(ARB_viewport_array); 389EXTRA_EXT(ARB_compute_shader); 390EXTRA_EXT(ARB_gpu_shader5); 391EXTRA_EXT2(ARB_transform_feedback3, ARB_gpu_shader5); 392EXTRA_EXT(INTEL_performance_query); 393EXTRA_EXT(ARB_explicit_uniform_location); 394 395static const int 396extra_ARB_color_buffer_float_or_glcore[] = { 397 EXT(ARB_color_buffer_float), 398 EXTRA_API_GL_CORE, 399 EXTRA_END 400}; 401 402static const int 403extra_NV_primitive_restart[] = { 404 EXT(NV_primitive_restart), 405 EXTRA_END 406}; 407 408static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END }; 409static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END }; 410static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END }; 411static const int extra_version_40[] = { EXTRA_VERSION_40, EXTRA_END }; 412 413static const int extra_gl30_es3[] = { 414 EXTRA_VERSION_30, 415 EXTRA_API_ES3, 416 EXTRA_END, 417}; 418 419static const int extra_gl32_es3[] = { 420 EXTRA_VERSION_32, 421 EXTRA_API_ES3, 422 EXTRA_END, 423}; 424 425static const int extra_gl32_ARB_geometry_shader4[] = { 426 EXTRA_VERSION_32, 427 EXT(ARB_geometry_shader4), 428 EXTRA_END 429}; 430 431static const int extra_gl40_ARB_sample_shading[] = { 432 EXTRA_VERSION_40, 433 EXT(ARB_sample_shading), 434 EXTRA_END 435}; 436 437static const int 438extra_ARB_vertex_program_api_es2[] = { 439 EXT(ARB_vertex_program), 440 EXTRA_API_ES2, 441 EXTRA_END 442}; 443 444/* The ReadBuffer get token is valid under either full GL or under 445 * GLES2 if the NV_read_buffer extension is available. */ 446static const int 447extra_NV_read_buffer_api_gl[] = { 448 EXTRA_API_ES2, 449 EXTRA_API_GL, 450 EXTRA_END 451}; 452 453static const int extra_core_ARB_color_buffer_float_and_new_buffers[] = { 454 EXTRA_API_GL_CORE, 455 EXT(ARB_color_buffer_float), 456 EXTRA_NEW_BUFFERS, 457 EXTRA_END 458}; 459 460/* This is the big table describing all the enums we accept in 461 * glGet*v(). The table is partitioned into six parts: enums 462 * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared 463 * between OpenGL and GLES, enums exclusive to GLES, etc for the 464 * remaining combinations. To look up the enums valid in a given API 465 * we will use a hash table specific to that API. These tables are in 466 * turn generated at build time and included through get_hash.h. 467 */ 468 469#include "get_hash.h" 470 471/* All we need now is a way to look up the value struct from the enum. 472 * The code generated by gcc for the old generated big switch 473 * statement is a big, balanced, open coded if/else tree, essentially 474 * an unrolled binary search. It would be natural to sort the new 475 * enum table and use bsearch(), but we will use a read-only hash 476 * table instead. bsearch() has a nice guaranteed worst case 477 * performance, but we're also guaranteed to hit that worst case 478 * (log2(n) iterations) for about half the enums. Instead, using an 479 * open addressing hash table, we can find the enum on the first try 480 * for 80% of the enums, 1 collision for 10% and never more than 5 481 * collisions for any enum (typical numbers). And the code is very 482 * simple, even though it feels a little magic. */ 483 484#ifdef GET_DEBUG 485static void 486print_table_stats(int api) 487{ 488 int i, j, collisions[11], count, hash, mask; 489 const struct value_desc *d; 490 const char *api_names[] = { 491 [API_OPENGL_COMPAT] = "GL", 492 [API_OPENGL_CORE] = "GL_CORE", 493 [API_OPENGLES] = "GLES", 494 [API_OPENGLES2] = "GLES2", 495 }; 496 const char *api_name; 497 498 api_name = api < Elements(api_names) ? api_names[api] : "N/A"; 499 count = 0; 500 mask = Elements(table(api)) - 1; 501 memset(collisions, 0, sizeof collisions); 502 503 for (i = 0; i < Elements(table(api)); i++) { 504 if (!table(api)[i]) 505 continue; 506 count++; 507 d = &values[table(api)[i]]; 508 hash = (d->pname * prime_factor); 509 j = 0; 510 while (1) { 511 if (values[table(api)[hash & mask]].pname == d->pname) 512 break; 513 hash += prime_step; 514 j++; 515 } 516 517 if (j < 10) 518 collisions[j]++; 519 else 520 collisions[10]++; 521 } 522 523 printf("number of enums for %s: %d (total %ld)\n", 524 api_name, count, Elements(values)); 525 for (i = 0; i < Elements(collisions) - 1; i++) 526 if (collisions[i] > 0) 527 printf(" %d enums with %d %scollisions\n", 528 collisions[i], i, i == 10 ? "or more " : ""); 529} 530#endif 531 532/** 533 * Initialize the enum hash for a given API 534 * 535 * This is called from one_time_init() to insert the enum values that 536 * are valid for the API in question into the enum hash table. 537 * 538 * \param the current context, for determining the API in question 539 */ 540void _mesa_init_get_hash(struct gl_context *ctx) 541{ 542#ifdef GET_DEBUG 543 print_table_stats(ctx->API); 544#else 545 (void) ctx; 546#endif 547} 548 549/** 550 * Handle irregular enums 551 * 552 * Some values don't conform to the "well-known type at context 553 * pointer + offset" pattern, so we have this function to catch all 554 * the corner cases. Typically, it's a computed value or a one-off 555 * pointer to a custom struct or something. 556 * 557 * In this case we can't return a pointer to the value, so we'll have 558 * to use the temporary variable 'v' declared back in the calling 559 * glGet*v() function to store the result. 560 * 561 * \param ctx the current context 562 * \param d the struct value_desc that describes the enum 563 * \param v pointer to the tmp declared in the calling glGet*v() function 564 */ 565static void 566find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v) 567{ 568 struct gl_buffer_object **buffer_obj; 569 struct gl_vertex_attrib_array *array; 570 GLuint unit, *p; 571 572 switch (d->pname) { 573 case GL_MAJOR_VERSION: 574 v->value_int = ctx->Version / 10; 575 break; 576 case GL_MINOR_VERSION: 577 v->value_int = ctx->Version % 10; 578 break; 579 580 case GL_TEXTURE_1D: 581 case GL_TEXTURE_2D: 582 case GL_TEXTURE_3D: 583 case GL_TEXTURE_CUBE_MAP_ARB: 584 case GL_TEXTURE_RECTANGLE_NV: 585 case GL_TEXTURE_EXTERNAL_OES: 586 v->value_bool = _mesa_IsEnabled(d->pname); 587 break; 588 589 case GL_LINE_STIPPLE_PATTERN: 590 /* This is the only GLushort, special case it here by promoting 591 * to an int rather than introducing a new type. */ 592 v->value_int = ctx->Line.StipplePattern; 593 break; 594 595 case GL_CURRENT_RASTER_TEXTURE_COORDS: 596 unit = ctx->Texture.CurrentUnit; 597 v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0]; 598 v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1]; 599 v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2]; 600 v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3]; 601 break; 602 603 case GL_CURRENT_TEXTURE_COORDS: 604 unit = ctx->Texture.CurrentUnit; 605 v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0]; 606 v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1]; 607 v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2]; 608 v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3]; 609 break; 610 611 case GL_COLOR_WRITEMASK: 612 v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0; 613 v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0; 614 v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0; 615 v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0; 616 break; 617 618 case GL_EDGE_FLAG: 619 v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0; 620 break; 621 622 case GL_READ_BUFFER: 623 v->value_enum = ctx->ReadBuffer->ColorReadBuffer; 624 break; 625 626 case GL_MAP2_GRID_DOMAIN: 627 v->value_float_4[0] = ctx->Eval.MapGrid2u1; 628 v->value_float_4[1] = ctx->Eval.MapGrid2u2; 629 v->value_float_4[2] = ctx->Eval.MapGrid2v1; 630 v->value_float_4[3] = ctx->Eval.MapGrid2v2; 631 break; 632 633 case GL_TEXTURE_STACK_DEPTH: 634 unit = ctx->Texture.CurrentUnit; 635 v->value_int = ctx->TextureMatrixStack[unit].Depth + 1; 636 break; 637 case GL_TEXTURE_MATRIX: 638 unit = ctx->Texture.CurrentUnit; 639 v->value_matrix = ctx->TextureMatrixStack[unit].Top; 640 break; 641 642 case GL_TEXTURE_COORD_ARRAY: 643 case GL_TEXTURE_COORD_ARRAY_SIZE: 644 case GL_TEXTURE_COORD_ARRAY_TYPE: 645 case GL_TEXTURE_COORD_ARRAY_STRIDE: 646 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)]; 647 v->value_int = *(GLuint *) ((char *) array + d->offset); 648 break; 649 650 case GL_ACTIVE_TEXTURE_ARB: 651 v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit; 652 break; 653 case GL_CLIENT_ACTIVE_TEXTURE_ARB: 654 v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture; 655 break; 656 657 case GL_MODELVIEW_STACK_DEPTH: 658 case GL_PROJECTION_STACK_DEPTH: 659 v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1; 660 break; 661 662 case GL_MAX_TEXTURE_SIZE: 663 case GL_MAX_3D_TEXTURE_SIZE: 664 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB: 665 p = (GLuint *) ((char *) ctx + d->offset); 666 v->value_int = 1 << (*p - 1); 667 break; 668 669 case GL_SCISSOR_BOX: 670 v->value_int_4[0] = ctx->Scissor.ScissorArray[0].X; 671 v->value_int_4[1] = ctx->Scissor.ScissorArray[0].Y; 672 v->value_int_4[2] = ctx->Scissor.ScissorArray[0].Width; 673 v->value_int_4[3] = ctx->Scissor.ScissorArray[0].Height; 674 break; 675 676 case GL_SCISSOR_TEST: 677 v->value_bool = ctx->Scissor.EnableFlags & 1; 678 break; 679 680 case GL_LIST_INDEX: 681 v->value_int = 682 ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0; 683 break; 684 case GL_LIST_MODE: 685 if (!ctx->CompileFlag) 686 v->value_enum = 0; 687 else if (ctx->ExecuteFlag) 688 v->value_enum = GL_COMPILE_AND_EXECUTE; 689 else 690 v->value_enum = GL_COMPILE; 691 break; 692 693 case GL_VIEWPORT: 694 v->value_float_4[0] = ctx->ViewportArray[0].X; 695 v->value_float_4[1] = ctx->ViewportArray[0].Y; 696 v->value_float_4[2] = ctx->ViewportArray[0].Width; 697 v->value_float_4[3] = ctx->ViewportArray[0].Height; 698 break; 699 700 case GL_DEPTH_RANGE: 701 v->value_double_2[0] = ctx->ViewportArray[0].Near; 702 v->value_double_2[1] = ctx->ViewportArray[0].Far; 703 break; 704 705 case GL_ACTIVE_STENCIL_FACE_EXT: 706 v->value_enum = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT; 707 break; 708 709 case GL_STENCIL_FAIL: 710 v->value_enum = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace]; 711 break; 712 case GL_STENCIL_FUNC: 713 v->value_enum = ctx->Stencil.Function[ctx->Stencil.ActiveFace]; 714 break; 715 case GL_STENCIL_PASS_DEPTH_FAIL: 716 v->value_enum = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace]; 717 break; 718 case GL_STENCIL_PASS_DEPTH_PASS: 719 v->value_enum = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace]; 720 break; 721 case GL_STENCIL_REF: 722 v->value_int = _mesa_get_stencil_ref(ctx, ctx->Stencil.ActiveFace); 723 break; 724 case GL_STENCIL_BACK_REF: 725 v->value_int = _mesa_get_stencil_ref(ctx, 1); 726 break; 727 case GL_STENCIL_VALUE_MASK: 728 v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace]; 729 break; 730 case GL_STENCIL_WRITEMASK: 731 v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace]; 732 break; 733 734 case GL_NUM_EXTENSIONS: 735 v->value_int = _mesa_get_extension_count(ctx); 736 break; 737 738 case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: 739 v->value_int = _mesa_get_color_read_type(ctx); 740 break; 741 case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: 742 v->value_int = _mesa_get_color_read_format(ctx); 743 break; 744 745 case GL_CURRENT_MATRIX_STACK_DEPTH_ARB: 746 v->value_int = ctx->CurrentStack->Depth + 1; 747 break; 748 case GL_CURRENT_MATRIX_ARB: 749 case GL_TRANSPOSE_CURRENT_MATRIX_ARB: 750 v->value_matrix = ctx->CurrentStack->Top; 751 break; 752 753 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB: 754 v->value_int = _mesa_get_compressed_formats(ctx, NULL); 755 break; 756 case GL_COMPRESSED_TEXTURE_FORMATS_ARB: 757 v->value_int_n.n = 758 _mesa_get_compressed_formats(ctx, v->value_int_n.ints); 759 ASSERT(v->value_int_n.n <= (int) ARRAY_SIZE(v->value_int_n.ints)); 760 break; 761 762 case GL_MAX_VARYING_FLOATS_ARB: 763 v->value_int = ctx->Const.MaxVarying * 4; 764 break; 765 766 /* Various object names */ 767 768 case GL_TEXTURE_BINDING_1D: 769 case GL_TEXTURE_BINDING_2D: 770 case GL_TEXTURE_BINDING_3D: 771 case GL_TEXTURE_BINDING_1D_ARRAY_EXT: 772 case GL_TEXTURE_BINDING_2D_ARRAY_EXT: 773 case GL_TEXTURE_BINDING_CUBE_MAP_ARB: 774 case GL_TEXTURE_BINDING_RECTANGLE_NV: 775 case GL_TEXTURE_BINDING_EXTERNAL_OES: 776 case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY: 777 case GL_TEXTURE_BINDING_2D_MULTISAMPLE: 778 case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY: 779 unit = ctx->Texture.CurrentUnit; 780 v->value_int = 781 ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name; 782 break; 783 784 /* GL_EXT_packed_float */ 785 case GL_RGBA_SIGNED_COMPONENTS_EXT: 786 { 787 /* Note: we only check the 0th color attachment. */ 788 const struct gl_renderbuffer *rb = 789 ctx->DrawBuffer->_ColorDrawBuffers[0]; 790 if (rb && _mesa_is_format_signed(rb->Format)) { 791 /* Issue 17 of GL_EXT_packed_float: If a component (such as 792 * alpha) has zero bits, the component should not be considered 793 * signed and so the bit for the respective component should be 794 * zeroed. 795 */ 796 GLint r_bits = 797 _mesa_get_format_bits(rb->Format, GL_RED_BITS); 798 GLint g_bits = 799 _mesa_get_format_bits(rb->Format, GL_GREEN_BITS); 800 GLint b_bits = 801 _mesa_get_format_bits(rb->Format, GL_BLUE_BITS); 802 GLint a_bits = 803 _mesa_get_format_bits(rb->Format, GL_ALPHA_BITS); 804 GLint l_bits = 805 _mesa_get_format_bits(rb->Format, GL_TEXTURE_LUMINANCE_SIZE); 806 GLint i_bits = 807 _mesa_get_format_bits(rb->Format, GL_TEXTURE_INTENSITY_SIZE); 808 809 v->value_int_4[0] = r_bits + l_bits + i_bits > 0; 810 v->value_int_4[1] = g_bits + l_bits + i_bits > 0; 811 v->value_int_4[2] = b_bits + l_bits + i_bits > 0; 812 v->value_int_4[3] = a_bits + i_bits > 0; 813 } 814 else { 815 v->value_int_4[0] = 816 v->value_int_4[1] = 817 v->value_int_4[2] = 818 v->value_int_4[3] = 0; 819 } 820 } 821 break; 822 823 /* GL_ARB_vertex_buffer_object */ 824 case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB: 825 case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB: 826 case GL_COLOR_ARRAY_BUFFER_BINDING_ARB: 827 case GL_INDEX_ARRAY_BUFFER_BINDING_ARB: 828 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB: 829 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB: 830 case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB: 831 buffer_obj = (struct gl_buffer_object **) 832 ((char *) ctx->Array.VAO + d->offset); 833 v->value_int = (*buffer_obj)->Name; 834 break; 835 case GL_ARRAY_BUFFER_BINDING_ARB: 836 v->value_int = ctx->Array.ArrayBufferObj->Name; 837 break; 838 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB: 839 v->value_int = 840 ctx->Array.VAO->VertexBinding[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj->Name; 841 break; 842 case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB: 843 v->value_int = ctx->Array.VAO->IndexBufferObj->Name; 844 break; 845 846 /* ARB_vertex_array_bgra */ 847 case GL_COLOR_ARRAY_SIZE: 848 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0]; 849 v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size; 850 break; 851 case GL_SECONDARY_COLOR_ARRAY_SIZE: 852 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1]; 853 v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size; 854 break; 855 856 /* ARB_copy_buffer */ 857 case GL_COPY_READ_BUFFER: 858 v->value_int = ctx->CopyReadBuffer->Name; 859 break; 860 case GL_COPY_WRITE_BUFFER: 861 v->value_int = ctx->CopyWriteBuffer->Name; 862 break; 863 864 case GL_PIXEL_PACK_BUFFER_BINDING_EXT: 865 v->value_int = ctx->Pack.BufferObj->Name; 866 break; 867 case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT: 868 v->value_int = ctx->Unpack.BufferObj->Name; 869 break; 870 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: 871 v->value_int = ctx->TransformFeedback.CurrentBuffer->Name; 872 break; 873 case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED: 874 v->value_int = ctx->TransformFeedback.CurrentObject->Paused; 875 break; 876 case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE: 877 v->value_int = ctx->TransformFeedback.CurrentObject->Active; 878 break; 879 case GL_TRANSFORM_FEEDBACK_BINDING: 880 v->value_int = ctx->TransformFeedback.CurrentObject->Name; 881 break; 882 case GL_CURRENT_PROGRAM: 883 /* The Changelog of the ARB_separate_shader_objects spec says: 884 * 885 * 24 25 Jul 2011 pbrown Remove the language erroneously deleting 886 * CURRENT_PROGRAM. In the EXT extension, this 887 * token was aliased to ACTIVE_PROGRAM_EXT, and 888 * was used to indicate the last program set by 889 * either ActiveProgramEXT or UseProgram. In 890 * the ARB extension, the SSO active programs 891 * are now program pipeline object state and 892 * CURRENT_PROGRAM should still be used to query 893 * the last program set by UseProgram (bug 7822). 894 */ 895 v->value_int = 896 ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0; 897 break; 898 case GL_READ_FRAMEBUFFER_BINDING_EXT: 899 v->value_int = ctx->ReadBuffer->Name; 900 break; 901 case GL_RENDERBUFFER_BINDING_EXT: 902 v->value_int = 903 ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0; 904 break; 905 case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: 906 v->value_int = ctx->Array.VAO->VertexBinding[VERT_ATTRIB_POINT_SIZE].BufferObj->Name; 907 break; 908 909 case GL_FOG_COLOR: 910 if (_mesa_get_clamp_fragment_color(ctx)) 911 COPY_4FV(v->value_float_4, ctx->Fog.Color); 912 else 913 COPY_4FV(v->value_float_4, ctx->Fog.ColorUnclamped); 914 break; 915 case GL_COLOR_CLEAR_VALUE: 916 if (_mesa_get_clamp_fragment_color(ctx)) { 917 v->value_float_4[0] = CLAMP(ctx->Color.ClearColor.f[0], 0.0F, 1.0F); 918 v->value_float_4[1] = CLAMP(ctx->Color.ClearColor.f[1], 0.0F, 1.0F); 919 v->value_float_4[2] = CLAMP(ctx->Color.ClearColor.f[2], 0.0F, 1.0F); 920 v->value_float_4[3] = CLAMP(ctx->Color.ClearColor.f[3], 0.0F, 1.0F); 921 } else 922 COPY_4FV(v->value_float_4, ctx->Color.ClearColor.f); 923 break; 924 case GL_BLEND_COLOR_EXT: 925 if (_mesa_get_clamp_fragment_color(ctx)) 926 COPY_4FV(v->value_float_4, ctx->Color.BlendColor); 927 else 928 COPY_4FV(v->value_float_4, ctx->Color.BlendColorUnclamped); 929 break; 930 case GL_ALPHA_TEST_REF: 931 if (_mesa_get_clamp_fragment_color(ctx)) 932 v->value_float = ctx->Color.AlphaRef; 933 else 934 v->value_float = ctx->Color.AlphaRefUnclamped; 935 break; 936 case GL_MAX_VERTEX_UNIFORM_VECTORS: 937 v->value_int = ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents / 4; 938 break; 939 940 case GL_MAX_FRAGMENT_UNIFORM_VECTORS: 941 v->value_int = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents / 4; 942 break; 943 944 /* GL_ARB_texture_buffer_object */ 945 case GL_TEXTURE_BUFFER_ARB: 946 v->value_int = ctx->Texture.BufferObject->Name; 947 break; 948 case GL_TEXTURE_BINDING_BUFFER_ARB: 949 unit = ctx->Texture.CurrentUnit; 950 v->value_int = 951 ctx->Texture.Unit[unit].CurrentTex[TEXTURE_BUFFER_INDEX]->Name; 952 break; 953 case GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB: 954 { 955 struct gl_buffer_object *buf = 956 ctx->Texture.Unit[ctx->Texture.CurrentUnit] 957 .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObject; 958 v->value_int = buf ? buf->Name : 0; 959 } 960 break; 961 case GL_TEXTURE_BUFFER_FORMAT_ARB: 962 v->value_int = ctx->Texture.Unit[ctx->Texture.CurrentUnit] 963 .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObjectFormat; 964 break; 965 966 /* GL_ARB_sampler_objects */ 967 case GL_SAMPLER_BINDING: 968 { 969 struct gl_sampler_object *samp = 970 ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler; 971 972 /* 973 * The sampler object may have been deleted on another context, 974 * so we try to lookup the sampler object before returning its Name. 975 */ 976 if (samp && _mesa_lookup_samplerobj(ctx, samp->Name)) { 977 v->value_int = samp->Name; 978 } else { 979 v->value_int = 0; 980 } 981 } 982 break; 983 /* GL_ARB_uniform_buffer_object */ 984 case GL_UNIFORM_BUFFER_BINDING: 985 v->value_int = ctx->UniformBuffer->Name; 986 break; 987 /* GL_ARB_timer_query */ 988 case GL_TIMESTAMP: 989 if (ctx->Driver.GetTimestamp) { 990 v->value_int64 = ctx->Driver.GetTimestamp(ctx); 991 } 992 else { 993 _mesa_problem(ctx, "driver doesn't implement GetTimestamp"); 994 } 995 break; 996 /* GL_KHR_DEBUG */ 997 case GL_DEBUG_LOGGED_MESSAGES: 998 case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH: 999 case GL_DEBUG_GROUP_STACK_DEPTH: 1000 v->value_int = _mesa_get_debug_state_int(ctx, d->pname); 1001 break; 1002 /* GL_ARB_shader_atomic_counters */ 1003 case GL_ATOMIC_COUNTER_BUFFER_BINDING: 1004 if (ctx->AtomicBuffer) { 1005 v->value_int = ctx->AtomicBuffer->Name; 1006 } else { 1007 v->value_int = 0; 1008 } 1009 break; 1010 /* GL_ARB_draw_indirect */ 1011 case GL_DRAW_INDIRECT_BUFFER_BINDING: 1012 v->value_int = ctx->DrawIndirectBuffer->Name; 1013 break; 1014 /* GL_ARB_separate_shader_objects */ 1015 case GL_PROGRAM_PIPELINE_BINDING: 1016 if (ctx->Pipeline.Current) { 1017 v->value_int = ctx->Pipeline.Current->Name; 1018 } else { 1019 v->value_int = 0; 1020 } 1021 break; 1022 } 1023} 1024 1025/** 1026 * Check extra constraints on a struct value_desc descriptor 1027 * 1028 * If a struct value_desc has a non-NULL extra pointer, it means that 1029 * there are a number of extra constraints to check or actions to 1030 * perform. The extras is just an integer array where each integer 1031 * encode different constraints or actions. 1032 * 1033 * \param ctx current context 1034 * \param func name of calling glGet*v() function for error reporting 1035 * \param d the struct value_desc that has the extra constraints 1036 * 1037 * \return GL_FALSE if all of the constraints were not satisfied, 1038 * otherwise GL_TRUE. 1039 */ 1040static GLboolean 1041check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d) 1042{ 1043 const GLuint version = ctx->Version; 1044 GLboolean api_check = GL_FALSE; 1045 GLboolean api_found = GL_FALSE; 1046 const int *e; 1047 1048 for (e = d->extra; *e != EXTRA_END; e++) { 1049 switch (*e) { 1050 case EXTRA_VERSION_30: 1051 api_check = GL_TRUE; 1052 if (version >= 30) 1053 api_found = GL_TRUE; 1054 break; 1055 case EXTRA_VERSION_31: 1056 api_check = GL_TRUE; 1057 if (version >= 31) 1058 api_found = GL_TRUE; 1059 break; 1060 case EXTRA_VERSION_32: 1061 api_check = GL_TRUE; 1062 if (version >= 32) 1063 api_found = GL_TRUE; 1064 break; 1065 case EXTRA_NEW_FRAG_CLAMP: 1066 if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP)) 1067 _mesa_update_state(ctx); 1068 break; 1069 case EXTRA_API_ES2: 1070 api_check = GL_TRUE; 1071 if (ctx->API == API_OPENGLES2) 1072 api_found = GL_TRUE; 1073 break; 1074 case EXTRA_API_ES3: 1075 api_check = GL_TRUE; 1076 if (_mesa_is_gles3(ctx)) 1077 api_found = GL_TRUE; 1078 break; 1079 case EXTRA_API_GL: 1080 api_check = GL_TRUE; 1081 if (_mesa_is_desktop_gl(ctx)) 1082 api_found = GL_TRUE; 1083 break; 1084 case EXTRA_API_GL_CORE: 1085 api_check = GL_TRUE; 1086 if (ctx->API == API_OPENGL_CORE) 1087 api_found = GL_TRUE; 1088 break; 1089 case EXTRA_NEW_BUFFERS: 1090 if (ctx->NewState & _NEW_BUFFERS) 1091 _mesa_update_state(ctx); 1092 break; 1093 case EXTRA_FLUSH_CURRENT: 1094 FLUSH_CURRENT(ctx, 0); 1095 break; 1096 case EXTRA_VALID_DRAW_BUFFER: 1097 if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) { 1098 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)", 1099 func, d->pname - GL_DRAW_BUFFER0_ARB); 1100 return GL_FALSE; 1101 } 1102 break; 1103 case EXTRA_VALID_TEXTURE_UNIT: 1104 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) { 1105 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)", 1106 func, ctx->Texture.CurrentUnit); 1107 return GL_FALSE; 1108 } 1109 break; 1110 case EXTRA_VALID_CLIP_DISTANCE: 1111 if (d->pname - GL_CLIP_DISTANCE0 >= ctx->Const.MaxClipPlanes) { 1112 _mesa_error(ctx, GL_INVALID_ENUM, "%s(clip distance %u)", 1113 func, d->pname - GL_CLIP_DISTANCE0); 1114 return GL_FALSE; 1115 } 1116 break; 1117 case EXTRA_GLSL_130: 1118 api_check = GL_TRUE; 1119 if (ctx->Const.GLSLVersion >= 130) 1120 api_found = GL_TRUE; 1121 break; 1122 case EXTRA_EXT_UBO_GS4: 1123 api_check = GL_TRUE; 1124 api_found = (ctx->Extensions.ARB_uniform_buffer_object && 1125 _mesa_has_geometry_shaders(ctx)); 1126 break; 1127 case EXTRA_EXT_ATOMICS_GS4: 1128 api_check = GL_TRUE; 1129 api_found = (ctx->Extensions.ARB_shader_atomic_counters && 1130 _mesa_has_geometry_shaders(ctx)); 1131 break; 1132 case EXTRA_EXT_SHADER_IMAGE_GS4: 1133 api_check = GL_TRUE; 1134 api_found = (ctx->Extensions.ARB_shader_image_load_store && 1135 _mesa_has_geometry_shaders(ctx)); 1136 break; 1137 case EXTRA_END: 1138 break; 1139 default: /* *e is a offset into the extension struct */ 1140 api_check = GL_TRUE; 1141 if (*(GLboolean *) ((char *) &ctx->Extensions + *e)) 1142 api_found = GL_TRUE; 1143 break; 1144 } 1145 } 1146 1147 if (api_check && !api_found) { 1148 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func, 1149 _mesa_lookup_enum_by_nr(d->pname)); 1150 return GL_FALSE; 1151 } 1152 1153 return GL_TRUE; 1154} 1155 1156static const struct value_desc error_value = 1157 { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA }; 1158 1159/** 1160 * Find the struct value_desc corresponding to the enum 'pname'. 1161 * 1162 * We hash the enum value to get an index into the 'table' array, 1163 * which holds the index in the 'values' array of struct value_desc. 1164 * Once we've found the entry, we do the extra checks, if any, then 1165 * look up the value and return a pointer to it. 1166 * 1167 * If the value has to be computed (for example, it's the result of a 1168 * function call or we need to add 1 to it), we use the tmp 'v' to 1169 * store the result. 1170 * 1171 * \param func name of glGet*v() func for error reporting 1172 * \param pname the enum value we're looking up 1173 * \param p is were we return the pointer to the value 1174 * \param v a tmp union value variable in the calling glGet*v() function 1175 * 1176 * \return the struct value_desc corresponding to the enum or a struct 1177 * value_desc of TYPE_INVALID if not found. This lets the calling 1178 * glGet*v() function jump right into a switch statement and 1179 * handle errors there instead of having to check for NULL. 1180 */ 1181static const struct value_desc * 1182find_value(const char *func, GLenum pname, void **p, union value *v) 1183{ 1184 GET_CURRENT_CONTEXT(ctx); 1185 struct gl_texture_unit *unit; 1186 int mask, hash; 1187 const struct value_desc *d; 1188 int api; 1189 1190 api = ctx->API; 1191 /* We index into the table_set[] list of per-API hash tables using the API's 1192 * value in the gl_api enum. Since GLES 3 doesn't have an API_OPENGL* enum 1193 * value since it's compatible with GLES2 its entry in table_set[] is at the 1194 * end. 1195 */ 1196 STATIC_ASSERT(Elements(table_set) == API_OPENGL_LAST + 2); 1197 if (_mesa_is_gles3(ctx)) { 1198 api = API_OPENGL_LAST + 1; 1199 } 1200 mask = Elements(table(api)) - 1; 1201 hash = (pname * prime_factor); 1202 while (1) { 1203 int idx = table(api)[hash & mask]; 1204 1205 /* If the enum isn't valid, the hash walk ends with index 0, 1206 * pointing to the first entry of values[] which doesn't hold 1207 * any valid enum. */ 1208 if (unlikely(idx == 0)) { 1209 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func, 1210 _mesa_lookup_enum_by_nr(pname)); 1211 return &error_value; 1212 } 1213 1214 d = &values[idx]; 1215 if (likely(d->pname == pname)) 1216 break; 1217 1218 hash += prime_step; 1219 } 1220 1221 if (unlikely(d->extra && !check_extra(ctx, func, d))) 1222 return &error_value; 1223 1224 switch (d->location) { 1225 case LOC_BUFFER: 1226 *p = ((char *) ctx->DrawBuffer + d->offset); 1227 return d; 1228 case LOC_CONTEXT: 1229 *p = ((char *) ctx + d->offset); 1230 return d; 1231 case LOC_ARRAY: 1232 *p = ((char *) ctx->Array.VAO + d->offset); 1233 return d; 1234 case LOC_TEXUNIT: 1235 unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit]; 1236 *p = ((char *) unit + d->offset); 1237 return d; 1238 case LOC_CUSTOM: 1239 find_custom_value(ctx, d, v); 1240 *p = v; 1241 return d; 1242 default: 1243 assert(0); 1244 break; 1245 } 1246 1247 /* silence warning */ 1248 return &error_value; 1249} 1250 1251static const int transpose[] = { 1252 0, 4, 8, 12, 1253 1, 5, 9, 13, 1254 2, 6, 10, 14, 1255 3, 7, 11, 15 1256}; 1257 1258void GLAPIENTRY 1259_mesa_GetBooleanv(GLenum pname, GLboolean *params) 1260{ 1261 const struct value_desc *d; 1262 union value v; 1263 GLmatrix *m; 1264 int shift, i; 1265 void *p; 1266 1267 d = find_value("glGetBooleanv", pname, &p, &v); 1268 switch (d->type) { 1269 case TYPE_INVALID: 1270 break; 1271 case TYPE_CONST: 1272 params[0] = INT_TO_BOOLEAN(d->offset); 1273 break; 1274 1275 case TYPE_FLOAT_4: 1276 case TYPE_FLOATN_4: 1277 params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]); 1278 case TYPE_FLOAT_3: 1279 case TYPE_FLOATN_3: 1280 params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]); 1281 case TYPE_FLOAT_2: 1282 case TYPE_FLOATN_2: 1283 params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]); 1284 case TYPE_FLOAT: 1285 case TYPE_FLOATN: 1286 params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]); 1287 break; 1288 1289 case TYPE_DOUBLEN_2: 1290 params[1] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[1]); 1291 case TYPE_DOUBLEN: 1292 params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]); 1293 break; 1294 1295 case TYPE_INT_4: 1296 params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]); 1297 case TYPE_INT_3: 1298 params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]); 1299 case TYPE_INT_2: 1300 case TYPE_ENUM_2: 1301 params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]); 1302 case TYPE_INT: 1303 case TYPE_ENUM: 1304 params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]); 1305 break; 1306 1307 case TYPE_INT_N: 1308 for (i = 0; i < v.value_int_n.n; i++) 1309 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]); 1310 break; 1311 1312 case TYPE_INT64: 1313 params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]); 1314 break; 1315 1316 case TYPE_BOOLEAN: 1317 params[0] = ((GLboolean*) p)[0]; 1318 break; 1319 1320 case TYPE_MATRIX: 1321 m = *(GLmatrix **) p; 1322 for (i = 0; i < 16; i++) 1323 params[i] = FLOAT_TO_BOOLEAN(m->m[i]); 1324 break; 1325 1326 case TYPE_MATRIX_T: 1327 m = *(GLmatrix **) p; 1328 for (i = 0; i < 16; i++) 1329 params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]); 1330 break; 1331 1332 case TYPE_BIT_0: 1333 case TYPE_BIT_1: 1334 case TYPE_BIT_2: 1335 case TYPE_BIT_3: 1336 case TYPE_BIT_4: 1337 case TYPE_BIT_5: 1338 case TYPE_BIT_6: 1339 case TYPE_BIT_7: 1340 shift = d->type - TYPE_BIT_0; 1341 params[0] = (*(GLbitfield *) p >> shift) & 1; 1342 break; 1343 } 1344} 1345 1346void GLAPIENTRY 1347_mesa_GetFloatv(GLenum pname, GLfloat *params) 1348{ 1349 const struct value_desc *d; 1350 union value v; 1351 GLmatrix *m; 1352 int shift, i; 1353 void *p; 1354 1355 d = find_value("glGetFloatv", pname, &p, &v); 1356 switch (d->type) { 1357 case TYPE_INVALID: 1358 break; 1359 case TYPE_CONST: 1360 params[0] = (GLfloat) d->offset; 1361 break; 1362 1363 case TYPE_FLOAT_4: 1364 case TYPE_FLOATN_4: 1365 params[3] = ((GLfloat *) p)[3]; 1366 case TYPE_FLOAT_3: 1367 case TYPE_FLOATN_3: 1368 params[2] = ((GLfloat *) p)[2]; 1369 case TYPE_FLOAT_2: 1370 case TYPE_FLOATN_2: 1371 params[1] = ((GLfloat *) p)[1]; 1372 case TYPE_FLOAT: 1373 case TYPE_FLOATN: 1374 params[0] = ((GLfloat *) p)[0]; 1375 break; 1376 1377 case TYPE_DOUBLEN_2: 1378 params[1] = (GLfloat) (((GLdouble *) p)[1]); 1379 case TYPE_DOUBLEN: 1380 params[0] = (GLfloat) (((GLdouble *) p)[0]); 1381 break; 1382 1383 case TYPE_INT_4: 1384 params[3] = (GLfloat) (((GLint *) p)[3]); 1385 case TYPE_INT_3: 1386 params[2] = (GLfloat) (((GLint *) p)[2]); 1387 case TYPE_INT_2: 1388 case TYPE_ENUM_2: 1389 params[1] = (GLfloat) (((GLint *) p)[1]); 1390 case TYPE_INT: 1391 case TYPE_ENUM: 1392 params[0] = (GLfloat) (((GLint *) p)[0]); 1393 break; 1394 1395 case TYPE_INT_N: 1396 for (i = 0; i < v.value_int_n.n; i++) 1397 params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]); 1398 break; 1399 1400 case TYPE_INT64: 1401 params[0] = (GLfloat) (((GLint64 *) p)[0]); 1402 break; 1403 1404 case TYPE_BOOLEAN: 1405 params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p); 1406 break; 1407 1408 case TYPE_MATRIX: 1409 m = *(GLmatrix **) p; 1410 for (i = 0; i < 16; i++) 1411 params[i] = m->m[i]; 1412 break; 1413 1414 case TYPE_MATRIX_T: 1415 m = *(GLmatrix **) p; 1416 for (i = 0; i < 16; i++) 1417 params[i] = m->m[transpose[i]]; 1418 break; 1419 1420 case TYPE_BIT_0: 1421 case TYPE_BIT_1: 1422 case TYPE_BIT_2: 1423 case TYPE_BIT_3: 1424 case TYPE_BIT_4: 1425 case TYPE_BIT_5: 1426 case TYPE_BIT_6: 1427 case TYPE_BIT_7: 1428 shift = d->type - TYPE_BIT_0; 1429 params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1); 1430 break; 1431 } 1432} 1433 1434void GLAPIENTRY 1435_mesa_GetIntegerv(GLenum pname, GLint *params) 1436{ 1437 const struct value_desc *d; 1438 union value v; 1439 GLmatrix *m; 1440 int shift, i; 1441 void *p; 1442 1443 d = find_value("glGetIntegerv", pname, &p, &v); 1444 switch (d->type) { 1445 case TYPE_INVALID: 1446 break; 1447 case TYPE_CONST: 1448 params[0] = d->offset; 1449 break; 1450 1451 case TYPE_FLOAT_4: 1452 params[3] = IROUND(((GLfloat *) p)[3]); 1453 case TYPE_FLOAT_3: 1454 params[2] = IROUND(((GLfloat *) p)[2]); 1455 case TYPE_FLOAT_2: 1456 params[1] = IROUND(((GLfloat *) p)[1]); 1457 case TYPE_FLOAT: 1458 params[0] = IROUND(((GLfloat *) p)[0]); 1459 break; 1460 1461 case TYPE_FLOATN_4: 1462 params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]); 1463 case TYPE_FLOATN_3: 1464 params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]); 1465 case TYPE_FLOATN_2: 1466 params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]); 1467 case TYPE_FLOATN: 1468 params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]); 1469 break; 1470 1471 case TYPE_DOUBLEN_2: 1472 params[1] = FLOAT_TO_INT(((GLdouble *) p)[1]); 1473 case TYPE_DOUBLEN: 1474 params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]); 1475 break; 1476 1477 case TYPE_INT_4: 1478 params[3] = ((GLint *) p)[3]; 1479 case TYPE_INT_3: 1480 params[2] = ((GLint *) p)[2]; 1481 case TYPE_INT_2: 1482 case TYPE_ENUM_2: 1483 params[1] = ((GLint *) p)[1]; 1484 case TYPE_INT: 1485 case TYPE_ENUM: 1486 params[0] = ((GLint *) p)[0]; 1487 break; 1488 1489 case TYPE_INT_N: 1490 for (i = 0; i < v.value_int_n.n; i++) 1491 params[i] = v.value_int_n.ints[i]; 1492 break; 1493 1494 case TYPE_INT64: 1495 params[0] = INT64_TO_INT(((GLint64 *) p)[0]); 1496 break; 1497 1498 case TYPE_BOOLEAN: 1499 params[0] = BOOLEAN_TO_INT(*(GLboolean*) p); 1500 break; 1501 1502 case TYPE_MATRIX: 1503 m = *(GLmatrix **) p; 1504 for (i = 0; i < 16; i++) 1505 params[i] = FLOAT_TO_INT(m->m[i]); 1506 break; 1507 1508 case TYPE_MATRIX_T: 1509 m = *(GLmatrix **) p; 1510 for (i = 0; i < 16; i++) 1511 params[i] = FLOAT_TO_INT(m->m[transpose[i]]); 1512 break; 1513 1514 case TYPE_BIT_0: 1515 case TYPE_BIT_1: 1516 case TYPE_BIT_2: 1517 case TYPE_BIT_3: 1518 case TYPE_BIT_4: 1519 case TYPE_BIT_5: 1520 case TYPE_BIT_6: 1521 case TYPE_BIT_7: 1522 shift = d->type - TYPE_BIT_0; 1523 params[0] = (*(GLbitfield *) p >> shift) & 1; 1524 break; 1525 } 1526} 1527 1528void GLAPIENTRY 1529_mesa_GetInteger64v(GLenum pname, GLint64 *params) 1530{ 1531 const struct value_desc *d; 1532 union value v; 1533 GLmatrix *m; 1534 int shift, i; 1535 void *p; 1536 1537 d = find_value("glGetInteger64v", pname, &p, &v); 1538 switch (d->type) { 1539 case TYPE_INVALID: 1540 break; 1541 case TYPE_CONST: 1542 params[0] = d->offset; 1543 break; 1544 1545 case TYPE_FLOAT_4: 1546 params[3] = IROUND64(((GLfloat *) p)[3]); 1547 case TYPE_FLOAT_3: 1548 params[2] = IROUND64(((GLfloat *) p)[2]); 1549 case TYPE_FLOAT_2: 1550 params[1] = IROUND64(((GLfloat *) p)[1]); 1551 case TYPE_FLOAT: 1552 params[0] = IROUND64(((GLfloat *) p)[0]); 1553 break; 1554 1555 case TYPE_FLOATN_4: 1556 params[3] = FLOAT_TO_INT64(((GLfloat *) p)[3]); 1557 case TYPE_FLOATN_3: 1558 params[2] = FLOAT_TO_INT64(((GLfloat *) p)[2]); 1559 case TYPE_FLOATN_2: 1560 params[1] = FLOAT_TO_INT64(((GLfloat *) p)[1]); 1561 case TYPE_FLOATN: 1562 params[0] = FLOAT_TO_INT64(((GLfloat *) p)[0]); 1563 break; 1564 1565 case TYPE_DOUBLEN_2: 1566 params[1] = FLOAT_TO_INT64(((GLdouble *) p)[1]); 1567 case TYPE_DOUBLEN: 1568 params[0] = FLOAT_TO_INT64(((GLdouble *) p)[0]); 1569 break; 1570 1571 case TYPE_INT_4: 1572 params[3] = ((GLint *) p)[3]; 1573 case TYPE_INT_3: 1574 params[2] = ((GLint *) p)[2]; 1575 case TYPE_INT_2: 1576 case TYPE_ENUM_2: 1577 params[1] = ((GLint *) p)[1]; 1578 case TYPE_INT: 1579 case TYPE_ENUM: 1580 params[0] = ((GLint *) p)[0]; 1581 break; 1582 1583 case TYPE_INT_N: 1584 for (i = 0; i < v.value_int_n.n; i++) 1585 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]); 1586 break; 1587 1588 case TYPE_INT64: 1589 params[0] = ((GLint64 *) p)[0]; 1590 break; 1591 1592 case TYPE_BOOLEAN: 1593 params[0] = ((GLboolean*) p)[0]; 1594 break; 1595 1596 case TYPE_MATRIX: 1597 m = *(GLmatrix **) p; 1598 for (i = 0; i < 16; i++) 1599 params[i] = FLOAT_TO_INT64(m->m[i]); 1600 break; 1601 1602 case TYPE_MATRIX_T: 1603 m = *(GLmatrix **) p; 1604 for (i = 0; i < 16; i++) 1605 params[i] = FLOAT_TO_INT64(m->m[transpose[i]]); 1606 break; 1607 1608 case TYPE_BIT_0: 1609 case TYPE_BIT_1: 1610 case TYPE_BIT_2: 1611 case TYPE_BIT_3: 1612 case TYPE_BIT_4: 1613 case TYPE_BIT_5: 1614 case TYPE_BIT_6: 1615 case TYPE_BIT_7: 1616 shift = d->type - TYPE_BIT_0; 1617 params[0] = (*(GLbitfield *) p >> shift) & 1; 1618 break; 1619 } 1620} 1621 1622void GLAPIENTRY 1623_mesa_GetDoublev(GLenum pname, GLdouble *params) 1624{ 1625 const struct value_desc *d; 1626 union value v; 1627 GLmatrix *m; 1628 int shift, i; 1629 void *p; 1630 1631 d = find_value("glGetDoublev", pname, &p, &v); 1632 switch (d->type) { 1633 case TYPE_INVALID: 1634 break; 1635 case TYPE_CONST: 1636 params[0] = d->offset; 1637 break; 1638 1639 case TYPE_FLOAT_4: 1640 case TYPE_FLOATN_4: 1641 params[3] = ((GLfloat *) p)[3]; 1642 case TYPE_FLOAT_3: 1643 case TYPE_FLOATN_3: 1644 params[2] = ((GLfloat *) p)[2]; 1645 case TYPE_FLOAT_2: 1646 case TYPE_FLOATN_2: 1647 params[1] = ((GLfloat *) p)[1]; 1648 case TYPE_FLOAT: 1649 case TYPE_FLOATN: 1650 params[0] = ((GLfloat *) p)[0]; 1651 break; 1652 1653 case TYPE_DOUBLEN_2: 1654 params[1] = ((GLdouble *) p)[1]; 1655 case TYPE_DOUBLEN: 1656 params[0] = ((GLdouble *) p)[0]; 1657 break; 1658 1659 case TYPE_INT_4: 1660 params[3] = ((GLint *) p)[3]; 1661 case TYPE_INT_3: 1662 params[2] = ((GLint *) p)[2]; 1663 case TYPE_INT_2: 1664 case TYPE_ENUM_2: 1665 params[1] = ((GLint *) p)[1]; 1666 case TYPE_INT: 1667 case TYPE_ENUM: 1668 params[0] = ((GLint *) p)[0]; 1669 break; 1670 1671 case TYPE_INT_N: 1672 for (i = 0; i < v.value_int_n.n; i++) 1673 params[i] = v.value_int_n.ints[i]; 1674 break; 1675 1676 case TYPE_INT64: 1677 params[0] = (GLdouble) (((GLint64 *) p)[0]); 1678 break; 1679 1680 case TYPE_BOOLEAN: 1681 params[0] = *(GLboolean*) p; 1682 break; 1683 1684 case TYPE_MATRIX: 1685 m = *(GLmatrix **) p; 1686 for (i = 0; i < 16; i++) 1687 params[i] = m->m[i]; 1688 break; 1689 1690 case TYPE_MATRIX_T: 1691 m = *(GLmatrix **) p; 1692 for (i = 0; i < 16; i++) 1693 params[i] = m->m[transpose[i]]; 1694 break; 1695 1696 case TYPE_BIT_0: 1697 case TYPE_BIT_1: 1698 case TYPE_BIT_2: 1699 case TYPE_BIT_3: 1700 case TYPE_BIT_4: 1701 case TYPE_BIT_5: 1702 case TYPE_BIT_6: 1703 case TYPE_BIT_7: 1704 shift = d->type - TYPE_BIT_0; 1705 params[0] = (*(GLbitfield *) p >> shift) & 1; 1706 break; 1707 } 1708} 1709 1710static enum value_type 1711find_value_indexed(const char *func, GLenum pname, GLuint index, union value *v) 1712{ 1713 GET_CURRENT_CONTEXT(ctx); 1714 1715 switch (pname) { 1716 1717 case GL_BLEND: 1718 if (index >= ctx->Const.MaxDrawBuffers) 1719 goto invalid_value; 1720 if (!ctx->Extensions.EXT_draw_buffers2) 1721 goto invalid_enum; 1722 v->value_int = (ctx->Color.BlendEnabled >> index) & 1; 1723 return TYPE_INT; 1724 1725 case GL_BLEND_SRC: 1726 /* fall-through */ 1727 case GL_BLEND_SRC_RGB: 1728 if (index >= ctx->Const.MaxDrawBuffers) 1729 goto invalid_value; 1730 if (!ctx->Extensions.ARB_draw_buffers_blend) 1731 goto invalid_enum; 1732 v->value_int = ctx->Color.Blend[index].SrcRGB; 1733 return TYPE_INT; 1734 case GL_BLEND_SRC_ALPHA: 1735 if (index >= ctx->Const.MaxDrawBuffers) 1736 goto invalid_value; 1737 if (!ctx->Extensions.ARB_draw_buffers_blend) 1738 goto invalid_enum; 1739 v->value_int = ctx->Color.Blend[index].SrcA; 1740 return TYPE_INT; 1741 case GL_BLEND_DST: 1742 /* fall-through */ 1743 case GL_BLEND_DST_RGB: 1744 if (index >= ctx->Const.MaxDrawBuffers) 1745 goto invalid_value; 1746 if (!ctx->Extensions.ARB_draw_buffers_blend) 1747 goto invalid_enum; 1748 v->value_int = ctx->Color.Blend[index].DstRGB; 1749 return TYPE_INT; 1750 case GL_BLEND_DST_ALPHA: 1751 if (index >= ctx->Const.MaxDrawBuffers) 1752 goto invalid_value; 1753 if (!ctx->Extensions.ARB_draw_buffers_blend) 1754 goto invalid_enum; 1755 v->value_int = ctx->Color.Blend[index].DstA; 1756 return TYPE_INT; 1757 case GL_BLEND_EQUATION_RGB: 1758 if (index >= ctx->Const.MaxDrawBuffers) 1759 goto invalid_value; 1760 if (!ctx->Extensions.ARB_draw_buffers_blend) 1761 goto invalid_enum; 1762 v->value_int = ctx->Color.Blend[index].EquationRGB; 1763 return TYPE_INT; 1764 case GL_BLEND_EQUATION_ALPHA: 1765 if (index >= ctx->Const.MaxDrawBuffers) 1766 goto invalid_value; 1767 if (!ctx->Extensions.ARB_draw_buffers_blend) 1768 goto invalid_enum; 1769 v->value_int = ctx->Color.Blend[index].EquationA; 1770 return TYPE_INT; 1771 1772 case GL_COLOR_WRITEMASK: 1773 if (index >= ctx->Const.MaxDrawBuffers) 1774 goto invalid_value; 1775 if (!ctx->Extensions.EXT_draw_buffers2) 1776 goto invalid_enum; 1777 v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0; 1778 v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0; 1779 v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0; 1780 v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0; 1781 return TYPE_INT_4; 1782 1783 case GL_SCISSOR_BOX: 1784 if (index >= ctx->Const.MaxViewports) 1785 goto invalid_value; 1786 v->value_int_4[0] = ctx->Scissor.ScissorArray[index].X; 1787 v->value_int_4[1] = ctx->Scissor.ScissorArray[index].Y; 1788 v->value_int_4[2] = ctx->Scissor.ScissorArray[index].Width; 1789 v->value_int_4[3] = ctx->Scissor.ScissorArray[index].Height; 1790 return TYPE_INT_4; 1791 1792 case GL_VIEWPORT: 1793 if (index >= ctx->Const.MaxViewports) 1794 goto invalid_value; 1795 v->value_float_4[0] = ctx->ViewportArray[index].X; 1796 v->value_float_4[1] = ctx->ViewportArray[index].Y; 1797 v->value_float_4[2] = ctx->ViewportArray[index].Width; 1798 v->value_float_4[3] = ctx->ViewportArray[index].Height; 1799 return TYPE_FLOAT_4; 1800 1801 case GL_DEPTH_RANGE: 1802 if (index >= ctx->Const.MaxViewports) 1803 goto invalid_value; 1804 v->value_double_2[0] = ctx->ViewportArray[index].Near; 1805 v->value_double_2[1] = ctx->ViewportArray[index].Far; 1806 return TYPE_DOUBLEN_2; 1807 1808 case GL_TRANSFORM_FEEDBACK_BUFFER_START: 1809 if (index >= ctx->Const.MaxTransformFeedbackBuffers) 1810 goto invalid_value; 1811 if (!ctx->Extensions.EXT_transform_feedback) 1812 goto invalid_enum; 1813 v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index]; 1814 return TYPE_INT64; 1815 1816 case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE: 1817 if (index >= ctx->Const.MaxTransformFeedbackBuffers) 1818 goto invalid_value; 1819 if (!ctx->Extensions.EXT_transform_feedback) 1820 goto invalid_enum; 1821 v->value_int64 1822 = ctx->TransformFeedback.CurrentObject->RequestedSize[index]; 1823 return TYPE_INT64; 1824 1825 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING: 1826 if (index >= ctx->Const.MaxTransformFeedbackBuffers) 1827 goto invalid_value; 1828 if (!ctx->Extensions.EXT_transform_feedback) 1829 goto invalid_enum; 1830 v->value_int = ctx->TransformFeedback.CurrentObject->BufferNames[index]; 1831 return TYPE_INT; 1832 1833 case GL_UNIFORM_BUFFER_BINDING: 1834 if (index >= ctx->Const.MaxUniformBufferBindings) 1835 goto invalid_value; 1836 if (!ctx->Extensions.ARB_uniform_buffer_object) 1837 goto invalid_enum; 1838 v->value_int = ctx->UniformBufferBindings[index].BufferObject->Name; 1839 return TYPE_INT; 1840 1841 case GL_UNIFORM_BUFFER_START: 1842 if (index >= ctx->Const.MaxUniformBufferBindings) 1843 goto invalid_value; 1844 if (!ctx->Extensions.ARB_uniform_buffer_object) 1845 goto invalid_enum; 1846 v->value_int = ctx->UniformBufferBindings[index].Offset; 1847 return TYPE_INT; 1848 1849 case GL_UNIFORM_BUFFER_SIZE: 1850 if (index >= ctx->Const.MaxUniformBufferBindings) 1851 goto invalid_value; 1852 if (!ctx->Extensions.ARB_uniform_buffer_object) 1853 goto invalid_enum; 1854 v->value_int = ctx->UniformBufferBindings[index].Size; 1855 return TYPE_INT; 1856 1857 /* ARB_texture_multisample / GL3.2 */ 1858 case GL_SAMPLE_MASK_VALUE: 1859 if (index != 0) 1860 goto invalid_value; 1861 if (!ctx->Extensions.ARB_texture_multisample) 1862 goto invalid_enum; 1863 v->value_int = ctx->Multisample.SampleMaskValue; 1864 return TYPE_INT; 1865 1866 case GL_ATOMIC_COUNTER_BUFFER_BINDING: 1867 if (!ctx->Extensions.ARB_shader_atomic_counters) 1868 goto invalid_enum; 1869 if (index >= ctx->Const.MaxAtomicBufferBindings) 1870 goto invalid_value; 1871 v->value_int = ctx->AtomicBufferBindings[index].BufferObject->Name; 1872 return TYPE_INT; 1873 1874 case GL_ATOMIC_COUNTER_BUFFER_START: 1875 if (!ctx->Extensions.ARB_shader_atomic_counters) 1876 goto invalid_enum; 1877 if (index >= ctx->Const.MaxAtomicBufferBindings) 1878 goto invalid_value; 1879 v->value_int64 = ctx->AtomicBufferBindings[index].Offset; 1880 return TYPE_INT64; 1881 1882 case GL_ATOMIC_COUNTER_BUFFER_SIZE: 1883 if (!ctx->Extensions.ARB_shader_atomic_counters) 1884 goto invalid_enum; 1885 if (index >= ctx->Const.MaxAtomicBufferBindings) 1886 goto invalid_value; 1887 v->value_int64 = ctx->AtomicBufferBindings[index].Size; 1888 return TYPE_INT64; 1889 1890 case GL_VERTEX_BINDING_DIVISOR: 1891 if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_instanced_arrays) 1892 goto invalid_enum; 1893 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) 1894 goto invalid_value; 1895 v->value_int = ctx->Array.VAO->VertexBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor; 1896 return TYPE_INT; 1897 1898 case GL_VERTEX_BINDING_OFFSET: 1899 if (!_mesa_is_desktop_gl(ctx)) 1900 goto invalid_enum; 1901 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) 1902 goto invalid_value; 1903 v->value_int = ctx->Array.VAO->VertexBinding[VERT_ATTRIB_GENERIC(index)].Offset; 1904 return TYPE_INT; 1905 1906 case GL_VERTEX_BINDING_STRIDE: 1907 if (!_mesa_is_desktop_gl(ctx)) 1908 goto invalid_enum; 1909 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) 1910 goto invalid_value; 1911 v->value_int = ctx->Array.VAO->VertexBinding[VERT_ATTRIB_GENERIC(index)].Stride; 1912 1913 /* ARB_shader_image_load_store */ 1914 case GL_IMAGE_BINDING_NAME: { 1915 struct gl_texture_object *t; 1916 1917 if (!ctx->Extensions.ARB_shader_image_load_store) 1918 goto invalid_enum; 1919 if (index >= ctx->Const.MaxImageUnits) 1920 goto invalid_value; 1921 1922 t = ctx->ImageUnits[index].TexObj; 1923 v->value_int = (t ? t->Name : 0); 1924 return TYPE_INT; 1925 } 1926 1927 case GL_IMAGE_BINDING_LEVEL: 1928 if (!ctx->Extensions.ARB_shader_image_load_store) 1929 goto invalid_enum; 1930 if (index >= ctx->Const.MaxImageUnits) 1931 goto invalid_value; 1932 1933 v->value_int = ctx->ImageUnits[index].Level; 1934 return TYPE_INT; 1935 1936 case GL_IMAGE_BINDING_LAYERED: 1937 if (!ctx->Extensions.ARB_shader_image_load_store) 1938 goto invalid_enum; 1939 if (index >= ctx->Const.MaxImageUnits) 1940 goto invalid_value; 1941 1942 v->value_int = ctx->ImageUnits[index].Layered; 1943 return TYPE_INT; 1944 1945 case GL_IMAGE_BINDING_LAYER: 1946 if (!ctx->Extensions.ARB_shader_image_load_store) 1947 goto invalid_enum; 1948 if (index >= ctx->Const.MaxImageUnits) 1949 goto invalid_value; 1950 1951 v->value_int = ctx->ImageUnits[index].Layer; 1952 return TYPE_INT; 1953 1954 case GL_IMAGE_BINDING_ACCESS: 1955 if (!ctx->Extensions.ARB_shader_image_load_store) 1956 goto invalid_enum; 1957 if (index >= ctx->Const.MaxImageUnits) 1958 goto invalid_value; 1959 1960 v->value_int = ctx->ImageUnits[index].Access; 1961 return TYPE_INT; 1962 1963 case GL_IMAGE_BINDING_FORMAT: 1964 if (!ctx->Extensions.ARB_shader_image_load_store) 1965 goto invalid_enum; 1966 if (index >= ctx->Const.MaxImageUnits) 1967 goto invalid_value; 1968 1969 v->value_int = ctx->ImageUnits[index].Format; 1970 return TYPE_INT; 1971 1972 case GL_MAX_COMPUTE_WORK_GROUP_COUNT: 1973 if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_compute_shader) 1974 goto invalid_enum; 1975 if (index >= 3) 1976 goto invalid_value; 1977 v->value_int = ctx->Const.MaxComputeWorkGroupCount[index]; 1978 return TYPE_INT; 1979 1980 case GL_MAX_COMPUTE_WORK_GROUP_SIZE: 1981 if (!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_compute_shader) 1982 goto invalid_enum; 1983 if (index >= 3) 1984 goto invalid_value; 1985 v->value_int = ctx->Const.MaxComputeWorkGroupSize[index]; 1986 return TYPE_INT; 1987 } 1988 1989 invalid_enum: 1990 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func, 1991 _mesa_lookup_enum_by_nr(pname)); 1992 return TYPE_INVALID; 1993 invalid_value: 1994 _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func, 1995 _mesa_lookup_enum_by_nr(pname)); 1996 return TYPE_INVALID; 1997} 1998 1999void GLAPIENTRY 2000_mesa_GetBooleani_v( GLenum pname, GLuint index, GLboolean *params ) 2001{ 2002 union value v; 2003 enum value_type type = 2004 find_value_indexed("glGetBooleani_v", pname, index, &v); 2005 2006 switch (type) { 2007 case TYPE_INT: 2008 params[0] = INT_TO_BOOLEAN(v.value_int); 2009 break; 2010 case TYPE_INT_4: 2011 params[0] = INT_TO_BOOLEAN(v.value_int_4[0]); 2012 params[1] = INT_TO_BOOLEAN(v.value_int_4[1]); 2013 params[2] = INT_TO_BOOLEAN(v.value_int_4[2]); 2014 params[3] = INT_TO_BOOLEAN(v.value_int_4[3]); 2015 break; 2016 case TYPE_INT64: 2017 params[0] = INT64_TO_BOOLEAN(v.value_int64); 2018 break; 2019 default: 2020 ; /* nothing - GL error was recorded */ 2021 } 2022} 2023 2024void GLAPIENTRY 2025_mesa_GetIntegeri_v( GLenum pname, GLuint index, GLint *params ) 2026{ 2027 union value v; 2028 enum value_type type = 2029 find_value_indexed("glGetIntegeri_v", pname, index, &v); 2030 2031 switch (type) { 2032 case TYPE_FLOAT_4: 2033 case TYPE_FLOATN_4: 2034 params[3] = IROUND(v.value_float_4[3]); 2035 case TYPE_FLOAT_3: 2036 case TYPE_FLOATN_3: 2037 params[2] = IROUND(v.value_float_4[2]); 2038 case TYPE_FLOAT_2: 2039 case TYPE_FLOATN_2: 2040 params[1] = IROUND(v.value_float_4[1]); 2041 case TYPE_FLOAT: 2042 case TYPE_FLOATN: 2043 params[0] = IROUND(v.value_float_4[0]); 2044 break; 2045 2046 case TYPE_DOUBLEN_2: 2047 params[1] = IROUND(v.value_double_2[1]); 2048 case TYPE_DOUBLEN: 2049 params[0] = IROUND(v.value_double_2[0]); 2050 break; 2051 2052 case TYPE_INT: 2053 params[0] = v.value_int; 2054 break; 2055 case TYPE_INT_4: 2056 params[0] = v.value_int_4[0]; 2057 params[1] = v.value_int_4[1]; 2058 params[2] = v.value_int_4[2]; 2059 params[3] = v.value_int_4[3]; 2060 break; 2061 case TYPE_INT64: 2062 params[0] = INT64_TO_INT(v.value_int64); 2063 break; 2064 default: 2065 ; /* nothing - GL error was recorded */ 2066 } 2067} 2068 2069void GLAPIENTRY 2070_mesa_GetInteger64i_v( GLenum pname, GLuint index, GLint64 *params ) 2071{ 2072 union value v; 2073 enum value_type type = 2074 find_value_indexed("glGetInteger64i_v", pname, index, &v); 2075 2076 switch (type) { 2077 case TYPE_INT: 2078 params[0] = v.value_int; 2079 break; 2080 case TYPE_INT_4: 2081 params[0] = v.value_int_4[0]; 2082 params[1] = v.value_int_4[1]; 2083 params[2] = v.value_int_4[2]; 2084 params[3] = v.value_int_4[3]; 2085 break; 2086 case TYPE_INT64: 2087 params[0] = v.value_int64; 2088 break; 2089 default: 2090 ; /* nothing - GL error was recorded */ 2091 } 2092} 2093 2094void GLAPIENTRY 2095_mesa_GetFloati_v(GLenum pname, GLuint index, GLfloat *params) 2096{ 2097 int i; 2098 GLmatrix *m; 2099 union value v; 2100 enum value_type type = 2101 find_value_indexed("glGetFloati_v", pname, index, &v); 2102 2103 switch (type) { 2104 case TYPE_FLOAT_4: 2105 case TYPE_FLOATN_4: 2106 params[3] = v.value_float_4[3]; 2107 case TYPE_FLOAT_3: 2108 case TYPE_FLOATN_3: 2109 params[2] = v.value_float_4[2]; 2110 case TYPE_FLOAT_2: 2111 case TYPE_FLOATN_2: 2112 params[1] = v.value_float_4[1]; 2113 case TYPE_FLOAT: 2114 case TYPE_FLOATN: 2115 params[0] = v.value_float_4[0]; 2116 break; 2117 2118 case TYPE_DOUBLEN_2: 2119 params[1] = (GLfloat) v.value_double_2[1]; 2120 case TYPE_DOUBLEN: 2121 params[0] = (GLfloat) v.value_double_2[0]; 2122 break; 2123 2124 case TYPE_INT_4: 2125 params[3] = (GLfloat) v.value_int_4[3]; 2126 case TYPE_INT_3: 2127 params[2] = (GLfloat) v.value_int_4[2]; 2128 case TYPE_INT_2: 2129 case TYPE_ENUM_2: 2130 params[1] = (GLfloat) v.value_int_4[1]; 2131 case TYPE_INT: 2132 case TYPE_ENUM: 2133 params[0] = (GLfloat) v.value_int_4[0]; 2134 break; 2135 2136 case TYPE_INT_N: 2137 for (i = 0; i < v.value_int_n.n; i++) 2138 params[i] = INT_TO_FLOAT(v.value_int_n.ints[i]); 2139 break; 2140 2141 case TYPE_INT64: 2142 params[0] = (GLfloat) v.value_int64; 2143 break; 2144 2145 case TYPE_BOOLEAN: 2146 params[0] = BOOLEAN_TO_FLOAT(v.value_bool); 2147 break; 2148 2149 case TYPE_MATRIX: 2150 m = *(GLmatrix **) &v; 2151 for (i = 0; i < 16; i++) 2152 params[i] = m->m[i]; 2153 break; 2154 2155 case TYPE_MATRIX_T: 2156 m = *(GLmatrix **) &v; 2157 for (i = 0; i < 16; i++) 2158 params[i] = m->m[transpose[i]]; 2159 break; 2160 2161 default: 2162 ; 2163 } 2164} 2165 2166void GLAPIENTRY 2167_mesa_GetDoublei_v(GLenum pname, GLuint index, GLdouble *params) 2168{ 2169 int i; 2170 GLmatrix *m; 2171 union value v; 2172 enum value_type type = 2173 find_value_indexed("glGetDoublei_v", pname, index, &v); 2174 2175 switch (type) { 2176 case TYPE_FLOAT_4: 2177 case TYPE_FLOATN_4: 2178 params[3] = (GLdouble) v.value_float_4[3]; 2179 case TYPE_FLOAT_3: 2180 case TYPE_FLOATN_3: 2181 params[2] = (GLdouble) v.value_float_4[2]; 2182 case TYPE_FLOAT_2: 2183 case TYPE_FLOATN_2: 2184 params[1] = (GLdouble) v.value_float_4[1]; 2185 case TYPE_FLOAT: 2186 case TYPE_FLOATN: 2187 params[0] = (GLdouble) v.value_float_4[0]; 2188 break; 2189 2190 case TYPE_DOUBLEN_2: 2191 params[1] = v.value_double_2[1]; 2192 case TYPE_DOUBLEN: 2193 params[0] = v.value_double_2[0]; 2194 break; 2195 2196 case TYPE_INT_4: 2197 params[3] = (GLdouble) v.value_int_4[3]; 2198 case TYPE_INT_3: 2199 params[2] = (GLdouble) v.value_int_4[2]; 2200 case TYPE_INT_2: 2201 case TYPE_ENUM_2: 2202 params[1] = (GLdouble) v.value_int_4[1]; 2203 case TYPE_INT: 2204 case TYPE_ENUM: 2205 params[0] = (GLdouble) v.value_int_4[0]; 2206 break; 2207 2208 case TYPE_INT_N: 2209 for (i = 0; i < v.value_int_n.n; i++) 2210 params[i] = (GLdouble) INT_TO_FLOAT(v.value_int_n.ints[i]); 2211 break; 2212 2213 case TYPE_INT64: 2214 params[0] = (GLdouble) v.value_int64; 2215 break; 2216 2217 case TYPE_BOOLEAN: 2218 params[0] = (GLdouble) BOOLEAN_TO_FLOAT(v.value_bool); 2219 break; 2220 2221 case TYPE_MATRIX: 2222 m = *(GLmatrix **) &v; 2223 for (i = 0; i < 16; i++) 2224 params[i] = (GLdouble) m->m[i]; 2225 break; 2226 2227 case TYPE_MATRIX_T: 2228 m = *(GLmatrix **) &v; 2229 for (i = 0; i < 16; i++) 2230 params[i] = (GLdouble) m->m[transpose[i]]; 2231 break; 2232 2233 default: 2234 ; 2235 } 2236} 2237 2238void GLAPIENTRY 2239_mesa_GetFixedv(GLenum pname, GLfixed *params) 2240{ 2241 const struct value_desc *d; 2242 union value v; 2243 GLmatrix *m; 2244 int shift, i; 2245 void *p; 2246 2247 d = find_value("glGetDoublev", pname, &p, &v); 2248 switch (d->type) { 2249 case TYPE_INVALID: 2250 break; 2251 case TYPE_CONST: 2252 params[0] = INT_TO_FIXED(d->offset); 2253 break; 2254 2255 case TYPE_FLOAT_4: 2256 case TYPE_FLOATN_4: 2257 params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]); 2258 case TYPE_FLOAT_3: 2259 case TYPE_FLOATN_3: 2260 params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]); 2261 case TYPE_FLOAT_2: 2262 case TYPE_FLOATN_2: 2263 params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]); 2264 case TYPE_FLOAT: 2265 case TYPE_FLOATN: 2266 params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]); 2267 break; 2268 2269 case TYPE_DOUBLEN_2: 2270 params[1] = FLOAT_TO_FIXED(((GLdouble *) p)[1]); 2271 case TYPE_DOUBLEN: 2272 params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]); 2273 break; 2274 2275 case TYPE_INT_4: 2276 params[3] = INT_TO_FIXED(((GLint *) p)[3]); 2277 case TYPE_INT_3: 2278 params[2] = INT_TO_FIXED(((GLint *) p)[2]); 2279 case TYPE_INT_2: 2280 case TYPE_ENUM_2: 2281 params[1] = INT_TO_FIXED(((GLint *) p)[1]); 2282 case TYPE_INT: 2283 case TYPE_ENUM: 2284 params[0] = INT_TO_FIXED(((GLint *) p)[0]); 2285 break; 2286 2287 case TYPE_INT_N: 2288 for (i = 0; i < v.value_int_n.n; i++) 2289 params[i] = INT_TO_FIXED(v.value_int_n.ints[i]); 2290 break; 2291 2292 case TYPE_INT64: 2293 params[0] = ((GLint64 *) p)[0]; 2294 break; 2295 2296 case TYPE_BOOLEAN: 2297 params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]); 2298 break; 2299 2300 case TYPE_MATRIX: 2301 m = *(GLmatrix **) p; 2302 for (i = 0; i < 16; i++) 2303 params[i] = FLOAT_TO_FIXED(m->m[i]); 2304 break; 2305 2306 case TYPE_MATRIX_T: 2307 m = *(GLmatrix **) p; 2308 for (i = 0; i < 16; i++) 2309 params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]); 2310 break; 2311 2312 case TYPE_BIT_0: 2313 case TYPE_BIT_1: 2314 case TYPE_BIT_2: 2315 case TYPE_BIT_3: 2316 case TYPE_BIT_4: 2317 case TYPE_BIT_5: 2318 case TYPE_BIT_6: 2319 case TYPE_BIT_7: 2320 shift = d->type - TYPE_BIT_0; 2321 params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1); 2322 break; 2323 } 2324} 2325