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