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 "util/glheader.h"
27 #include "context.h"
28 #include "blend.h"
29 #include "debug_output.h"
30 #include "enable.h"
31 #include "enums.h"
32 #include "errors.h"
33 #include "extensions.h"
34 #include "get.h"
35 #include "macros.h"
36 #include "multisample.h"
37 #include "mtypes.h"
38 #include "queryobj.h"
39 #include "spirv_extensions.h"
40 #include "state.h"
41 #include "texcompress.h"
42 #include "texstate.h"
43 #include "framebuffer.h"
44 #include "samplerobj.h"
45 #include "stencil.h"
46 #include "version.h"
47
48 #include "state_tracker/st_context.h"
49 #include "api_exec_decl.h"
50
51 /* This is a table driven implemetation of the glGet*v() functions.
52 * The basic idea is that most getters just look up an int somewhere
53 * in struct gl_context and then convert it to a bool or float according to
54 * which of glGetIntegerv() glGetBooleanv() etc is being called.
55 * Instead of generating code to do this, we can just record the enum
56 * value and the offset into struct gl_context in an array of structs. Then
57 * in glGet*(), we lookup the struct for the enum in question, and use
58 * the offset to get the int we need.
59 *
60 * Sometimes we need to look up a float, a boolean, a bit in a
61 * bitfield, a matrix or other types instead, so we need to track the
62 * type of the value in struct gl_context. And sometimes the value isn't in
63 * struct gl_context but in the drawbuffer, the array object, current texture
64 * unit, or maybe it's a computed value. So we need to also track
65 * where or how to find the value. Finally, we sometimes need to
66 * check that one of a number of extensions are enabled, the GL
67 * version or flush or call _mesa_update_state(). This is done by
68 * attaching optional extra information to the value description
69 * struct, it's sort of like an array of opcodes that describe extra
70 * checks or actions.
71 *
72 * Putting all this together we end up with struct value_desc below,
73 * and with a couple of macros to help, the table of struct value_desc
74 * is about as concise as the specification in the old python script.
75 */
76
77 static inline GLboolean
FLOAT_TO_BOOLEAN(GLfloat X)78 FLOAT_TO_BOOLEAN(GLfloat X)
79 {
80 return ( (X) ? GL_TRUE : GL_FALSE );
81 }
82
83 static inline GLint
FLOAT_TO_FIXED(GLfloat F)84 FLOAT_TO_FIXED(GLfloat F)
85 {
86 return ( ((F) * 65536.0f > (float)INT32_MAX) ? INT32_MAX :
87 ((F) * 65536.0f < (float)INT32_MIN) ? INT32_MIN :
88 (GLint) ((F) * 65536.0f) );
89 }
90
91 static inline GLboolean
INT_TO_BOOLEAN(GLint I)92 INT_TO_BOOLEAN(GLint I)
93 {
94 return ( (I) ? GL_TRUE : GL_FALSE );
95 }
96
97 static inline GLfixed
INT_TO_FIXED(GLint I)98 INT_TO_FIXED(GLint I)
99 {
100 return (((I) > SHRT_MAX) ? INT_MAX :
101 ((I) < SHRT_MIN) ? INT_MIN :
102 (GLint) ((I) * 65536) );
103 }
104
105
106 static inline GLboolean
INT64_TO_BOOLEAN(GLint64 I)107 INT64_TO_BOOLEAN(GLint64 I)
108 {
109 return ( (I) ? GL_TRUE : GL_FALSE );
110 }
111
112 static inline GLint
INT64_TO_INT(GLint64 I)113 INT64_TO_INT(GLint64 I)
114 {
115 return ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) );
116 }
117
118 static inline GLint
BOOLEAN_TO_INT(GLboolean B)119 BOOLEAN_TO_INT(GLboolean B)
120 {
121 return ( (GLint) (B) );
122 }
123
124 static inline GLfloat
BOOLEAN_TO_FLOAT(GLboolean B)125 BOOLEAN_TO_FLOAT(GLboolean B)
126 {
127 return ( (B) ? 1.0F : 0.0F );
128 }
129
130 static inline GLfixed
BOOLEAN_TO_FIXED(GLboolean B)131 BOOLEAN_TO_FIXED(GLboolean B)
132 {
133 return ( (GLint) ((B) ? 1 : 0) << 16 );
134 }
135
136 enum value_type {
137 TYPE_INVALID,
138 TYPE_INT,
139 TYPE_INT_2,
140 TYPE_INT_3,
141 TYPE_INT_4,
142 TYPE_INT_N,
143 TYPE_UINT,
144 TYPE_UINT_2,
145 TYPE_UINT_3,
146 TYPE_UINT_4,
147 TYPE_INT64,
148 TYPE_ENUM16,
149 TYPE_ENUM,
150 TYPE_ENUM_2,
151 TYPE_BOOLEAN,
152 TYPE_UBYTE,
153 TYPE_SHORT,
154 TYPE_BIT_0,
155 TYPE_BIT_1,
156 TYPE_BIT_2,
157 TYPE_BIT_3,
158 TYPE_BIT_4,
159 TYPE_BIT_5,
160 TYPE_BIT_6,
161 TYPE_BIT_7,
162 TYPE_FLOAT,
163 TYPE_FLOAT_2,
164 TYPE_FLOAT_3,
165 TYPE_FLOAT_4,
166 TYPE_FLOAT_8,
167 TYPE_FLOATN,
168 TYPE_FLOATN_2,
169 TYPE_FLOATN_3,
170 TYPE_FLOATN_4,
171 TYPE_DOUBLEN,
172 TYPE_DOUBLEN_2,
173 TYPE_MATRIX,
174 TYPE_MATRIX_T,
175 TYPE_CONST
176 };
177
178 enum value_location {
179 LOC_BUFFER,
180 LOC_CONTEXT,
181 LOC_ARRAY,
182 LOC_TEXUNIT,
183 LOC_CUSTOM
184 };
185
186 enum value_extra {
187 EXTRA_END = 0x8000,
188 EXTRA_VERSION_30,
189 EXTRA_VERSION_31,
190 EXTRA_VERSION_32,
191 EXTRA_VERSION_40,
192 EXTRA_VERSION_43,
193 EXTRA_API_GL,
194 EXTRA_API_GL_CORE,
195 EXTRA_API_GL_COMPAT,
196 EXTRA_API_ES,
197 EXTRA_API_ES2,
198 EXTRA_API_ES3,
199 EXTRA_API_ES31,
200 EXTRA_API_ES32,
201 EXTRA_NEW_BUFFERS,
202 EXTRA_VALID_DRAW_BUFFER,
203 EXTRA_VALID_TEXTURE_UNIT,
204 EXTRA_VALID_CLIP_DISTANCE,
205 EXTRA_FLUSH_CURRENT,
206 EXTRA_GLSL_130,
207 EXTRA_EXT_UBO_GS,
208 EXTRA_EXT_ATOMICS_GS,
209 EXTRA_EXT_SHADER_IMAGE_GS,
210 EXTRA_EXT_ATOMICS_TESS,
211 EXTRA_EXT_SHADER_IMAGE_TESS,
212 EXTRA_EXT_SSBO_GS,
213 EXTRA_EXT_FB_NO_ATTACH_GS,
214 EXTRA_EXT_ES_GS,
215 EXTRA_EXT_PROVOKING_VERTEX_32,
216 };
217
218 #define NO_EXTRA NULL
219 #define NO_OFFSET 0
220
221 struct value_desc {
222 GLenum pname;
223 GLubyte location; /**< enum value_location */
224 GLubyte type; /**< enum value_type */
225 int offset;
226 const int *extra;
227 };
228
229 union value {
230 GLfloat value_float;
231 GLfloat value_float_4[4];
232 GLdouble value_double_2[2];
233 GLmatrix *value_matrix;
234 GLint value_int;
235 GLint value_int_2[2];
236 GLint value_int_4[4];
237 GLint64 value_int64;
238 GLenum value_enum;
239 GLenum16 value_enum16;
240 GLubyte value_ubyte;
241 GLshort value_short;
242 GLuint value_uint;
243
244 /* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */
245 struct {
246 GLint n, ints[100];
247 } value_int_n;
248 GLboolean value_bool;
249 };
250
251 #define BUFFER_FIELD(field, type) \
252 LOC_BUFFER, type, offsetof(struct gl_framebuffer, field)
253 #define CONTEXT_FIELD(field, type) \
254 LOC_CONTEXT, type, offsetof(struct gl_context, field)
255 #define ARRAY_FIELD(field, type) \
256 LOC_ARRAY, type, offsetof(struct gl_vertex_array_object, field)
257 #undef CONST /* already defined through windows.h */
258 #define CONST(value) \
259 LOC_CONTEXT, TYPE_CONST, value
260
261 #define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)
262 #define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)
263 #define BUFFER_ENUM16(field) BUFFER_FIELD(field, TYPE_ENUM16)
264 #define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)
265
266 #define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)
267 #define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)
268 #define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)
269 #define CONTEXT_UINT(field) CONTEXT_FIELD(field, TYPE_UINT)
270 #define CONTEXT_ENUM16(field) CONTEXT_FIELD(field, TYPE_ENUM16)
271 #define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)
272 #define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)
273 #define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)
274 #define CONTEXT_BIT0(field) CONTEXT_FIELD(field, TYPE_BIT_0)
275 #define CONTEXT_BIT1(field) CONTEXT_FIELD(field, TYPE_BIT_1)
276 #define CONTEXT_BIT2(field) CONTEXT_FIELD(field, TYPE_BIT_2)
277 #define CONTEXT_BIT3(field) CONTEXT_FIELD(field, TYPE_BIT_3)
278 #define CONTEXT_BIT4(field) CONTEXT_FIELD(field, TYPE_BIT_4)
279 #define CONTEXT_BIT5(field) CONTEXT_FIELD(field, TYPE_BIT_5)
280 #define CONTEXT_BIT6(field) CONTEXT_FIELD(field, TYPE_BIT_6)
281 #define CONTEXT_BIT7(field) CONTEXT_FIELD(field, TYPE_BIT_7)
282 #define CONTEXT_FLOAT(field) CONTEXT_FIELD(field, TYPE_FLOAT)
283 #define CONTEXT_FLOAT2(field) CONTEXT_FIELD(field, TYPE_FLOAT_2)
284 #define CONTEXT_FLOAT3(field) CONTEXT_FIELD(field, TYPE_FLOAT_3)
285 #define CONTEXT_FLOAT4(field) CONTEXT_FIELD(field, TYPE_FLOAT_4)
286 #define CONTEXT_FLOAT8(field) CONTEXT_FIELD(field, TYPE_FLOAT_8)
287 #define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)
288 #define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)
289
290 /* Vertex array fields */
291 #define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)
292 #define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)
293 #define ARRAY_ENUM16(field) ARRAY_FIELD(field, TYPE_ENUM16)
294 #define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)
295 #define ARRAY_UBYTE(field) ARRAY_FIELD(field, TYPE_UBYTE)
296 #define ARRAY_SHORT(field) ARRAY_FIELD(field, TYPE_SHORT)
297
298 #define EXT(f) \
299 offsetof(struct gl_extensions, f)
300
301 #define EXTRA_EXT(e) \
302 static const int extra_##e[] = { \
303 EXT(e), EXTRA_END \
304 }
305
306 #define EXTRA_EXT2(e1, e2) \
307 static const int extra_##e1##_##e2[] = { \
308 EXT(e1), EXT(e2), EXTRA_END \
309 }
310
311 /* The 'extra' mechanism is a way to specify extra checks (such as
312 * extensions or specific gl versions) or actions (flush current, new
313 * buffers) that we need to do before looking up an enum. We need to
314 * declare them all up front so we can refer to them in the value_desc
315 * structs below.
316 *
317 * Each EXTRA_ will be executed. For EXTRA_* enums of extensions and API
318 * versions, listing multiple ones in an array means an error will be thrown
319 * only if none of them are available. If you need to check for "AND"
320 * behavior, you would need to make a custom EXTRA_ enum.
321 */
322
323 static const int extra_new_buffers_compat_es[] = {
324 EXTRA_API_GL_COMPAT,
325 EXTRA_API_ES,
326 EXTRA_NEW_BUFFERS,
327 EXTRA_END
328 };
329
330 static const int extra_new_buffers[] = {
331 EXTRA_NEW_BUFFERS,
332 EXTRA_END
333 };
334
335 static const int extra_valid_draw_buffer[] = {
336 EXTRA_VALID_DRAW_BUFFER,
337 EXTRA_END
338 };
339
340 static const int extra_valid_texture_unit[] = {
341 EXTRA_VALID_TEXTURE_UNIT,
342 EXTRA_END
343 };
344
345 static const int extra_valid_clip_distance[] = {
346 EXTRA_VALID_CLIP_DISTANCE,
347 EXTRA_END
348 };
349
350 static const int extra_flush_current_valid_texture_unit[] = {
351 EXTRA_FLUSH_CURRENT,
352 EXTRA_VALID_TEXTURE_UNIT,
353 EXTRA_END
354 };
355
356 static const int extra_flush_current[] = {
357 EXTRA_FLUSH_CURRENT,
358 EXTRA_END
359 };
360
361 static const int extra_EXT_texture_integer_and_new_buffers[] = {
362 EXT(EXT_texture_integer),
363 EXTRA_NEW_BUFFERS,
364 EXTRA_END
365 };
366
367 static const int extra_GLSL_130_es3_gpushader4[] = {
368 EXTRA_GLSL_130,
369 EXTRA_API_ES3,
370 EXT(EXT_gpu_shader4),
371 EXTRA_END
372 };
373
374 static const int extra_texture_buffer_object[] = {
375 EXT(ARB_texture_buffer_object),
376 EXTRA_END
377 };
378
379 static const int extra_ARB_transform_feedback2_api_es3[] = {
380 EXT(ARB_transform_feedback2),
381 EXTRA_API_ES3,
382 EXTRA_END
383 };
384
385 static const int extra_ARB_uniform_buffer_object_and_geometry_shader[] = {
386 EXTRA_EXT_UBO_GS,
387 EXTRA_END
388 };
389
390 static const int extra_ARB_ES2_compatibility_api_es2[] = {
391 EXT(ARB_ES2_compatibility),
392 EXTRA_API_ES2,
393 EXTRA_END
394 };
395
396 static const int extra_ARB_ES3_compatibility_api_es3[] = {
397 EXT(ARB_ES3_compatibility),
398 EXTRA_API_ES3,
399 EXTRA_END
400 };
401
402 static const int extra_EXT_framebuffer_sRGB_and_new_buffers[] = {
403 EXT(EXT_framebuffer_sRGB),
404 EXTRA_NEW_BUFFERS,
405 EXTRA_END
406 };
407
408 static const int extra_EXT_packed_float[] = {
409 EXT(EXT_packed_float),
410 EXTRA_NEW_BUFFERS,
411 EXTRA_END
412 };
413
414 static const int extra_EXT_texture_array_es3[] = {
415 EXT(EXT_texture_array),
416 EXTRA_API_ES3,
417 EXTRA_END
418 };
419
420 static const int extra_ARB_shader_atomic_counters_and_geometry_shader[] = {
421 EXTRA_EXT_ATOMICS_GS,
422 EXTRA_END
423 };
424
425 static const int extra_ARB_shader_atomic_counters_es31[] = {
426 EXT(ARB_shader_atomic_counters),
427 EXTRA_API_ES31,
428 EXTRA_END
429 };
430
431 static const int extra_ARB_shader_image_load_store_and_geometry_shader[] = {
432 EXTRA_EXT_SHADER_IMAGE_GS,
433 EXTRA_END
434 };
435
436 static const int extra_ARB_shader_atomic_counters_and_tessellation[] = {
437 EXTRA_EXT_ATOMICS_TESS,
438 EXTRA_END
439 };
440
441 static const int extra_ARB_shader_image_load_store_and_tessellation[] = {
442 EXTRA_EXT_SHADER_IMAGE_TESS,
443 EXTRA_END
444 };
445
446 static const int extra_ARB_shader_image_load_store_es31[] = {
447 EXT(ARB_shader_image_load_store),
448 EXTRA_API_ES31,
449 EXTRA_END
450 };
451
452 /* HACK: remove when ARB_compute_shader is actually supported */
453 static const int extra_ARB_compute_shader_es31[] = {
454 EXT(ARB_compute_shader),
455 EXTRA_API_ES31,
456 EXTRA_END
457 };
458
459 static const int extra_ARB_shader_storage_buffer_object_es31[] = {
460 EXT(ARB_shader_storage_buffer_object),
461 EXTRA_API_ES31,
462 EXTRA_END
463 };
464
465 static const int extra_ARB_shader_storage_buffer_object_and_geometry_shader[] = {
466 EXTRA_EXT_SSBO_GS,
467 EXTRA_END
468 };
469
470 static const int extra_ARB_shader_image_load_store_shader_storage_buffer_object_es31[] = {
471 EXT(ARB_shader_image_load_store),
472 EXT(ARB_shader_storage_buffer_object),
473 EXTRA_API_ES31,
474 EXTRA_END
475 };
476
477 static const int extra_ARB_framebuffer_no_attachments_and_geometry_shader[] = {
478 EXTRA_EXT_FB_NO_ATTACH_GS,
479 EXTRA_END
480 };
481
482 static const int extra_ARB_viewport_array_or_oes_geometry_shader[] = {
483 EXT(ARB_viewport_array),
484 EXTRA_EXT_ES_GS,
485 EXTRA_END
486 };
487
488 static const int extra_ARB_viewport_array_or_oes_viewport_array[] = {
489 EXT(ARB_viewport_array),
490 EXT(OES_viewport_array),
491 EXTRA_END
492 };
493
494 static const int extra_ARB_gpu_shader5_or_oes_geometry_shader[] = {
495 EXT(ARB_gpu_shader5),
496 EXTRA_EXT_ES_GS,
497 EXTRA_END
498 };
499
500 static const int extra_ARB_gpu_shader5_or_OES_sample_variables[] = {
501 EXT(ARB_gpu_shader5),
502 EXT(OES_sample_variables),
503 EXTRA_END
504 };
505
506 static const int extra_ES32[] = {
507 EXT(ARB_ES3_2_compatibility),
508 EXTRA_API_ES32,
509 EXTRA_END
510 };
511
512 static const int extra_KHR_robustness_or_GL[] = {
513 EXT(KHR_robustness),
514 EXTRA_API_GL,
515 EXTRA_API_GL_CORE,
516 EXTRA_END
517 };
518
519 static const int extra_INTEL_conservative_rasterization[] = {
520 EXT(INTEL_conservative_rasterization),
521 EXTRA_END
522 };
523
524 static const int extra_ARB_timer_query_or_EXT_disjoint_timer_query[] = {
525 EXT(ARB_timer_query),
526 EXT(EXT_disjoint_timer_query),
527 EXTRA_END
528 };
529
530 static const int extra_ARB_framebuffer_object_or_EXT_framebuffer_multisample_or_EXT_multisampled_render_to_texture[] = {
531 EXT(ARB_framebuffer_object),
532 EXT(EXT_framebuffer_multisample),
533 EXT(EXT_multisampled_render_to_texture),
534 EXTRA_END
535 };
536
537 EXTRA_EXT(EXT_texture_array);
538 EXTRA_EXT(NV_fog_distance);
539 EXTRA_EXT(EXT_texture_filter_anisotropic);
540 EXTRA_EXT(NV_texture_rectangle);
541 EXTRA_EXT(EXT_stencil_two_side);
542 EXTRA_EXT(EXT_depth_bounds_test);
543 EXTRA_EXT(ARB_depth_clamp);
544 EXTRA_EXT(AMD_depth_clamp_separate);
545 EXTRA_EXT(ATI_fragment_shader);
546 EXTRA_EXT(EXT_provoking_vertex);
547 EXTRA_EXT(ARB_fragment_shader);
548 EXTRA_EXT(ARB_fragment_program);
549 EXTRA_EXT(ARB_seamless_cube_map);
550 EXTRA_EXT(ARB_sync);
551 EXTRA_EXT(ARB_vertex_shader);
552 EXTRA_EXT(EXT_transform_feedback);
553 EXTRA_EXT(ARB_transform_feedback3);
554 EXTRA_EXT(ARB_vertex_program);
555 EXTRA_EXT2(ARB_vertex_program, ARB_fragment_program);
556 EXTRA_EXT(ARB_color_buffer_float);
557 EXTRA_EXT(EXT_framebuffer_sRGB);
558 EXTRA_EXT(OES_EGL_image_external);
559 EXTRA_EXT(ARB_blend_func_extended);
560 EXTRA_EXT(ARB_uniform_buffer_object);
561 EXTRA_EXT2(ARB_texture_cube_map_array, OES_texture_cube_map_array);
562 EXTRA_EXT(ARB_texture_buffer_range);
563 EXTRA_EXT(ARB_texture_multisample);
564 EXTRA_EXT(ARB_texture_gather);
565 EXTRA_EXT(ARB_draw_indirect);
566 EXTRA_EXT(ARB_shader_image_load_store);
567 EXTRA_EXT(ARB_query_buffer_object);
568 EXTRA_EXT2(ARB_transform_feedback3, ARB_gpu_shader5);
569 EXTRA_EXT(INTEL_performance_query);
570 EXTRA_EXT(ARB_explicit_uniform_location);
571 EXTRA_EXT(ARB_clip_control);
572 EXTRA_EXT(ARB_polygon_offset_clamp);
573 EXTRA_EXT(ARB_framebuffer_no_attachments);
574 EXTRA_EXT(ARB_tessellation_shader);
575 EXTRA_EXT(ARB_shader_storage_buffer_object);
576 EXTRA_EXT(ARB_indirect_parameters);
577 EXTRA_EXT(ATI_meminfo);
578 EXTRA_EXT(NVX_gpu_memory_info);
579 EXTRA_EXT(ARB_cull_distance);
580 EXTRA_EXT(EXT_window_rectangles);
581 EXTRA_EXT(KHR_blend_equation_advanced_coherent);
582 EXTRA_EXT(OES_primitive_bounding_box);
583 EXTRA_EXT(ARB_compute_variable_group_size);
584 EXTRA_EXT(KHR_robustness);
585 EXTRA_EXT(ARB_sparse_buffer);
586 EXTRA_EXT(NV_conservative_raster);
587 EXTRA_EXT(NV_conservative_raster_dilate);
588 EXTRA_EXT(NV_conservative_raster_pre_snap_triangles);
589 EXTRA_EXT(ARB_sample_locations);
590 EXTRA_EXT(AMD_framebuffer_multisample_advanced);
591 EXTRA_EXT(ARB_spirv_extensions);
592 EXTRA_EXT(NV_viewport_swizzle);
593 EXTRA_EXT(ARB_sparse_texture);
594 EXTRA_EXT(KHR_shader_subgroup);
595 EXTRA_EXT(OVR_multiview);
596
597 static const int extra_ARB_gl_spirv_or_es2_compat[] = {
598 EXT(ARB_gl_spirv),
599 EXT(ARB_ES2_compatibility),
600 EXTRA_API_ES2,
601 EXTRA_END
602 };
603
604 static const int
605 extra_ARB_color_buffer_float_or_glcore[] = {
606 EXT(ARB_color_buffer_float),
607 EXTRA_API_GL_CORE,
608 EXTRA_END
609 };
610
611 static const int
612 extra_NV_primitive_restart[] = {
613 EXT(NV_primitive_restart),
614 EXTRA_END
615 };
616
617 static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };
618 static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };
619 static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };
620 static const int extra_version_43[] = { EXTRA_VERSION_43, EXTRA_END };
621
622 static const int extra_gl30_es3[] = {
623 EXTRA_VERSION_30,
624 EXTRA_API_ES3,
625 EXTRA_END,
626 };
627
628 static const int extra_gl32_es3[] = {
629 EXTRA_VERSION_32,
630 EXTRA_API_ES3,
631 EXTRA_END,
632 };
633
634 static const int extra_version_32_OES_geometry_shader[] = {
635 EXTRA_VERSION_32,
636 EXTRA_EXT_ES_GS,
637 EXTRA_END
638 };
639
640 static const int extra_gl40_ARB_sample_shading[] = {
641 EXTRA_VERSION_40,
642 EXT(ARB_sample_shading),
643 EXTRA_END
644 };
645
646 static const int
647 extra_ARB_vertex_program_api_es2[] = {
648 EXT(ARB_vertex_program),
649 EXTRA_API_ES2,
650 EXTRA_END
651 };
652
653 /* The ReadBuffer get token is valid under either full GL or under
654 * GLES2 if the NV_read_buffer extension is available. */
655 static const int
656 extra_NV_read_buffer_api_gl[] = {
657 EXTRA_API_ES2,
658 EXTRA_API_GL,
659 EXTRA_END
660 };
661
662 static const int extra_core_ARB_color_buffer_float_and_new_buffers[] = {
663 EXTRA_API_GL_CORE,
664 EXT(ARB_color_buffer_float),
665 EXTRA_NEW_BUFFERS,
666 EXTRA_END
667 };
668
669 static const int extra_EXT_shader_framebuffer_fetch[] = {
670 EXTRA_API_ES2,
671 EXTRA_API_ES3,
672 EXT(EXT_shader_framebuffer_fetch),
673 EXTRA_END
674 };
675
676 static const int extra_EXT_provoking_vertex_32[] = {
677 EXTRA_EXT_PROVOKING_VERTEX_32,
678 EXTRA_END
679 };
680
681 static const int extra_EXT_disjoint_timer_query[] = {
682 EXTRA_API_ES2,
683 EXTRA_API_ES3,
684 EXT(EXT_disjoint_timer_query),
685 EXTRA_END
686 };
687
688
689 /* This is the big table describing all the enums we accept in
690 * glGet*v(). The table is partitioned into six parts: enums
691 * understood by all GL APIs (OpenGL, GLES and GLES2), enums shared
692 * between OpenGL and GLES, enums exclusive to GLES, etc for the
693 * remaining combinations. To look up the enums valid in a given API
694 * we will use a hash table specific to that API. These tables are in
695 * turn generated at build time and included through get_hash.h.
696 */
697
698 #include "get_hash.h"
699
700 /* All we need now is a way to look up the value struct from the enum.
701 * The code generated by gcc for the old generated big switch
702 * statement is a big, balanced, open coded if/else tree, essentially
703 * an unrolled binary search. It would be natural to sort the new
704 * enum table and use bsearch(), but we will use a read-only hash
705 * table instead. bsearch() has a nice guaranteed worst case
706 * performance, but we're also guaranteed to hit that worst case
707 * (log2(n) iterations) for about half the enums. Instead, using an
708 * open addressing hash table, we can find the enum on the first try
709 * for 80% of the enums, 1 collision for 10% and never more than 5
710 * collisions for any enum (typical numbers). And the code is very
711 * simple, even though it feels a little magic. */
712
713 /**
714 * Handle irregular enums
715 *
716 * Some values don't conform to the "well-known type at context
717 * pointer + offset" pattern, so we have this function to catch all
718 * the corner cases. Typically, it's a computed value or a one-off
719 * pointer to a custom struct or something.
720 *
721 * In this case we can't return a pointer to the value, so we'll have
722 * to use the temporary variable 'v' declared back in the calling
723 * glGet*v() function to store the result.
724 *
725 * \param ctx the current context
726 * \param d the struct value_desc that describes the enum
727 * \param v pointer to the tmp declared in the calling glGet*v() function
728 */
729 static void
find_custom_value(struct gl_context * ctx,const struct value_desc * d,union value * v)730 find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)
731 {
732 struct gl_buffer_object **buffer_obj, *buf;
733 struct gl_array_attributes *array;
734 GLuint unit, *p;
735
736 switch (d->pname) {
737 case GL_MAJOR_VERSION:
738 v->value_int = ctx->Version / 10;
739 break;
740 case GL_MINOR_VERSION:
741 v->value_int = ctx->Version % 10;
742 break;
743
744 case GL_TEXTURE_1D:
745 case GL_TEXTURE_2D:
746 case GL_TEXTURE_3D:
747 case GL_TEXTURE_CUBE_MAP:
748 case GL_TEXTURE_RECTANGLE_NV:
749 case GL_TEXTURE_EXTERNAL_OES:
750 v->value_bool = _mesa_IsEnabled(d->pname);
751 break;
752
753 case GL_LINE_STIPPLE_PATTERN:
754 /* This is the only GLushort, special case it here by promoting
755 * to an int rather than introducing a new type. */
756 v->value_int = ctx->Line.StipplePattern;
757 break;
758
759 case GL_CURRENT_RASTER_TEXTURE_COORDS:
760 unit = ctx->Texture.CurrentUnit;
761 v->value_float_4[0] = ctx->Current.RasterTexCoords[unit][0];
762 v->value_float_4[1] = ctx->Current.RasterTexCoords[unit][1];
763 v->value_float_4[2] = ctx->Current.RasterTexCoords[unit][2];
764 v->value_float_4[3] = ctx->Current.RasterTexCoords[unit][3];
765 break;
766
767 case GL_CURRENT_TEXTURE_COORDS:
768 unit = ctx->Texture.CurrentUnit;
769 v->value_float_4[0] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][0];
770 v->value_float_4[1] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][1];
771 v->value_float_4[2] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][2];
772 v->value_float_4[3] = ctx->Current.Attrib[VERT_ATTRIB_TEX0 + unit][3];
773 break;
774
775 case GL_COLOR_WRITEMASK:
776 v->value_int_4[0] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 0);
777 v->value_int_4[1] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 1);
778 v->value_int_4[2] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 2);
779 v->value_int_4[3] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 3);
780 break;
781
782 case GL_DEPTH_CLAMP:
783 v->value_bool = ctx->Transform.DepthClampNear || ctx->Transform.DepthClampFar;
784 break;
785
786 case GL_EDGE_FLAG:
787 v->value_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0F;
788 break;
789
790 case GL_READ_BUFFER:
791 v->value_enum16 = ctx->ReadBuffer->ColorReadBuffer;
792 break;
793
794 case GL_MAP2_GRID_DOMAIN:
795 v->value_float_4[0] = ctx->Eval.MapGrid2u1;
796 v->value_float_4[1] = ctx->Eval.MapGrid2u2;
797 v->value_float_4[2] = ctx->Eval.MapGrid2v1;
798 v->value_float_4[3] = ctx->Eval.MapGrid2v2;
799 break;
800
801 case GL_TEXTURE_STACK_DEPTH:
802 unit = ctx->Texture.CurrentUnit;
803 v->value_int = ctx->TextureMatrixStack[unit].Depth + 1;
804 break;
805 case GL_TEXTURE_MATRIX:
806 unit = ctx->Texture.CurrentUnit;
807 v->value_matrix = ctx->TextureMatrixStack[unit].Top;
808 break;
809
810 case GL_VERTEX_ARRAY:
811 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_POS);
812 break;
813 case GL_NORMAL_ARRAY:
814 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_NORMAL);
815 break;
816 case GL_COLOR_ARRAY:
817 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR0);
818 break;
819 case GL_TEXTURE_COORD_ARRAY:
820 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_TEX(ctx->Array.ActiveTexture));
821 break;
822 case GL_INDEX_ARRAY:
823 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR_INDEX);
824 break;
825 case GL_EDGE_FLAG_ARRAY:
826 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_EDGEFLAG);
827 break;
828 case GL_SECONDARY_COLOR_ARRAY:
829 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR1);
830 break;
831 case GL_FOG_COORDINATE_ARRAY:
832 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_FOG);
833 break;
834 case GL_POINT_SIZE_ARRAY_OES:
835 v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_POINT_SIZE);
836 break;
837
838 case GL_TEXTURE_COORD_ARRAY_TYPE:
839 case GL_TEXTURE_COORD_ARRAY_STRIDE:
840 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)];
841 v->value_int = *(GLuint *) ((char *) array + d->offset);
842 break;
843
844 case GL_TEXTURE_COORD_ARRAY_SIZE:
845 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)];
846 v->value_int = array->Format.User.Size;
847 break;
848
849 case GL_VERTEX_ARRAY_SIZE:
850 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS];
851 v->value_int = array->Format.User.Size;
852 break;
853
854 case GL_ACTIVE_TEXTURE_ARB:
855 v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
856 break;
857 case GL_CLIENT_ACTIVE_TEXTURE_ARB:
858 v->value_int = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
859 break;
860
861 case GL_MODELVIEW_STACK_DEPTH:
862 case GL_PROJECTION_STACK_DEPTH:
863 v->value_int = *(GLint *) ((char *) ctx + d->offset) + 1;
864 break;
865
866 case GL_MAX_TEXTURE_SIZE:
867 case GL_MAX_3D_TEXTURE_SIZE:
868 case GL_MAX_CUBE_MAP_TEXTURE_SIZE_ARB:
869 p = (GLuint *) ((char *) ctx + d->offset);
870 v->value_int = 1 << (*p - 1);
871 break;
872
873 case GL_SCISSOR_BOX:
874 v->value_int_4[0] = ctx->Scissor.ScissorArray[0].X;
875 v->value_int_4[1] = ctx->Scissor.ScissorArray[0].Y;
876 v->value_int_4[2] = ctx->Scissor.ScissorArray[0].Width;
877 v->value_int_4[3] = ctx->Scissor.ScissorArray[0].Height;
878 break;
879
880 case GL_SCISSOR_TEST:
881 v->value_bool = ctx->Scissor.EnableFlags & 1;
882 break;
883
884 case GL_LIST_INDEX:
885 v->value_int =
886 ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
887 break;
888 case GL_LIST_MODE:
889 if (!ctx->CompileFlag)
890 v->value_enum16 = 0;
891 else if (ctx->ExecuteFlag)
892 v->value_enum16 = GL_COMPILE_AND_EXECUTE;
893 else
894 v->value_enum16 = GL_COMPILE;
895 break;
896
897 case GL_VIEWPORT:
898 v->value_float_4[0] = ctx->ViewportArray[0].X;
899 v->value_float_4[1] = ctx->ViewportArray[0].Y;
900 v->value_float_4[2] = ctx->ViewportArray[0].Width;
901 v->value_float_4[3] = ctx->ViewportArray[0].Height;
902 break;
903
904 case GL_DEPTH_RANGE:
905 v->value_double_2[0] = ctx->ViewportArray[0].Near;
906 v->value_double_2[1] = ctx->ViewportArray[0].Far;
907 break;
908
909 case GL_ACTIVE_STENCIL_FACE_EXT:
910 v->value_enum16 = ctx->Stencil.ActiveFace ? GL_BACK : GL_FRONT;
911 break;
912
913 case GL_STENCIL_FAIL:
914 v->value_enum16 = ctx->Stencil.FailFunc[ctx->Stencil.ActiveFace];
915 break;
916 case GL_STENCIL_FUNC:
917 v->value_enum16 = ctx->Stencil.Function[ctx->Stencil.ActiveFace];
918 break;
919 case GL_STENCIL_PASS_DEPTH_FAIL:
920 v->value_enum16 = ctx->Stencil.ZFailFunc[ctx->Stencil.ActiveFace];
921 break;
922 case GL_STENCIL_PASS_DEPTH_PASS:
923 v->value_enum16 = ctx->Stencil.ZPassFunc[ctx->Stencil.ActiveFace];
924 break;
925 case GL_STENCIL_REF:
926 v->value_int = _mesa_get_stencil_ref(ctx, ctx->Stencil.ActiveFace);
927 break;
928 case GL_STENCIL_BACK_REF:
929 v->value_int = _mesa_get_stencil_ref(ctx, 1);
930 break;
931 case GL_STENCIL_VALUE_MASK:
932 v->value_int = ctx->Stencil.ValueMask[ctx->Stencil.ActiveFace];
933 break;
934 case GL_STENCIL_WRITEMASK:
935 v->value_int = ctx->Stencil.WriteMask[ctx->Stencil.ActiveFace];
936 break;
937
938 case GL_NUM_EXTENSIONS:
939 v->value_int = _mesa_get_extension_count(ctx);
940 break;
941
942 case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
943 v->value_int = _mesa_get_color_read_type(ctx, NULL, "glGetIntegerv");
944 break;
945 case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
946 v->value_int = _mesa_get_color_read_format(ctx, NULL, "glGetIntegerv");
947 break;
948
949 case GL_CURRENT_MATRIX_STACK_DEPTH_ARB:
950 v->value_int = ctx->CurrentStack->Depth + 1;
951 break;
952 case GL_CURRENT_MATRIX_ARB:
953 case GL_TRANSPOSE_CURRENT_MATRIX_ARB:
954 v->value_matrix = ctx->CurrentStack->Top;
955 break;
956
957 case GL_NUM_COMPRESSED_TEXTURE_FORMATS_ARB:
958 v->value_int = _mesa_get_compressed_formats(ctx, NULL);
959 break;
960 case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
961 v->value_int_n.n =
962 _mesa_get_compressed_formats(ctx, v->value_int_n.ints);
963 assert(v->value_int_n.n <= (int) ARRAY_SIZE(v->value_int_n.ints));
964 break;
965
966 case GL_MAX_VARYING_FLOATS_ARB:
967 v->value_int = ctx->Const.MaxVarying * 4;
968 break;
969
970 /* Various object names */
971
972 case GL_TEXTURE_BINDING_1D:
973 case GL_TEXTURE_BINDING_2D:
974 case GL_TEXTURE_BINDING_3D:
975 case GL_TEXTURE_BINDING_1D_ARRAY_EXT:
976 case GL_TEXTURE_BINDING_2D_ARRAY_EXT:
977 case GL_TEXTURE_BINDING_CUBE_MAP_ARB:
978 case GL_TEXTURE_BINDING_RECTANGLE_NV:
979 case GL_TEXTURE_BINDING_EXTERNAL_OES:
980 case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
981 case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
982 case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
983 unit = ctx->Texture.CurrentUnit;
984 v->value_int =
985 ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
986 break;
987
988 /* GL_EXT_external_objects */
989 case GL_NUM_DEVICE_UUIDS_EXT:
990 v->value_int = 1;
991 break;
992 case GL_DRIVER_UUID_EXT:
993 _mesa_get_driver_uuid(ctx, v->value_int_4);
994 break;
995 case GL_DEVICE_UUID_EXT:
996 _mesa_get_device_uuid(ctx, v->value_int_4);
997 break;
998
999 /* GL_EXT_memory_object_win32 */
1000 case GL_DEVICE_LUID_EXT:
1001 _mesa_get_device_luid(ctx, v->value_int_2);
1002 break;
1003 case GL_DEVICE_NODE_MASK_EXT:
1004 v->value_int = ctx->pipe->screen->get_device_node_mask(ctx->pipe->screen);
1005 break;
1006
1007 /* GL_EXT_packed_float */
1008 case GL_RGBA_SIGNED_COMPONENTS_EXT:
1009 {
1010 /* Note: we only check the 0th color attachment. */
1011 const struct gl_renderbuffer *rb =
1012 ctx->DrawBuffer->_ColorDrawBuffers[0];
1013 if (rb && _mesa_is_format_signed(rb->Format)) {
1014 /* Issue 17 of GL_EXT_packed_float: If a component (such as
1015 * alpha) has zero bits, the component should not be considered
1016 * signed and so the bit for the respective component should be
1017 * zeroed.
1018 */
1019 GLint r_bits =
1020 _mesa_get_format_bits(rb->Format, GL_RED_BITS);
1021 GLint g_bits =
1022 _mesa_get_format_bits(rb->Format, GL_GREEN_BITS);
1023 GLint b_bits =
1024 _mesa_get_format_bits(rb->Format, GL_BLUE_BITS);
1025 GLint a_bits =
1026 _mesa_get_format_bits(rb->Format, GL_ALPHA_BITS);
1027 GLint l_bits =
1028 _mesa_get_format_bits(rb->Format, GL_TEXTURE_LUMINANCE_SIZE);
1029 GLint i_bits =
1030 _mesa_get_format_bits(rb->Format, GL_TEXTURE_INTENSITY_SIZE);
1031
1032 v->value_int_4[0] = r_bits + l_bits + i_bits > 0;
1033 v->value_int_4[1] = g_bits + l_bits + i_bits > 0;
1034 v->value_int_4[2] = b_bits + l_bits + i_bits > 0;
1035 v->value_int_4[3] = a_bits + i_bits > 0;
1036 }
1037 else {
1038 v->value_int_4[0] =
1039 v->value_int_4[1] =
1040 v->value_int_4[2] =
1041 v->value_int_4[3] = 0;
1042 }
1043 }
1044 break;
1045
1046 /* GL_ARB_vertex_buffer_object */
1047 case GL_VERTEX_ARRAY_BUFFER_BINDING_ARB:
1048 case GL_NORMAL_ARRAY_BUFFER_BINDING_ARB:
1049 case GL_COLOR_ARRAY_BUFFER_BINDING_ARB:
1050 case GL_INDEX_ARRAY_BUFFER_BINDING_ARB:
1051 case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB:
1052 case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
1053 case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
1054 buffer_obj = (struct gl_buffer_object **)
1055 ((char *) ctx->Array.VAO + d->offset);
1056 v->value_int = (*buffer_obj) ? (*buffer_obj)->Name : 0;
1057 break;
1058 case GL_ARRAY_BUFFER_BINDING_ARB:
1059 buf = ctx->Array.ArrayBufferObj;
1060 v->value_int = buf ? buf->Name : 0;
1061 break;
1062 case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
1063 buf = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj;
1064 v->value_int = buf ? buf->Name : 0;
1065 break;
1066 case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
1067 buf = ctx->Array.VAO->IndexBufferObj;
1068 v->value_int = buf ? buf->Name : 0;
1069 break;
1070
1071 /* ARB_vertex_array_bgra */
1072 case GL_COLOR_ARRAY_SIZE:
1073 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0];
1074 v->value_int = array->Format.User.Bgra ? GL_BGRA : array->Format.User.Size;
1075 break;
1076 case GL_SECONDARY_COLOR_ARRAY_SIZE:
1077 array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1];
1078 v->value_int = array->Format.User.Bgra ? GL_BGRA : array->Format.User.Size;
1079 break;
1080
1081 /* ARB_copy_buffer */
1082 case GL_COPY_READ_BUFFER:
1083 v->value_int = ctx->CopyReadBuffer ? ctx->CopyReadBuffer->Name : 0;
1084 break;
1085 case GL_COPY_WRITE_BUFFER:
1086 v->value_int = ctx->CopyWriteBuffer ? ctx->CopyWriteBuffer->Name : 0;
1087 break;
1088
1089 case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
1090 v->value_int = ctx->Pack.BufferObj ? ctx->Pack.BufferObj->Name : 0;
1091 break;
1092 case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
1093 v->value_int = ctx->Unpack.BufferObj ? ctx->Unpack.BufferObj->Name : 0;
1094 break;
1095 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
1096 v->value_int = ctx->TransformFeedback.CurrentBuffer ?
1097 ctx->TransformFeedback.CurrentBuffer->Name : 0;
1098 break;
1099 case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
1100 v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
1101 break;
1102 case GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE:
1103 v->value_int = ctx->TransformFeedback.CurrentObject->Active;
1104 break;
1105 case GL_TRANSFORM_FEEDBACK_BINDING:
1106 v->value_int = ctx->TransformFeedback.CurrentObject->Name;
1107 break;
1108 case GL_CURRENT_PROGRAM:
1109 /* The Changelog of the ARB_separate_shader_objects spec says:
1110 *
1111 * 24 25 Jul 2011 pbrown Remove the language erroneously deleting
1112 * CURRENT_PROGRAM. In the EXT extension, this
1113 * token was aliased to ACTIVE_PROGRAM_EXT, and
1114 * was used to indicate the last program set by
1115 * either ActiveProgramEXT or UseProgram. In
1116 * the ARB extension, the SSO active programs
1117 * are now program pipeline object state and
1118 * CURRENT_PROGRAM should still be used to query
1119 * the last program set by UseProgram (bug 7822).
1120 */
1121 v->value_int =
1122 ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
1123 break;
1124 case GL_READ_FRAMEBUFFER_BINDING_EXT:
1125 v->value_int = ctx->ReadBuffer->Name;
1126 break;
1127 case GL_RENDERBUFFER_BINDING_EXT:
1128 v->value_int =
1129 ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
1130 break;
1131 case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
1132 buf = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_POINT_SIZE].BufferObj;
1133 v->value_int = buf ? buf->Name : 0;
1134 break;
1135
1136 case GL_FOG_COLOR:
1137 if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1138 COPY_4FV(v->value_float_4, ctx->Fog.Color);
1139 else
1140 COPY_4FV(v->value_float_4, ctx->Fog.ColorUnclamped);
1141 break;
1142 case GL_COLOR_CLEAR_VALUE:
1143 if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer)) {
1144 v->value_float_4[0] = CLAMP(ctx->Color.ClearColor.f[0], 0.0F, 1.0F);
1145 v->value_float_4[1] = CLAMP(ctx->Color.ClearColor.f[1], 0.0F, 1.0F);
1146 v->value_float_4[2] = CLAMP(ctx->Color.ClearColor.f[2], 0.0F, 1.0F);
1147 v->value_float_4[3] = CLAMP(ctx->Color.ClearColor.f[3], 0.0F, 1.0F);
1148 } else
1149 COPY_4FV(v->value_float_4, ctx->Color.ClearColor.f);
1150 break;
1151 case GL_BLEND_COLOR_EXT:
1152 if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1153 COPY_4FV(v->value_float_4, ctx->Color.BlendColor);
1154 else
1155 COPY_4FV(v->value_float_4, ctx->Color.BlendColorUnclamped);
1156 break;
1157 case GL_ALPHA_TEST_REF:
1158 if (_mesa_get_clamp_fragment_color(ctx, ctx->DrawBuffer))
1159 v->value_float = ctx->Color.AlphaRef;
1160 else
1161 v->value_float = ctx->Color.AlphaRefUnclamped;
1162 break;
1163 case GL_MAX_VERTEX_UNIFORM_VECTORS:
1164 v->value_int = ctx->Const.Program[MESA_SHADER_VERTEX].MaxUniformComponents / 4;
1165 break;
1166
1167 case GL_MAX_FRAGMENT_UNIFORM_VECTORS:
1168 v->value_int = ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxUniformComponents / 4;
1169 break;
1170
1171 /* GL_ARB_texture_buffer_object */
1172 case GL_TEXTURE_BUFFER_ARB:
1173 v->value_int = ctx->Texture.BufferObject ? ctx->Texture.BufferObject->Name : 0;
1174 break;
1175 case GL_TEXTURE_BINDING_BUFFER_ARB:
1176 unit = ctx->Texture.CurrentUnit;
1177 v->value_int =
1178 ctx->Texture.Unit[unit].CurrentTex[TEXTURE_BUFFER_INDEX]->Name;
1179 break;
1180 case GL_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB:
1181 {
1182 struct gl_buffer_object *buf =
1183 ctx->Texture.Unit[ctx->Texture.CurrentUnit]
1184 .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObject;
1185 v->value_int = buf ? buf->Name : 0;
1186 }
1187 break;
1188 case GL_TEXTURE_BUFFER_FORMAT_ARB:
1189 v->value_int = ctx->Texture.Unit[ctx->Texture.CurrentUnit]
1190 .CurrentTex[TEXTURE_BUFFER_INDEX]->BufferObjectFormat;
1191 break;
1192
1193 /* GL_ARB_sampler_objects */
1194 case GL_SAMPLER_BINDING:
1195 {
1196 struct gl_sampler_object *samp =
1197 ctx->Texture.Unit[ctx->Texture.CurrentUnit].Sampler;
1198 v->value_int = samp ? samp->Name : 0;
1199 }
1200 break;
1201 /* GL_ARB_uniform_buffer_object */
1202 case GL_UNIFORM_BUFFER_BINDING:
1203 v->value_int = ctx->UniformBuffer ? ctx->UniformBuffer->Name : 0;
1204 break;
1205 /* GL_ARB_shader_storage_buffer_object */
1206 case GL_SHADER_STORAGE_BUFFER_BINDING:
1207 v->value_int = ctx->ShaderStorageBuffer ? ctx->ShaderStorageBuffer->Name : 0;
1208 break;
1209 /* GL_ARB_query_buffer_object */
1210 case GL_QUERY_BUFFER_BINDING:
1211 v->value_int = ctx->QueryBuffer ? ctx->QueryBuffer->Name : 0;
1212 break;
1213 /* GL_ARB_timer_query */
1214 case GL_TIMESTAMP:
1215 v->value_int64 = _mesa_get_timestamp(ctx);
1216 break;
1217 /* GL_KHR_DEBUG */
1218 case GL_DEBUG_OUTPUT:
1219 case GL_DEBUG_OUTPUT_SYNCHRONOUS:
1220 case GL_DEBUG_LOGGED_MESSAGES:
1221 case GL_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH:
1222 case GL_DEBUG_GROUP_STACK_DEPTH:
1223 v->value_int = _mesa_get_debug_state_int(ctx, d->pname);
1224 break;
1225 /* GL_ARB_shader_atomic_counters */
1226 case GL_ATOMIC_COUNTER_BUFFER_BINDING:
1227 v->value_int = ctx->AtomicBuffer ? ctx->AtomicBuffer->Name : 0;
1228 break;
1229 /* GL 4.3 */
1230 case GL_NUM_SHADING_LANGUAGE_VERSIONS:
1231 v->value_int = _mesa_get_shading_language_version(ctx, -1, NULL);
1232 break;
1233 /* GL_ARB_draw_indirect */
1234 case GL_DRAW_INDIRECT_BUFFER_BINDING:
1235 v->value_int = ctx->DrawIndirectBuffer ? ctx->DrawIndirectBuffer->Name: 0;
1236 break;
1237 /* GL_ARB_indirect_parameters */
1238 case GL_PARAMETER_BUFFER_BINDING_ARB:
1239 v->value_int = ctx->ParameterBuffer ? ctx->ParameterBuffer->Name : 0;
1240 break;
1241 /* GL_ARB_separate_shader_objects */
1242 case GL_PROGRAM_PIPELINE_BINDING:
1243 if (ctx->Pipeline.Current) {
1244 v->value_int = ctx->Pipeline.Current->Name;
1245 } else {
1246 v->value_int = 0;
1247 }
1248 break;
1249 /* GL_ARB_compute_shader */
1250 case GL_DISPATCH_INDIRECT_BUFFER_BINDING:
1251 v->value_int = ctx->DispatchIndirectBuffer ?
1252 ctx->DispatchIndirectBuffer->Name : 0;
1253 break;
1254 /* GL_ARB_multisample */
1255 case GL_SAMPLES:
1256 v->value_int = _mesa_geometric_samples(ctx->DrawBuffer);
1257 break;
1258 case GL_SAMPLE_BUFFERS:
1259 v->value_int = _mesa_geometric_samples(ctx->DrawBuffer) > 0;
1260 break;
1261 /* GL_EXT_textrue_integer */
1262 case GL_RGBA_INTEGER_MODE_EXT:
1263 v->value_int = (ctx->DrawBuffer->_IntegerBuffers != 0);
1264 break;
1265 /* GL_ATI_meminfo & GL_NVX_gpu_memory_info */
1266 case GL_VBO_FREE_MEMORY_ATI:
1267 case GL_TEXTURE_FREE_MEMORY_ATI:
1268 case GL_RENDERBUFFER_FREE_MEMORY_ATI:
1269 case GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX:
1270 case GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX:
1271 case GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX:
1272 case GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX:
1273 case GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX:
1274 {
1275 struct pipe_memory_info info;
1276 struct pipe_screen *screen = ctx->pipe->screen;
1277
1278 assert(screen->query_memory_info);
1279 screen->query_memory_info(screen, &info);
1280
1281 if (d->pname == GL_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX)
1282 v->value_int = info.total_device_memory;
1283 else if (d->pname == GL_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX)
1284 v->value_int = info.total_device_memory +
1285 info.total_staging_memory;
1286 else if (d->pname == GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX)
1287 v->value_int = info.avail_device_memory;
1288 else if (d->pname == GL_GPU_MEMORY_INFO_EVICTION_COUNT_NVX)
1289 v->value_int = info.nr_device_memory_evictions;
1290 else if (d->pname == GL_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX)
1291 v->value_int = info.device_memory_evicted;
1292 else {
1293 /* ATI free memory enums.
1294 *
1295 * Since the GPU memory is (usually) page-table based, every two
1296 * consecutive elements are equal. From the GL_ATI_meminfo
1297 * specification:
1298 *
1299 * "param[0] - total memory free in the pool
1300 * param[1] - largest available free block in the pool
1301 * param[2] - total auxiliary memory free
1302 * param[3] - largest auxiliary free block"
1303 *
1304 * All three (VBO, TEXTURE, RENDERBUFFER) queries return
1305 * the same numbers here.
1306 */
1307 v->value_int_4[0] = info.avail_device_memory;
1308 v->value_int_4[1] = info.avail_device_memory;
1309 v->value_int_4[2] = info.avail_staging_memory;
1310 v->value_int_4[3] = info.avail_staging_memory;
1311 }
1312 }
1313 break;
1314
1315 /* GL_ARB_get_program_binary */
1316 case GL_PROGRAM_BINARY_FORMATS:
1317 assert(ctx->Const.NumProgramBinaryFormats <= 1);
1318 v->value_int_n.n = MIN2(ctx->Const.NumProgramBinaryFormats, 1);
1319 if (ctx->Const.NumProgramBinaryFormats > 0) {
1320 v->value_int_n.ints[0] = GL_PROGRAM_BINARY_FORMAT_MESA;
1321 }
1322 break;
1323 /* GL_ARB_gl_spirv */
1324 case GL_SHADER_BINARY_FORMATS:
1325 assert(ctx->Const.NumShaderBinaryFormats <= 1);
1326 v->value_int_n.n = MIN2(ctx->Const.NumShaderBinaryFormats, 1);
1327 if (ctx->Const.NumShaderBinaryFormats > 0) {
1328 v->value_int_n.ints[0] = GL_SHADER_BINARY_FORMAT_SPIR_V;
1329 }
1330 break;
1331 /* ARB_spirv_extensions */
1332 case GL_NUM_SPIR_V_EXTENSIONS:
1333 v->value_int = _mesa_get_spirv_extension_count(ctx);
1334 break;
1335 /* GL_EXT_disjoint_timer_query */
1336 case GL_GPU_DISJOINT_EXT:
1337 {
1338 v->value_int = 0;
1339 }
1340 break;
1341 /* GL_ARB_sample_locations */
1342 case GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB:
1343 case GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB:
1344 case GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB:
1345 {
1346 GLuint bits, width, height;
1347
1348 if (ctx->NewState & _NEW_BUFFERS)
1349 _mesa_update_state(ctx);
1350
1351 if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE) {
1352 v->value_uint = 0;
1353 break;
1354 }
1355
1356 _mesa_GetProgrammableSampleCaps(ctx, ctx->DrawBuffer,
1357 &bits, &width, &height);
1358
1359 if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB)
1360 v->value_uint = width;
1361 else if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB)
1362 v->value_uint = height;
1363 else
1364 v->value_uint = bits;
1365 }
1366 break;
1367 case GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB:
1368 v->value_uint = MAX_SAMPLE_LOCATION_TABLE_SIZE;
1369 break;
1370
1371 /* GL_AMD_framebuffer_multisample_advanced */
1372 case GL_SUPPORTED_MULTISAMPLE_MODES_AMD:
1373 v->value_int_n.n = ctx->Const.NumSupportedMultisampleModes * 3;
1374 memcpy(v->value_int_n.ints, ctx->Const.SupportedMultisampleModes,
1375 v->value_int_n.n * sizeof(GLint));
1376 break;
1377
1378 /* GL_NV_viewport_swizzle */
1379 case GL_VIEWPORT_SWIZZLE_X_NV:
1380 v->value_enum = ctx->ViewportArray[0].SwizzleX;
1381 break;
1382 case GL_VIEWPORT_SWIZZLE_Y_NV:
1383 v->value_enum = ctx->ViewportArray[0].SwizzleY;
1384 break;
1385 case GL_VIEWPORT_SWIZZLE_Z_NV:
1386 v->value_enum = ctx->ViewportArray[0].SwizzleZ;
1387 break;
1388 case GL_VIEWPORT_SWIZZLE_W_NV:
1389 v->value_enum = ctx->ViewportArray[0].SwizzleW;
1390 break;
1391 }
1392 }
1393
1394 /**
1395 * Check extra constraints on a struct value_desc descriptor
1396 *
1397 * If a struct value_desc has a non-NULL extra pointer, it means that
1398 * there are a number of extra constraints to check or actions to
1399 * perform. The extras is just an integer array where each integer
1400 * encode different constraints or actions.
1401 *
1402 * \param ctx current context
1403 * \param func name of calling glGet*v() function for error reporting
1404 * \param d the struct value_desc that has the extra constraints
1405 *
1406 * \return GL_FALSE if all of the constraints were not satisfied,
1407 * otherwise GL_TRUE.
1408 */
1409 static GLboolean
check_extra(struct gl_context * ctx,const char * func,const struct value_desc * d)1410 check_extra(struct gl_context *ctx, const char *func, const struct value_desc *d)
1411 {
1412 const GLuint version = ctx->Version;
1413 GLboolean api_check = GL_FALSE;
1414 GLboolean api_found = GL_FALSE;
1415 const int *e;
1416
1417 for (e = d->extra; *e != EXTRA_END; e++) {
1418 switch (*e) {
1419 case EXTRA_VERSION_30:
1420 api_check = GL_TRUE;
1421 if (version >= 30)
1422 api_found = GL_TRUE;
1423 break;
1424 case EXTRA_VERSION_31:
1425 api_check = GL_TRUE;
1426 if (version >= 31)
1427 api_found = GL_TRUE;
1428 break;
1429 case EXTRA_VERSION_32:
1430 api_check = GL_TRUE;
1431 if (version >= 32)
1432 api_found = GL_TRUE;
1433 break;
1434 case EXTRA_VERSION_40:
1435 api_check = GL_TRUE;
1436 if (version >= 40)
1437 api_found = GL_TRUE;
1438 break;
1439 case EXTRA_VERSION_43:
1440 api_check = GL_TRUE;
1441 if (_mesa_is_desktop_gl(ctx) && version >= 43)
1442 api_found = GL_TRUE;
1443 break;
1444 case EXTRA_API_ES:
1445 api_check = GL_TRUE;
1446 if (_mesa_is_gles(ctx))
1447 api_found = GL_TRUE;
1448 break;
1449 case EXTRA_API_ES2:
1450 api_check = GL_TRUE;
1451 if (_mesa_is_gles2(ctx))
1452 api_found = GL_TRUE;
1453 break;
1454 case EXTRA_API_ES3:
1455 api_check = GL_TRUE;
1456 if (_mesa_is_gles3(ctx))
1457 api_found = GL_TRUE;
1458 break;
1459 case EXTRA_API_ES31:
1460 api_check = GL_TRUE;
1461 if (_mesa_is_gles31(ctx))
1462 api_found = GL_TRUE;
1463 break;
1464 case EXTRA_API_ES32:
1465 api_check = GL_TRUE;
1466 if (_mesa_is_gles32(ctx))
1467 api_found = GL_TRUE;
1468 break;
1469 case EXTRA_API_GL:
1470 api_check = GL_TRUE;
1471 if (_mesa_is_desktop_gl(ctx))
1472 api_found = GL_TRUE;
1473 break;
1474 case EXTRA_API_GL_CORE:
1475 api_check = GL_TRUE;
1476 if (_mesa_is_desktop_gl_core(ctx))
1477 api_found = GL_TRUE;
1478 break;
1479 case EXTRA_API_GL_COMPAT:
1480 api_check = GL_TRUE;
1481 if (_mesa_is_desktop_gl_compat(ctx))
1482 api_found = GL_TRUE;
1483 break;
1484 case EXTRA_NEW_BUFFERS:
1485 if (ctx->NewState & _NEW_BUFFERS)
1486 _mesa_update_state(ctx);
1487 break;
1488 case EXTRA_FLUSH_CURRENT:
1489 FLUSH_CURRENT(ctx, 0);
1490 break;
1491 case EXTRA_VALID_DRAW_BUFFER:
1492 if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
1493 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
1494 func, d->pname - GL_DRAW_BUFFER0_ARB);
1495 return GL_FALSE;
1496 }
1497 break;
1498 case EXTRA_VALID_TEXTURE_UNIT:
1499 if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
1500 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
1501 func, ctx->Texture.CurrentUnit);
1502 return GL_FALSE;
1503 }
1504 break;
1505 case EXTRA_VALID_CLIP_DISTANCE:
1506 if (d->pname - GL_CLIP_DISTANCE0 >= ctx->Const.MaxClipPlanes) {
1507 _mesa_error(ctx, GL_INVALID_ENUM, "%s(clip distance %u)",
1508 func, d->pname - GL_CLIP_DISTANCE0);
1509 return GL_FALSE;
1510 }
1511 break;
1512 case EXTRA_GLSL_130:
1513 api_check = GL_TRUE;
1514 if (ctx->Const.GLSLVersion >= 130)
1515 api_found = GL_TRUE;
1516 break;
1517 case EXTRA_EXT_UBO_GS:
1518 api_check = GL_TRUE;
1519 if (ctx->Extensions.ARB_uniform_buffer_object &&
1520 _mesa_has_geometry_shaders(ctx))
1521 api_found = GL_TRUE;
1522 break;
1523 case EXTRA_EXT_ATOMICS_GS:
1524 api_check = GL_TRUE;
1525 if (ctx->Extensions.ARB_shader_atomic_counters &&
1526 _mesa_has_geometry_shaders(ctx))
1527 api_found = GL_TRUE;
1528 break;
1529 case EXTRA_EXT_SHADER_IMAGE_GS:
1530 api_check = GL_TRUE;
1531 if ((ctx->Extensions.ARB_shader_image_load_store ||
1532 _mesa_is_gles31(ctx)) &&
1533 _mesa_has_geometry_shaders(ctx))
1534 api_found = GL_TRUE;
1535 break;
1536 case EXTRA_EXT_ATOMICS_TESS:
1537 api_check = GL_TRUE;
1538 api_found = ctx->Extensions.ARB_shader_atomic_counters &&
1539 _mesa_has_tessellation(ctx);
1540 break;
1541 case EXTRA_EXT_SHADER_IMAGE_TESS:
1542 api_check = GL_TRUE;
1543 api_found = ctx->Extensions.ARB_shader_image_load_store &&
1544 _mesa_has_tessellation(ctx);
1545 break;
1546 case EXTRA_EXT_SSBO_GS:
1547 api_check = GL_TRUE;
1548 if (ctx->Extensions.ARB_shader_storage_buffer_object &&
1549 _mesa_has_geometry_shaders(ctx))
1550 api_found = GL_TRUE;
1551 break;
1552 case EXTRA_EXT_FB_NO_ATTACH_GS:
1553 api_check = GL_TRUE;
1554 if (ctx->Extensions.ARB_framebuffer_no_attachments &&
1555 (_mesa_is_desktop_gl(ctx) ||
1556 _mesa_has_OES_geometry_shader(ctx)))
1557 api_found = GL_TRUE;
1558 break;
1559 case EXTRA_EXT_ES_GS:
1560 api_check = GL_TRUE;
1561 if (_mesa_has_OES_geometry_shader(ctx))
1562 api_found = GL_TRUE;
1563 break;
1564 case EXTRA_EXT_PROVOKING_VERTEX_32:
1565 api_check = GL_TRUE;
1566 if (_mesa_is_desktop_gl_compat(ctx) || version == 32)
1567 api_found = ctx->Extensions.EXT_provoking_vertex;
1568 break;
1569 case EXTRA_END:
1570 break;
1571 default: /* *e is a offset into the extension struct */
1572 api_check = GL_TRUE;
1573 if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
1574 api_found = GL_TRUE;
1575 break;
1576 }
1577 }
1578
1579 if (api_check && !api_found) {
1580 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1581 _mesa_enum_to_string(d->pname));
1582 return GL_FALSE;
1583 }
1584
1585 return GL_TRUE;
1586 }
1587
1588 static const struct value_desc error_value =
1589 { 0, 0, TYPE_INVALID, NO_OFFSET, NO_EXTRA };
1590
1591 /**
1592 * Find the struct value_desc corresponding to the enum 'pname'.
1593 *
1594 * We hash the enum value to get an index into the 'table' array,
1595 * which holds the index in the 'values' array of struct value_desc.
1596 * Once we've found the entry, we do the extra checks, if any, then
1597 * look up the value and return a pointer to it.
1598 *
1599 * If the value has to be computed (for example, it's the result of a
1600 * function call or we need to add 1 to it), we use the tmp 'v' to
1601 * store the result.
1602 *
1603 * \param func name of glGet*v() func for error reporting
1604 * \param pname the enum value we're looking up
1605 * \param p is were we return the pointer to the value
1606 * \param v a tmp union value variable in the calling glGet*v() function
1607 *
1608 * \return the struct value_desc corresponding to the enum or a struct
1609 * value_desc of TYPE_INVALID if not found. This lets the calling
1610 * glGet*v() function jump right into a switch statement and
1611 * handle errors there instead of having to check for NULL.
1612 */
1613 static const struct value_desc *
find_value(const char * func,GLenum pname,void ** p,union value * v)1614 find_value(const char *func, GLenum pname, void **p, union value *v)
1615 {
1616 GET_CURRENT_CONTEXT(ctx);
1617 int mask, hash;
1618 const struct value_desc *d;
1619 int api;
1620
1621 *p = NULL;
1622
1623 api = ctx->API;
1624 /* We index into the table_set[] list of per-API hash tables using the API's
1625 * value in the gl_api enum. Since GLES 3 doesn't have an API_OPENGL* enum
1626 * value since it's compatible with GLES2 its entry in table_set[] is at the
1627 * end.
1628 */
1629 STATIC_ASSERT(ARRAY_SIZE(table_set) == API_OPENGL_LAST + 4);
1630 if (_mesa_is_gles2(ctx)) {
1631 if (ctx->Version >= 32)
1632 api = API_OPENGL_LAST + 3;
1633 else if (ctx->Version >= 31)
1634 api = API_OPENGL_LAST + 2;
1635 else if (ctx->Version >= 30)
1636 api = API_OPENGL_LAST + 1;
1637 }
1638 mask = ARRAY_SIZE(table(api)) - 1;
1639 hash = (pname * prime_factor);
1640 while (1) {
1641 int idx = table(api)[hash & mask];
1642
1643 /* If the enum isn't valid, the hash walk ends with index 0,
1644 * pointing to the first entry of values[] which doesn't hold
1645 * any valid enum. */
1646 if (unlikely(idx == 0)) {
1647 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
1648 _mesa_enum_to_string(pname));
1649 return &error_value;
1650 }
1651
1652 d = &values[idx];
1653 if (likely(d->pname == pname))
1654 break;
1655
1656 hash += prime_step;
1657 }
1658
1659 if (unlikely(d->extra && !check_extra(ctx, func, d)))
1660 return &error_value;
1661
1662 switch (d->location) {
1663 case LOC_BUFFER:
1664 *p = ((char *) ctx->DrawBuffer + d->offset);
1665 return d;
1666 case LOC_CONTEXT:
1667 *p = ((char *) ctx + d->offset);
1668 return d;
1669 case LOC_ARRAY:
1670 *p = ((char *) ctx->Array.VAO + d->offset);
1671 return d;
1672 case LOC_TEXUNIT:
1673 if (ctx->Texture.CurrentUnit < ARRAY_SIZE(ctx->Texture.FixedFuncUnit)) {
1674 unsigned index = ctx->Texture.CurrentUnit;
1675 *p = ((char *)&ctx->Texture.FixedFuncUnit[index] + d->offset);
1676 return d;
1677 }
1678 _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s,unit=%d)", func,
1679 _mesa_enum_to_string(pname),
1680 ctx->Texture.CurrentUnit);
1681 return &error_value;
1682 case LOC_CUSTOM:
1683 find_custom_value(ctx, d, v);
1684 *p = v;
1685 return d;
1686 default:
1687 assert(0);
1688 break;
1689 }
1690
1691 /* silence warning */
1692 return &error_value;
1693 }
1694
1695 static const int transpose[] = {
1696 0, 4, 8, 12,
1697 1, 5, 9, 13,
1698 2, 6, 10, 14,
1699 3, 7, 11, 15
1700 };
1701
1702 static GLsizei
get_value_size(enum value_type type,const union value * v)1703 get_value_size(enum value_type type, const union value *v)
1704 {
1705 switch (type) {
1706 case TYPE_INVALID:
1707 return 0;
1708 case TYPE_CONST:
1709 case TYPE_UINT:
1710 case TYPE_INT:
1711 return sizeof(GLint);
1712 case TYPE_INT_2:
1713 case TYPE_UINT_2:
1714 return sizeof(GLint) * 2;
1715 case TYPE_INT_3:
1716 case TYPE_UINT_3:
1717 return sizeof(GLint) * 3;
1718 case TYPE_INT_4:
1719 case TYPE_UINT_4:
1720 return sizeof(GLint) * 4;
1721 case TYPE_INT_N:
1722 return sizeof(GLint) * v->value_int_n.n;
1723 case TYPE_INT64:
1724 return sizeof(GLint64);
1725 break;
1726 case TYPE_ENUM16:
1727 return sizeof(GLenum16);
1728 case TYPE_ENUM:
1729 return sizeof(GLenum);
1730 case TYPE_ENUM_2:
1731 return sizeof(GLenum) * 2;
1732 case TYPE_BOOLEAN:
1733 return sizeof(GLboolean);
1734 case TYPE_UBYTE:
1735 return sizeof(GLubyte);
1736 case TYPE_SHORT:
1737 return sizeof(GLshort);
1738 case TYPE_BIT_0:
1739 case TYPE_BIT_1:
1740 case TYPE_BIT_2:
1741 case TYPE_BIT_3:
1742 case TYPE_BIT_4:
1743 case TYPE_BIT_5:
1744 case TYPE_BIT_6:
1745 case TYPE_BIT_7:
1746 return 1;
1747 case TYPE_FLOAT:
1748 case TYPE_FLOATN:
1749 return sizeof(GLfloat);
1750 case TYPE_FLOAT_2:
1751 case TYPE_FLOATN_2:
1752 return sizeof(GLfloat) * 2;
1753 case TYPE_FLOAT_3:
1754 case TYPE_FLOATN_3:
1755 return sizeof(GLfloat) * 3;
1756 case TYPE_FLOAT_4:
1757 case TYPE_FLOATN_4:
1758 return sizeof(GLfloat) * 4;
1759 case TYPE_FLOAT_8:
1760 return sizeof(GLfloat) * 8;
1761 case TYPE_DOUBLEN:
1762 return sizeof(GLdouble);
1763 case TYPE_DOUBLEN_2:
1764 return sizeof(GLdouble) * 2;
1765 case TYPE_MATRIX:
1766 return sizeof (GLfloat) * 16;
1767 case TYPE_MATRIX_T:
1768 return sizeof (GLfloat) * 16;
1769 default:
1770 assert(!"invalid value_type given for get_value_size()");
1771 return -1;
1772 }
1773 }
1774
1775 void GLAPIENTRY
_mesa_GetBooleanv(GLenum pname,GLboolean * params)1776 _mesa_GetBooleanv(GLenum pname, GLboolean *params)
1777 {
1778 const struct value_desc *d;
1779 union value v;
1780 GLmatrix *m;
1781 int shift, i;
1782 void *p;
1783
1784 d = find_value("glGetBooleanv", pname, &p, &v);
1785 switch (d->type) {
1786 case TYPE_INVALID:
1787 break;
1788 case TYPE_CONST:
1789 params[0] = INT_TO_BOOLEAN(d->offset);
1790 break;
1791
1792 case TYPE_FLOAT_8:
1793 params[7] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[7]);
1794 params[6] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[6]);
1795 params[5] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[5]);
1796 params[4] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[4]);
1797 FALLTHROUGH;
1798 case TYPE_FLOAT_4:
1799 case TYPE_FLOATN_4:
1800 params[3] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[3]);
1801 FALLTHROUGH;
1802 case TYPE_FLOAT_3:
1803 case TYPE_FLOATN_3:
1804 params[2] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[2]);
1805 FALLTHROUGH;
1806 case TYPE_FLOAT_2:
1807 case TYPE_FLOATN_2:
1808 params[1] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[1]);
1809 FALLTHROUGH;
1810 case TYPE_FLOAT:
1811 case TYPE_FLOATN:
1812 params[0] = FLOAT_TO_BOOLEAN(((GLfloat *) p)[0]);
1813 break;
1814
1815 case TYPE_DOUBLEN_2:
1816 params[1] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[1]);
1817 FALLTHROUGH;
1818 case TYPE_DOUBLEN:
1819 params[0] = FLOAT_TO_BOOLEAN(((GLdouble *) p)[0]);
1820 break;
1821
1822 case TYPE_INT_4:
1823 case TYPE_UINT_4:
1824 params[3] = INT_TO_BOOLEAN(((GLint *) p)[3]);
1825 FALLTHROUGH;
1826 case TYPE_INT_3:
1827 case TYPE_UINT_3:
1828 params[2] = INT_TO_BOOLEAN(((GLint *) p)[2]);
1829 FALLTHROUGH;
1830 case TYPE_INT_2:
1831 case TYPE_UINT_2:
1832 case TYPE_ENUM_2:
1833 params[1] = INT_TO_BOOLEAN(((GLint *) p)[1]);
1834 FALLTHROUGH;
1835 case TYPE_INT:
1836 case TYPE_UINT:
1837 case TYPE_ENUM:
1838 params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
1839 break;
1840
1841 case TYPE_ENUM16:
1842 params[0] = INT_TO_BOOLEAN(((GLenum16 *) p)[0]);
1843 break;
1844
1845 case TYPE_INT_N:
1846 for (i = 0; i < v.value_int_n.n; i++)
1847 params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
1848 break;
1849
1850 case TYPE_INT64:
1851 params[0] = INT64_TO_BOOLEAN(((GLint64 *) p)[0]);
1852 break;
1853
1854 case TYPE_BOOLEAN:
1855 params[0] = ((GLboolean*) p)[0];
1856 break;
1857
1858 case TYPE_UBYTE:
1859 params[0] = INT_TO_BOOLEAN(((GLubyte *) p)[0]);
1860 break;
1861
1862 case TYPE_SHORT:
1863 params[0] = INT_TO_BOOLEAN(((GLshort *) p)[0]);
1864 break;
1865
1866 case TYPE_MATRIX:
1867 m = *(GLmatrix **) p;
1868 for (i = 0; i < 16; i++)
1869 params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
1870 break;
1871
1872 case TYPE_MATRIX_T:
1873 m = *(GLmatrix **) p;
1874 for (i = 0; i < 16; i++)
1875 params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
1876 break;
1877
1878 case TYPE_BIT_0:
1879 case TYPE_BIT_1:
1880 case TYPE_BIT_2:
1881 case TYPE_BIT_3:
1882 case TYPE_BIT_4:
1883 case TYPE_BIT_5:
1884 case TYPE_BIT_6:
1885 case TYPE_BIT_7:
1886 shift = d->type - TYPE_BIT_0;
1887 params[0] = (*(GLbitfield *) p >> shift) & 1;
1888 break;
1889 }
1890 }
1891
1892 void GLAPIENTRY
_mesa_GetFloatv(GLenum pname,GLfloat * params)1893 _mesa_GetFloatv(GLenum pname, GLfloat *params)
1894 {
1895 const struct value_desc *d;
1896 union value v;
1897 GLmatrix *m;
1898 int shift, i;
1899 void *p;
1900
1901 d = find_value("glGetFloatv", pname, &p, &v);
1902 switch (d->type) {
1903 case TYPE_INVALID:
1904 break;
1905 case TYPE_CONST:
1906 params[0] = (GLfloat) d->offset;
1907 break;
1908
1909 case TYPE_FLOAT_8:
1910 params[7] = ((GLfloat *) p)[7];
1911 params[6] = ((GLfloat *) p)[6];
1912 params[5] = ((GLfloat *) p)[5];
1913 params[4] = ((GLfloat *) p)[4];
1914 FALLTHROUGH;
1915 case TYPE_FLOAT_4:
1916 case TYPE_FLOATN_4:
1917 params[3] = ((GLfloat *) p)[3];
1918 FALLTHROUGH;
1919 case TYPE_FLOAT_3:
1920 case TYPE_FLOATN_3:
1921 params[2] = ((GLfloat *) p)[2];
1922 FALLTHROUGH;
1923 case TYPE_FLOAT_2:
1924 case TYPE_FLOATN_2:
1925 params[1] = ((GLfloat *) p)[1];
1926 FALLTHROUGH;
1927 case TYPE_FLOAT:
1928 case TYPE_FLOATN:
1929 params[0] = ((GLfloat *) p)[0];
1930 break;
1931
1932 case TYPE_DOUBLEN_2:
1933 params[1] = (GLfloat) (((GLdouble *) p)[1]);
1934 FALLTHROUGH;
1935 case TYPE_DOUBLEN:
1936 params[0] = (GLfloat) (((GLdouble *) p)[0]);
1937 break;
1938
1939 case TYPE_INT_4:
1940 params[3] = (GLfloat) (((GLint *) p)[3]);
1941 FALLTHROUGH;
1942 case TYPE_INT_3:
1943 params[2] = (GLfloat) (((GLint *) p)[2]);
1944 FALLTHROUGH;
1945 case TYPE_INT_2:
1946 case TYPE_ENUM_2:
1947 params[1] = (GLfloat) (((GLint *) p)[1]);
1948 FALLTHROUGH;
1949 case TYPE_INT:
1950 case TYPE_ENUM:
1951 params[0] = (GLfloat) (((GLint *) p)[0]);
1952 break;
1953
1954 case TYPE_ENUM16:
1955 params[0] = (GLfloat) (((GLenum16 *) p)[0]);
1956 break;
1957
1958 case TYPE_INT_N:
1959 for (i = 0; i < v.value_int_n.n; i++)
1960 params[i] = (GLfloat) v.value_int_n.ints[i];
1961 break;
1962
1963 case TYPE_UINT_4:
1964 params[3] = (GLfloat) (((GLuint *) p)[3]);
1965 FALLTHROUGH;
1966 case TYPE_UINT_3:
1967 params[2] = (GLfloat) (((GLuint *) p)[2]);
1968 FALLTHROUGH;
1969 case TYPE_UINT_2:
1970 params[1] = (GLfloat) (((GLuint *) p)[1]);
1971 FALLTHROUGH;
1972 case TYPE_UINT:
1973 params[0] = (GLfloat) (((GLuint *) p)[0]);
1974 break;
1975
1976 case TYPE_INT64:
1977 params[0] = (GLfloat) (((GLint64 *) p)[0]);
1978 break;
1979
1980 case TYPE_BOOLEAN:
1981 params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
1982 break;
1983
1984 case TYPE_UBYTE:
1985 params[0] = (GLfloat) ((GLubyte *) p)[0];
1986 break;
1987
1988 case TYPE_SHORT:
1989 params[0] = (GLfloat) ((GLshort *) p)[0];
1990 break;
1991
1992 case TYPE_MATRIX:
1993 m = *(GLmatrix **) p;
1994 for (i = 0; i < 16; i++)
1995 params[i] = m->m[i];
1996 break;
1997
1998 case TYPE_MATRIX_T:
1999 m = *(GLmatrix **) p;
2000 for (i = 0; i < 16; i++)
2001 params[i] = m->m[transpose[i]];
2002 break;
2003
2004 case TYPE_BIT_0:
2005 case TYPE_BIT_1:
2006 case TYPE_BIT_2:
2007 case TYPE_BIT_3:
2008 case TYPE_BIT_4:
2009 case TYPE_BIT_5:
2010 case TYPE_BIT_6:
2011 case TYPE_BIT_7:
2012 shift = d->type - TYPE_BIT_0;
2013 params[0] = BOOLEAN_TO_FLOAT((*(GLbitfield *) p >> shift) & 1);
2014 break;
2015 }
2016 }
2017
2018 void GLAPIENTRY
_mesa_GetIntegerv(GLenum pname,GLint * params)2019 _mesa_GetIntegerv(GLenum pname, GLint *params)
2020 {
2021 const struct value_desc *d;
2022 union value v;
2023 GLmatrix *m;
2024 int shift, i;
2025 void *p;
2026
2027 d = find_value("glGetIntegerv", pname, &p, &v);
2028 switch (d->type) {
2029 case TYPE_INVALID:
2030 break;
2031 case TYPE_CONST:
2032 params[0] = d->offset;
2033 break;
2034
2035 case TYPE_FLOAT_8:
2036 params[7] = lroundf(((GLfloat *) p)[7]);
2037 params[6] = lroundf(((GLfloat *) p)[6]);
2038 params[5] = lroundf(((GLfloat *) p)[5]);
2039 params[4] = lroundf(((GLfloat *) p)[4]);
2040 FALLTHROUGH;
2041 case TYPE_FLOAT_4:
2042 params[3] = lroundf(((GLfloat *) p)[3]);
2043 FALLTHROUGH;
2044 case TYPE_FLOAT_3:
2045 params[2] = lroundf(((GLfloat *) p)[2]);
2046 FALLTHROUGH;
2047 case TYPE_FLOAT_2:
2048 params[1] = lroundf(((GLfloat *) p)[1]);
2049 FALLTHROUGH;
2050 case TYPE_FLOAT:
2051 params[0] = lroundf(((GLfloat *) p)[0]);
2052 break;
2053
2054 case TYPE_FLOATN_4:
2055 params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
2056 FALLTHROUGH;
2057 case TYPE_FLOATN_3:
2058 params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
2059 FALLTHROUGH;
2060 case TYPE_FLOATN_2:
2061 params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
2062 FALLTHROUGH;
2063 case TYPE_FLOATN:
2064 params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
2065 break;
2066
2067 case TYPE_DOUBLEN_2:
2068 params[1] = FLOAT_TO_INT(((GLdouble *) p)[1]);
2069 FALLTHROUGH;
2070 case TYPE_DOUBLEN:
2071 params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
2072 break;
2073
2074 case TYPE_INT_4:
2075 params[3] = ((GLint *) p)[3];
2076 FALLTHROUGH;
2077 case TYPE_INT_3:
2078 params[2] = ((GLint *) p)[2];
2079 FALLTHROUGH;
2080 case TYPE_INT_2:
2081 case TYPE_ENUM_2:
2082 params[1] = ((GLint *) p)[1];
2083 FALLTHROUGH;
2084 case TYPE_INT:
2085 case TYPE_ENUM:
2086 params[0] = ((GLint *) p)[0];
2087 break;
2088
2089 case TYPE_UINT_4:
2090 params[3] = MIN2(((GLuint *) p)[3], INT_MAX);
2091 FALLTHROUGH;
2092 case TYPE_UINT_3:
2093 params[2] = MIN2(((GLuint *) p)[2], INT_MAX);
2094 FALLTHROUGH;
2095 case TYPE_UINT_2:
2096 params[1] = MIN2(((GLuint *) p)[1], INT_MAX);
2097 FALLTHROUGH;
2098 case TYPE_UINT:
2099 params[0] = MIN2(((GLuint *) p)[0], INT_MAX);
2100 break;
2101
2102 case TYPE_ENUM16:
2103 params[0] = ((GLenum16 *) p)[0];
2104 break;
2105
2106 case TYPE_INT_N:
2107 for (i = 0; i < v.value_int_n.n; i++)
2108 params[i] = v.value_int_n.ints[i];
2109 break;
2110
2111 case TYPE_INT64:
2112 params[0] = INT64_TO_INT(((GLint64 *) p)[0]);
2113 break;
2114
2115 case TYPE_BOOLEAN:
2116 params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
2117 break;
2118
2119 case TYPE_UBYTE:
2120 params[0] = ((GLubyte *) p)[0];
2121 break;
2122
2123 case TYPE_SHORT:
2124 params[0] = ((GLshort *) p)[0];
2125 break;
2126
2127 case TYPE_MATRIX:
2128 m = *(GLmatrix **) p;
2129 for (i = 0; i < 16; i++)
2130 params[i] = FLOAT_TO_INT(m->m[i]);
2131 break;
2132
2133 case TYPE_MATRIX_T:
2134 m = *(GLmatrix **) p;
2135 for (i = 0; i < 16; i++)
2136 params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
2137 break;
2138
2139 case TYPE_BIT_0:
2140 case TYPE_BIT_1:
2141 case TYPE_BIT_2:
2142 case TYPE_BIT_3:
2143 case TYPE_BIT_4:
2144 case TYPE_BIT_5:
2145 case TYPE_BIT_6:
2146 case TYPE_BIT_7:
2147 shift = d->type - TYPE_BIT_0;
2148 params[0] = (*(GLbitfield *) p >> shift) & 1;
2149 break;
2150 }
2151 }
2152
2153 void GLAPIENTRY
_mesa_GetInteger64v(GLenum pname,GLint64 * params)2154 _mesa_GetInteger64v(GLenum pname, GLint64 *params)
2155 {
2156 const struct value_desc *d;
2157 union value v;
2158 GLmatrix *m;
2159 int shift, i;
2160 void *p;
2161
2162 d = find_value("glGetInteger64v", pname, &p, &v);
2163 switch (d->type) {
2164 case TYPE_INVALID:
2165 break;
2166 case TYPE_CONST:
2167 params[0] = d->offset;
2168 break;
2169
2170 case TYPE_FLOAT_8:
2171 params[7] = llround(((GLfloat *) p)[7]);
2172 params[6] = llround(((GLfloat *) p)[6]);
2173 params[5] = llround(((GLfloat *) p)[5]);
2174 params[4] = llround(((GLfloat *) p)[4]);
2175 FALLTHROUGH;
2176 case TYPE_FLOAT_4:
2177 params[3] = llround(((GLfloat *) p)[3]);
2178 FALLTHROUGH;
2179 case TYPE_FLOAT_3:
2180 params[2] = llround(((GLfloat *) p)[2]);
2181 FALLTHROUGH;
2182 case TYPE_FLOAT_2:
2183 params[1] = llround(((GLfloat *) p)[1]);
2184 FALLTHROUGH;
2185 case TYPE_FLOAT:
2186 params[0] = llround(((GLfloat *) p)[0]);
2187 break;
2188
2189 case TYPE_FLOATN_4:
2190 params[3] = FLOAT_TO_INT(((GLfloat *) p)[3]);
2191 FALLTHROUGH;
2192 case TYPE_FLOATN_3:
2193 params[2] = FLOAT_TO_INT(((GLfloat *) p)[2]);
2194 FALLTHROUGH;
2195 case TYPE_FLOATN_2:
2196 params[1] = FLOAT_TO_INT(((GLfloat *) p)[1]);
2197 FALLTHROUGH;
2198 case TYPE_FLOATN:
2199 params[0] = FLOAT_TO_INT(((GLfloat *) p)[0]);
2200 break;
2201
2202 case TYPE_DOUBLEN_2:
2203 params[1] = FLOAT_TO_INT(((GLdouble *) p)[1]);
2204 FALLTHROUGH;
2205 case TYPE_DOUBLEN:
2206 params[0] = FLOAT_TO_INT(((GLdouble *) p)[0]);
2207 break;
2208
2209 case TYPE_INT_4:
2210 params[3] = ((GLint *) p)[3];
2211 FALLTHROUGH;
2212 case TYPE_INT_3:
2213 params[2] = ((GLint *) p)[2];
2214 FALLTHROUGH;
2215 case TYPE_INT_2:
2216 case TYPE_ENUM_2:
2217 params[1] = ((GLint *) p)[1];
2218 FALLTHROUGH;
2219 case TYPE_INT:
2220 case TYPE_ENUM:
2221 params[0] = ((GLint *) p)[0];
2222 break;
2223
2224 case TYPE_ENUM16:
2225 params[0] = ((GLenum16 *) p)[0];
2226 break;
2227
2228 case TYPE_INT_N:
2229 for (i = 0; i < v.value_int_n.n; i++)
2230 params[i] = v.value_int_n.ints[i];
2231 break;
2232
2233 case TYPE_UINT_4:
2234 params[3] = ((GLuint *) p)[3];
2235 FALLTHROUGH;
2236 case TYPE_UINT_3:
2237 params[2] = ((GLuint *) p)[2];
2238 FALLTHROUGH;
2239 case TYPE_UINT_2:
2240 params[1] = ((GLuint *) p)[1];
2241 FALLTHROUGH;
2242 case TYPE_UINT:
2243 params[0] = ((GLuint *) p)[0];
2244 break;
2245
2246 case TYPE_INT64:
2247 params[0] = ((GLint64 *) p)[0];
2248 break;
2249
2250 case TYPE_BOOLEAN:
2251 params[0] = ((GLboolean*) p)[0];
2252 break;
2253
2254 case TYPE_MATRIX:
2255 m = *(GLmatrix **) p;
2256 for (i = 0; i < 16; i++)
2257 params[i] = FLOAT_TO_INT64(m->m[i]);
2258 break;
2259
2260 case TYPE_MATRIX_T:
2261 m = *(GLmatrix **) p;
2262 for (i = 0; i < 16; i++)
2263 params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
2264 break;
2265
2266 case TYPE_BIT_0:
2267 case TYPE_BIT_1:
2268 case TYPE_BIT_2:
2269 case TYPE_BIT_3:
2270 case TYPE_BIT_4:
2271 case TYPE_BIT_5:
2272 case TYPE_BIT_6:
2273 case TYPE_BIT_7:
2274 shift = d->type - TYPE_BIT_0;
2275 params[0] = (*(GLbitfield *) p >> shift) & 1;
2276 break;
2277 }
2278 }
2279
2280 void GLAPIENTRY
_mesa_GetDoublev(GLenum pname,GLdouble * params)2281 _mesa_GetDoublev(GLenum pname, GLdouble *params)
2282 {
2283 const struct value_desc *d;
2284 union value v;
2285 GLmatrix *m;
2286 int shift, i;
2287 void *p;
2288
2289 d = find_value("glGetDoublev", pname, &p, &v);
2290 switch (d->type) {
2291 case TYPE_INVALID:
2292 break;
2293 case TYPE_CONST:
2294 params[0] = d->offset;
2295 break;
2296
2297 case TYPE_FLOAT_8:
2298 params[7] = ((GLfloat *) p)[7];
2299 params[6] = ((GLfloat *) p)[6];
2300 params[5] = ((GLfloat *) p)[5];
2301 params[4] = ((GLfloat *) p)[4];
2302 FALLTHROUGH;
2303 case TYPE_FLOAT_4:
2304 case TYPE_FLOATN_4:
2305 params[3] = ((GLfloat *) p)[3];
2306 FALLTHROUGH;
2307 case TYPE_FLOAT_3:
2308 case TYPE_FLOATN_3:
2309 params[2] = ((GLfloat *) p)[2];
2310 FALLTHROUGH;
2311 case TYPE_FLOAT_2:
2312 case TYPE_FLOATN_2:
2313 params[1] = ((GLfloat *) p)[1];
2314 FALLTHROUGH;
2315 case TYPE_FLOAT:
2316 case TYPE_FLOATN:
2317 params[0] = ((GLfloat *) p)[0];
2318 break;
2319
2320 case TYPE_DOUBLEN_2:
2321 params[1] = ((GLdouble *) p)[1];
2322 FALLTHROUGH;
2323 case TYPE_DOUBLEN:
2324 params[0] = ((GLdouble *) p)[0];
2325 break;
2326
2327 case TYPE_INT_4:
2328 params[3] = ((GLint *) p)[3];
2329 FALLTHROUGH;
2330 case TYPE_INT_3:
2331 params[2] = ((GLint *) p)[2];
2332 FALLTHROUGH;
2333 case TYPE_INT_2:
2334 case TYPE_ENUM_2:
2335 params[1] = ((GLint *) p)[1];
2336 FALLTHROUGH;
2337 case TYPE_INT:
2338 case TYPE_ENUM:
2339 params[0] = ((GLint *) p)[0];
2340 break;
2341
2342 case TYPE_ENUM16:
2343 params[0] = ((GLenum16 *) p)[0];
2344 break;
2345
2346 case TYPE_INT_N:
2347 for (i = 0; i < v.value_int_n.n; i++)
2348 params[i] = v.value_int_n.ints[i];
2349 break;
2350
2351 case TYPE_UINT_4:
2352 params[3] = ((GLuint *) p)[3];
2353 FALLTHROUGH;
2354 case TYPE_UINT_3:
2355 params[2] = ((GLuint *) p)[2];
2356 FALLTHROUGH;
2357 case TYPE_UINT_2:
2358 params[1] = ((GLuint *) p)[1];
2359 FALLTHROUGH;
2360 case TYPE_UINT:
2361 params[0] = ((GLuint *) p)[0];
2362 break;
2363
2364 case TYPE_INT64:
2365 params[0] = (GLdouble) (((GLint64 *) p)[0]);
2366 break;
2367
2368 case TYPE_BOOLEAN:
2369 params[0] = *(GLboolean*) p;
2370 break;
2371
2372 case TYPE_UBYTE:
2373 params[0] = ((GLubyte *) p)[0];
2374 break;
2375
2376 case TYPE_SHORT:
2377 params[0] = ((GLshort *) p)[0];
2378 break;
2379
2380 case TYPE_MATRIX:
2381 m = *(GLmatrix **) p;
2382 for (i = 0; i < 16; i++)
2383 params[i] = m->m[i];
2384 break;
2385
2386 case TYPE_MATRIX_T:
2387 m = *(GLmatrix **) p;
2388 for (i = 0; i < 16; i++)
2389 params[i] = m->m[transpose[i]];
2390 break;
2391
2392 case TYPE_BIT_0:
2393 case TYPE_BIT_1:
2394 case TYPE_BIT_2:
2395 case TYPE_BIT_3:
2396 case TYPE_BIT_4:
2397 case TYPE_BIT_5:
2398 case TYPE_BIT_6:
2399 case TYPE_BIT_7:
2400 shift = d->type - TYPE_BIT_0;
2401 params[0] = (*(GLbitfield *) p >> shift) & 1;
2402 break;
2403 }
2404 }
2405
2406 void GLAPIENTRY
_mesa_GetUnsignedBytevEXT(GLenum pname,GLubyte * data)2407 _mesa_GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
2408 {
2409 const struct value_desc *d;
2410 union value v;
2411 int shift;
2412 void *p = NULL;
2413 GLsizei size;
2414 const char *func = "glGetUnsignedBytevEXT";
2415
2416 GET_CURRENT_CONTEXT(ctx);
2417
2418 if (!_mesa_has_EXT_memory_object(ctx)) {
2419 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
2420 return;
2421 }
2422
2423 d = find_value(func, pname, &p, &v);
2424 size = get_value_size(d->type, &v);
2425
2426 switch (d->type) {
2427 case TYPE_BIT_0:
2428 case TYPE_BIT_1:
2429 case TYPE_BIT_2:
2430 case TYPE_BIT_3:
2431 case TYPE_BIT_4:
2432 case TYPE_BIT_5:
2433 case TYPE_BIT_6:
2434 case TYPE_BIT_7:
2435 shift = d->type - TYPE_BIT_0;
2436 data[0] = (*(GLbitfield *) p >> shift) & 1;
2437 break;
2438 case TYPE_CONST:
2439 memcpy(data, &d->offset, size);
2440 break;
2441 case TYPE_INT_N:
2442 memcpy(data, &v.value_int_n.ints, size);
2443 break;
2444 case TYPE_UINT:
2445 case TYPE_INT:
2446 case TYPE_INT_2:
2447 case TYPE_UINT_2:
2448 case TYPE_INT_3:
2449 case TYPE_UINT_3:
2450 case TYPE_INT_4:
2451 case TYPE_UINT_4:
2452 case TYPE_INT64:
2453 case TYPE_ENUM:
2454 case TYPE_ENUM_2:
2455 case TYPE_BOOLEAN:
2456 case TYPE_UBYTE:
2457 case TYPE_SHORT:
2458 case TYPE_FLOAT:
2459 case TYPE_FLOATN:
2460 case TYPE_FLOAT_2:
2461 case TYPE_FLOATN_2:
2462 case TYPE_FLOAT_3:
2463 case TYPE_FLOATN_3:
2464 case TYPE_FLOAT_4:
2465 case TYPE_FLOATN_4:
2466 case TYPE_FLOAT_8:
2467 case TYPE_DOUBLEN:
2468 case TYPE_DOUBLEN_2:
2469 case TYPE_MATRIX:
2470 case TYPE_MATRIX_T:
2471 memcpy(data, p, size);
2472 break;
2473 case TYPE_ENUM16: {
2474 GLenum e = *(GLenum16 *)p;
2475 memcpy(data, &e, sizeof(e));
2476 break;
2477 }
2478 default:
2479 break; /* nothing - GL error was recorded */
2480 }
2481 }
2482
2483 /**
2484 * Convert a GL texture binding enum such as GL_TEXTURE_BINDING_2D
2485 * into the corresponding Mesa texture target index.
2486 * \return TEXTURE_x_INDEX or -1 if binding is invalid
2487 */
2488 static int
tex_binding_to_index(const struct gl_context * ctx,GLenum binding)2489 tex_binding_to_index(const struct gl_context *ctx, GLenum binding)
2490 {
2491 switch (binding) {
2492 case GL_TEXTURE_BINDING_1D:
2493 return _mesa_is_desktop_gl(ctx) ? TEXTURE_1D_INDEX : -1;
2494 case GL_TEXTURE_BINDING_2D:
2495 return TEXTURE_2D_INDEX;
2496 case GL_TEXTURE_BINDING_3D:
2497 return (ctx->API != API_OPENGLES &&
2498 !(_mesa_is_gles2(ctx) && !ctx->Extensions.OES_texture_3D))
2499 ? TEXTURE_3D_INDEX : -1;
2500 case GL_TEXTURE_BINDING_CUBE_MAP:
2501 return TEXTURE_CUBE_INDEX;
2502 case GL_TEXTURE_BINDING_RECTANGLE:
2503 return _mesa_is_desktop_gl(ctx) && ctx->Extensions.NV_texture_rectangle
2504 ? TEXTURE_RECT_INDEX : -1;
2505 case GL_TEXTURE_BINDING_1D_ARRAY:
2506 return _mesa_is_desktop_gl(ctx) && ctx->Extensions.EXT_texture_array
2507 ? TEXTURE_1D_ARRAY_INDEX : -1;
2508 case GL_TEXTURE_BINDING_2D_ARRAY:
2509 return (_mesa_is_desktop_gl(ctx) && ctx->Extensions.EXT_texture_array)
2510 || _mesa_is_gles3(ctx)
2511 ? TEXTURE_2D_ARRAY_INDEX : -1;
2512 case GL_TEXTURE_BINDING_BUFFER:
2513 return (_mesa_has_ARB_texture_buffer_object(ctx) ||
2514 _mesa_has_OES_texture_buffer(ctx)) ?
2515 TEXTURE_BUFFER_INDEX : -1;
2516 case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
2517 return _mesa_has_texture_cube_map_array(ctx)
2518 ? TEXTURE_CUBE_ARRAY_INDEX : -1;
2519 case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
2520 return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_multisample
2521 ? TEXTURE_2D_MULTISAMPLE_INDEX : -1;
2522 case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
2523 return _mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_texture_multisample
2524 ? TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX : -1;
2525 default:
2526 return -1;
2527 }
2528 }
2529
2530 static enum value_type
find_value_indexed(const char * func,GLenum pname,GLuint index,union value * v)2531 find_value_indexed(const char *func, GLenum pname, GLuint index, union value *v)
2532 {
2533 GET_CURRENT_CONTEXT(ctx);
2534 struct gl_buffer_object *buf;
2535
2536 switch (pname) {
2537
2538 case GL_BLEND:
2539 if (index >= ctx->Const.MaxDrawBuffers)
2540 goto invalid_value;
2541 if (!ctx->Extensions.EXT_draw_buffers2)
2542 goto invalid_enum;
2543 v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
2544 return TYPE_INT;
2545
2546 case GL_BLEND_SRC:
2547 FALLTHROUGH;
2548 case GL_BLEND_SRC_RGB:
2549 if (index >= ctx->Const.MaxDrawBuffers)
2550 goto invalid_value;
2551 if (!ctx->Extensions.ARB_draw_buffers_blend)
2552 goto invalid_enum;
2553 v->value_int = ctx->Color.Blend[index].SrcRGB;
2554 return TYPE_INT;
2555 case GL_BLEND_SRC_ALPHA:
2556 if (index >= ctx->Const.MaxDrawBuffers)
2557 goto invalid_value;
2558 if (!ctx->Extensions.ARB_draw_buffers_blend)
2559 goto invalid_enum;
2560 v->value_int = ctx->Color.Blend[index].SrcA;
2561 return TYPE_INT;
2562 case GL_BLEND_DST:
2563 FALLTHROUGH;
2564 case GL_BLEND_DST_RGB:
2565 if (index >= ctx->Const.MaxDrawBuffers)
2566 goto invalid_value;
2567 if (!ctx->Extensions.ARB_draw_buffers_blend)
2568 goto invalid_enum;
2569 v->value_int = ctx->Color.Blend[index].DstRGB;
2570 return TYPE_INT;
2571 case GL_BLEND_DST_ALPHA:
2572 if (index >= ctx->Const.MaxDrawBuffers)
2573 goto invalid_value;
2574 if (!ctx->Extensions.ARB_draw_buffers_blend)
2575 goto invalid_enum;
2576 v->value_int = ctx->Color.Blend[index].DstA;
2577 return TYPE_INT;
2578 case GL_BLEND_EQUATION_RGB:
2579 if (index >= ctx->Const.MaxDrawBuffers)
2580 goto invalid_value;
2581 if (!ctx->Extensions.ARB_draw_buffers_blend)
2582 goto invalid_enum;
2583 v->value_int = ctx->Color.Blend[index].EquationRGB;
2584 return TYPE_INT;
2585 case GL_BLEND_EQUATION_ALPHA:
2586 if (index >= ctx->Const.MaxDrawBuffers)
2587 goto invalid_value;
2588 if (!ctx->Extensions.ARB_draw_buffers_blend)
2589 goto invalid_enum;
2590 v->value_int = ctx->Color.Blend[index].EquationA;
2591 return TYPE_INT;
2592
2593 case GL_COLOR_WRITEMASK:
2594 if (index >= ctx->Const.MaxDrawBuffers)
2595 goto invalid_value;
2596 if (!ctx->Extensions.EXT_draw_buffers2)
2597 goto invalid_enum;
2598 v->value_int_4[0] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 0);
2599 v->value_int_4[1] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 1);
2600 v->value_int_4[2] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 2);
2601 v->value_int_4[3] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 3);
2602 return TYPE_INT_4;
2603
2604 case GL_SCISSOR_BOX:
2605 if (index >= ctx->Const.MaxViewports)
2606 goto invalid_value;
2607 v->value_int_4[0] = ctx->Scissor.ScissorArray[index].X;
2608 v->value_int_4[1] = ctx->Scissor.ScissorArray[index].Y;
2609 v->value_int_4[2] = ctx->Scissor.ScissorArray[index].Width;
2610 v->value_int_4[3] = ctx->Scissor.ScissorArray[index].Height;
2611 return TYPE_INT_4;
2612
2613 case GL_WINDOW_RECTANGLE_EXT:
2614 if (!ctx->Extensions.EXT_window_rectangles)
2615 goto invalid_enum;
2616 if (index >= ctx->Const.MaxWindowRectangles)
2617 goto invalid_value;
2618 v->value_int_4[0] = ctx->Scissor.WindowRects[index].X;
2619 v->value_int_4[1] = ctx->Scissor.WindowRects[index].Y;
2620 v->value_int_4[2] = ctx->Scissor.WindowRects[index].Width;
2621 v->value_int_4[3] = ctx->Scissor.WindowRects[index].Height;
2622 return TYPE_INT_4;
2623
2624 case GL_VIEWPORT:
2625 if (index >= ctx->Const.MaxViewports)
2626 goto invalid_value;
2627 v->value_float_4[0] = ctx->ViewportArray[index].X;
2628 v->value_float_4[1] = ctx->ViewportArray[index].Y;
2629 v->value_float_4[2] = ctx->ViewportArray[index].Width;
2630 v->value_float_4[3] = ctx->ViewportArray[index].Height;
2631 return TYPE_FLOAT_4;
2632
2633 case GL_DEPTH_RANGE:
2634 if (index >= ctx->Const.MaxViewports)
2635 goto invalid_value;
2636 v->value_double_2[0] = ctx->ViewportArray[index].Near;
2637 v->value_double_2[1] = ctx->ViewportArray[index].Far;
2638 return TYPE_DOUBLEN_2;
2639
2640 case GL_TRANSFORM_FEEDBACK_BUFFER_START:
2641 if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2642 goto invalid_value;
2643 if (!ctx->Extensions.EXT_transform_feedback)
2644 goto invalid_enum;
2645 v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
2646 return TYPE_INT64;
2647
2648 case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
2649 if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2650 goto invalid_value;
2651 if (!ctx->Extensions.EXT_transform_feedback)
2652 goto invalid_enum;
2653 v->value_int64
2654 = ctx->TransformFeedback.CurrentObject->RequestedSize[index];
2655 return TYPE_INT64;
2656
2657 case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
2658 if (index >= ctx->Const.MaxTransformFeedbackBuffers)
2659 goto invalid_value;
2660 if (!ctx->Extensions.EXT_transform_feedback)
2661 goto invalid_enum;
2662 v->value_int = ctx->TransformFeedback.CurrentObject->BufferNames[index];
2663 return TYPE_INT;
2664
2665 case GL_UNIFORM_BUFFER_BINDING:
2666 if (index >= ctx->Const.MaxUniformBufferBindings)
2667 goto invalid_value;
2668 if (!ctx->Extensions.ARB_uniform_buffer_object)
2669 goto invalid_enum;
2670 buf = ctx->UniformBufferBindings[index].BufferObject;
2671 v->value_int = buf ? buf->Name : 0;
2672 return TYPE_INT;
2673
2674 case GL_UNIFORM_BUFFER_START:
2675 if (index >= ctx->Const.MaxUniformBufferBindings)
2676 goto invalid_value;
2677 if (!ctx->Extensions.ARB_uniform_buffer_object)
2678 goto invalid_enum;
2679 v->value_int = ctx->UniformBufferBindings[index].Offset < 0 ? 0 :
2680 ctx->UniformBufferBindings[index].Offset;
2681 return TYPE_INT;
2682
2683 case GL_UNIFORM_BUFFER_SIZE:
2684 if (index >= ctx->Const.MaxUniformBufferBindings)
2685 goto invalid_value;
2686 if (!ctx->Extensions.ARB_uniform_buffer_object)
2687 goto invalid_enum;
2688 v->value_int = ctx->UniformBufferBindings[index].Size < 0 ? 0 :
2689 ctx->UniformBufferBindings[index].Size;
2690 return TYPE_INT;
2691
2692 /* ARB_shader_storage_buffer_object */
2693 case GL_SHADER_STORAGE_BUFFER_BINDING:
2694 if (!ctx->Extensions.ARB_shader_storage_buffer_object && !_mesa_is_gles31(ctx))
2695 goto invalid_enum;
2696 if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2697 goto invalid_value;
2698 buf = ctx->ShaderStorageBufferBindings[index].BufferObject;
2699 v->value_int = buf ? buf->Name : 0;
2700 return TYPE_INT;
2701
2702 case GL_SHADER_STORAGE_BUFFER_START:
2703 if (!ctx->Extensions.ARB_shader_storage_buffer_object && !_mesa_is_gles31(ctx))
2704 goto invalid_enum;
2705 if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2706 goto invalid_value;
2707 v->value_int = ctx->ShaderStorageBufferBindings[index].Offset < 0 ? 0 :
2708 ctx->ShaderStorageBufferBindings[index].Offset;
2709 return TYPE_INT;
2710
2711 case GL_SHADER_STORAGE_BUFFER_SIZE:
2712 if (!ctx->Extensions.ARB_shader_storage_buffer_object && !_mesa_is_gles31(ctx))
2713 goto invalid_enum;
2714 if (index >= ctx->Const.MaxShaderStorageBufferBindings)
2715 goto invalid_value;
2716 v->value_int = ctx->ShaderStorageBufferBindings[index].Size < 0 ? 0 :
2717 ctx->ShaderStorageBufferBindings[index].Size;
2718 return TYPE_INT;
2719
2720 /* ARB_texture_multisample / GL3.2 */
2721 case GL_SAMPLE_MASK_VALUE:
2722 if (index != 0)
2723 goto invalid_value;
2724 if (!ctx->Extensions.ARB_texture_multisample)
2725 goto invalid_enum;
2726 v->value_int = ctx->Multisample.SampleMaskValue;
2727 return TYPE_INT;
2728
2729 case GL_ATOMIC_COUNTER_BUFFER_BINDING:
2730 if (!ctx->Extensions.ARB_shader_atomic_counters && !_mesa_is_gles31(ctx))
2731 goto invalid_enum;
2732 if (index >= ctx->Const.MaxAtomicBufferBindings)
2733 goto invalid_value;
2734 buf = ctx->AtomicBufferBindings[index].BufferObject;
2735 v->value_int = buf ? buf->Name : 0;
2736 return TYPE_INT;
2737
2738 case GL_ATOMIC_COUNTER_BUFFER_START:
2739 if (!ctx->Extensions.ARB_shader_atomic_counters && !_mesa_is_gles31(ctx))
2740 goto invalid_enum;
2741 if (index >= ctx->Const.MaxAtomicBufferBindings)
2742 goto invalid_value;
2743 v->value_int64 = ctx->AtomicBufferBindings[index].Offset < 0 ? 0 :
2744 ctx->AtomicBufferBindings[index].Offset;
2745 return TYPE_INT64;
2746
2747 case GL_ATOMIC_COUNTER_BUFFER_SIZE:
2748 if (!ctx->Extensions.ARB_shader_atomic_counters && !_mesa_is_gles31(ctx))
2749 goto invalid_enum;
2750 if (index >= ctx->Const.MaxAtomicBufferBindings)
2751 goto invalid_value;
2752 v->value_int64 = ctx->AtomicBufferBindings[index].Size < 0 ? 0 :
2753 ctx->AtomicBufferBindings[index].Size;
2754 return TYPE_INT64;
2755
2756 case GL_VERTEX_BINDING_DIVISOR:
2757 if ((!_mesa_is_desktop_gl(ctx) || !ctx->Extensions.ARB_instanced_arrays) &&
2758 !_mesa_is_gles31(ctx))
2759 goto invalid_enum;
2760 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2761 goto invalid_value;
2762 v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor;
2763 return TYPE_INT;
2764
2765 case GL_VERTEX_BINDING_OFFSET:
2766 if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles31(ctx))
2767 goto invalid_enum;
2768 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2769 goto invalid_value;
2770 v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset;
2771 return TYPE_INT;
2772
2773 case GL_VERTEX_BINDING_STRIDE:
2774 if (!_mesa_is_desktop_gl(ctx) && !_mesa_is_gles31(ctx))
2775 goto invalid_enum;
2776 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2777 goto invalid_value;
2778 v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].Stride;
2779 return TYPE_INT;
2780
2781 case GL_VERTEX_BINDING_BUFFER:
2782 if (_mesa_is_gles2(ctx) && ctx->Version < 31)
2783 goto invalid_enum;
2784 if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
2785 goto invalid_value;
2786 buf = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj;
2787 v->value_int = buf ? buf->Name : 0;
2788 return TYPE_INT;
2789
2790 /* ARB_shader_image_load_store */
2791 case GL_IMAGE_BINDING_NAME: {
2792 struct gl_texture_object *t;
2793
2794 if (!ctx->Extensions.ARB_shader_image_load_store && !_mesa_is_gles31(ctx))
2795 goto invalid_enum;
2796 if (index >= ctx->Const.MaxImageUnits)
2797 goto invalid_value;
2798
2799 t = ctx->ImageUnits[index].TexObj;
2800 v->value_int = (t ? t->Name : 0);
2801 return TYPE_INT;
2802 }
2803
2804 case GL_IMAGE_BINDING_LEVEL:
2805 if (!ctx->Extensions.ARB_shader_image_load_store && !_mesa_is_gles31(ctx))
2806 goto invalid_enum;
2807 if (index >= ctx->Const.MaxImageUnits)
2808 goto invalid_value;
2809
2810 v->value_int = ctx->ImageUnits[index].Level;
2811 return TYPE_INT;
2812
2813 case GL_IMAGE_BINDING_LAYERED:
2814 if (!ctx->Extensions.ARB_shader_image_load_store && !_mesa_is_gles31(ctx))
2815 goto invalid_enum;
2816 if (index >= ctx->Const.MaxImageUnits)
2817 goto invalid_value;
2818
2819 v->value_int = ctx->ImageUnits[index].Layered;
2820 return TYPE_INT;
2821
2822 case GL_IMAGE_BINDING_LAYER:
2823 if (!ctx->Extensions.ARB_shader_image_load_store && !_mesa_is_gles31(ctx))
2824 goto invalid_enum;
2825 if (index >= ctx->Const.MaxImageUnits)
2826 goto invalid_value;
2827
2828 v->value_int = ctx->ImageUnits[index].Layer;
2829 return TYPE_INT;
2830
2831 case GL_IMAGE_BINDING_ACCESS:
2832 if (!ctx->Extensions.ARB_shader_image_load_store && !_mesa_is_gles31(ctx))
2833 goto invalid_enum;
2834 if (index >= ctx->Const.MaxImageUnits)
2835 goto invalid_value;
2836
2837 v->value_int = ctx->ImageUnits[index].Access;
2838 return TYPE_INT;
2839
2840 case GL_IMAGE_BINDING_FORMAT:
2841 if (!ctx->Extensions.ARB_shader_image_load_store && !_mesa_is_gles31(ctx))
2842 goto invalid_enum;
2843 if (index >= ctx->Const.MaxImageUnits)
2844 goto invalid_value;
2845
2846 v->value_int = ctx->ImageUnits[index].Format;
2847 return TYPE_INT;
2848
2849 /* ARB_direct_state_access */
2850 case GL_TEXTURE_BINDING_1D:
2851 case GL_TEXTURE_BINDING_1D_ARRAY:
2852 case GL_TEXTURE_BINDING_2D:
2853 case GL_TEXTURE_BINDING_2D_ARRAY:
2854 case GL_TEXTURE_BINDING_2D_MULTISAMPLE:
2855 case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
2856 case GL_TEXTURE_BINDING_3D:
2857 case GL_TEXTURE_BINDING_BUFFER:
2858 case GL_TEXTURE_BINDING_CUBE_MAP:
2859 case GL_TEXTURE_BINDING_CUBE_MAP_ARRAY:
2860 case GL_TEXTURE_BINDING_RECTANGLE: {
2861 int target;
2862
2863 target = tex_binding_to_index(ctx, pname);
2864 if (target < 0)
2865 goto invalid_enum;
2866 if (index >= _mesa_max_tex_unit(ctx))
2867 goto invalid_value;
2868
2869 v->value_int = ctx->Texture.Unit[index].CurrentTex[target]->Name;
2870 return TYPE_INT;
2871 }
2872
2873 case GL_SAMPLER_BINDING: {
2874 struct gl_sampler_object *samp;
2875
2876 if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 33)
2877 goto invalid_enum;
2878 if (index >= _mesa_max_tex_unit(ctx))
2879 goto invalid_value;
2880
2881 samp = ctx->Texture.Unit[index].Sampler;
2882 v->value_int = samp ? samp->Name : 0;
2883 return TYPE_INT;
2884 }
2885
2886 case GL_MAX_COMPUTE_WORK_GROUP_COUNT:
2887 if (!_mesa_has_compute_shaders(ctx))
2888 goto invalid_enum;
2889 if (index >= 3)
2890 goto invalid_value;
2891 v->value_uint = ctx->Const.MaxComputeWorkGroupCount[index];
2892 return TYPE_UINT;
2893
2894 case GL_MAX_COMPUTE_WORK_GROUP_SIZE:
2895 if (!_mesa_has_compute_shaders(ctx))
2896 goto invalid_enum;
2897 if (index >= 3)
2898 goto invalid_value;
2899 v->value_int = ctx->Const.MaxComputeWorkGroupSize[index];
2900 return TYPE_INT;
2901
2902 /* ARB_compute_variable_group_size */
2903 case GL_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB:
2904 if (!ctx->Extensions.ARB_compute_variable_group_size)
2905 goto invalid_enum;
2906 if (index >= 3)
2907 goto invalid_value;
2908 v->value_int = ctx->Const.MaxComputeVariableGroupSize[index];
2909 return TYPE_INT;
2910
2911 /* GL_EXT_external_objects */
2912 case GL_NUM_DEVICE_UUIDS_EXT:
2913 if (!_mesa_has_EXT_memory_object(ctx) && !_mesa_has_EXT_semaphore(ctx))
2914 goto invalid_enum;
2915 v->value_int = 1;
2916 return TYPE_INT;
2917 case GL_DRIVER_UUID_EXT:
2918 if (!_mesa_has_EXT_memory_object(ctx) && !_mesa_has_EXT_semaphore(ctx))
2919 goto invalid_enum;
2920 if (index >= 1)
2921 goto invalid_value;
2922 _mesa_get_driver_uuid(ctx, v->value_int_4);
2923 return TYPE_INT_4;
2924 case GL_DEVICE_UUID_EXT:
2925 if (!_mesa_has_EXT_memory_object(ctx) && !_mesa_has_EXT_semaphore(ctx))
2926 goto invalid_enum;
2927 if (index >= 1)
2928 goto invalid_value;
2929 _mesa_get_device_uuid(ctx, v->value_int_4);
2930 return TYPE_INT_4;
2931 /* GL_EXT_memory_object_win32 */
2932 case GL_DEVICE_LUID_EXT:
2933 if (!_mesa_has_EXT_memory_object_win32(ctx) && !_mesa_has_EXT_semaphore_win32(ctx))
2934 goto invalid_enum;
2935 if (index >= 1)
2936 goto invalid_value;
2937 _mesa_get_device_luid(ctx, v->value_int_2);
2938 return TYPE_INT_2;
2939 case GL_DEVICE_NODE_MASK_EXT:
2940 if (index >= 1)
2941 goto invalid_value;
2942 v->value_int = ctx->pipe->screen->get_device_node_mask(ctx->pipe->screen);
2943 return TYPE_INT;
2944 /* GL_EXT_direct_state_access */
2945 case GL_TEXTURE_1D:
2946 case GL_TEXTURE_2D:
2947 case GL_TEXTURE_3D:
2948 case GL_TEXTURE_CUBE_MAP:
2949 case GL_TEXTURE_GEN_S:
2950 case GL_TEXTURE_GEN_T:
2951 case GL_TEXTURE_GEN_R:
2952 case GL_TEXTURE_GEN_Q:
2953 case GL_TEXTURE_RECTANGLE_ARB: {
2954 GLuint curTexUnitSave;
2955 if (index >= _mesa_max_tex_unit(ctx))
2956 goto invalid_enum;
2957 curTexUnitSave = ctx->Texture.CurrentUnit;
2958 _mesa_ActiveTexture_no_error(GL_TEXTURE0 + index);
2959 v->value_int = _mesa_IsEnabled(pname);
2960 _mesa_ActiveTexture_no_error(GL_TEXTURE0 + curTexUnitSave);
2961 return TYPE_INT;
2962 }
2963 case GL_TEXTURE_COORD_ARRAY: {
2964 GLuint curTexUnitSave;
2965 if (index >= ctx->Const.MaxTextureCoordUnits)
2966 goto invalid_enum;
2967 curTexUnitSave = ctx->Array.ActiveTexture;
2968 _mesa_ClientActiveTexture(GL_TEXTURE0 + index);
2969 v->value_int = _mesa_IsEnabled(pname);
2970 _mesa_ClientActiveTexture(GL_TEXTURE0 + curTexUnitSave);
2971 return TYPE_INT;
2972 }
2973 case GL_TEXTURE_MATRIX:
2974 if (index >= ARRAY_SIZE(ctx->TextureMatrixStack))
2975 goto invalid_enum;
2976 v->value_matrix = ctx->TextureMatrixStack[index].Top;
2977 return TYPE_MATRIX;
2978 case GL_TRANSPOSE_TEXTURE_MATRIX:
2979 if (index >= ARRAY_SIZE(ctx->TextureMatrixStack))
2980 goto invalid_enum;
2981 v->value_matrix = ctx->TextureMatrixStack[index].Top;
2982 return TYPE_MATRIX_T;
2983 /* GL_NV_viewport_swizzle */
2984 case GL_VIEWPORT_SWIZZLE_X_NV:
2985 if (!ctx->Extensions.NV_viewport_swizzle)
2986 goto invalid_enum;
2987 if (index >= ctx->Const.MaxViewports)
2988 goto invalid_value;
2989 v->value_int = ctx->ViewportArray[index].SwizzleX;
2990 return TYPE_INT;
2991 case GL_VIEWPORT_SWIZZLE_Y_NV:
2992 if (!ctx->Extensions.NV_viewport_swizzle)
2993 goto invalid_enum;
2994 if (index >= ctx->Const.MaxViewports)
2995 goto invalid_value;
2996 v->value_int = ctx->ViewportArray[index].SwizzleY;
2997 return TYPE_INT;
2998 case GL_VIEWPORT_SWIZZLE_Z_NV:
2999 if (!ctx->Extensions.NV_viewport_swizzle)
3000 goto invalid_enum;
3001 if (index >= ctx->Const.MaxViewports)
3002 goto invalid_value;
3003 v->value_int = ctx->ViewportArray[index].SwizzleZ;
3004 return TYPE_INT;
3005 case GL_VIEWPORT_SWIZZLE_W_NV:
3006 if (!ctx->Extensions.NV_viewport_swizzle)
3007 goto invalid_enum;
3008 if (index >= ctx->Const.MaxViewports)
3009 goto invalid_value;
3010 v->value_int = ctx->ViewportArray[index].SwizzleW;
3011 return TYPE_INT;
3012 }
3013
3014 invalid_enum:
3015 _mesa_error(ctx, GL_INVALID_ENUM, "%s(pname=%s)", func,
3016 _mesa_enum_to_string(pname));
3017 return TYPE_INVALID;
3018 invalid_value:
3019 _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s)", func,
3020 _mesa_enum_to_string(pname));
3021 return TYPE_INVALID;
3022 }
3023
3024 void GLAPIENTRY
_mesa_GetBooleani_v(GLenum pname,GLuint index,GLboolean * params)3025 _mesa_GetBooleani_v( GLenum pname, GLuint index, GLboolean *params )
3026 {
3027 union value v;
3028 enum value_type type =
3029 find_value_indexed("glGetBooleani_v", pname, index, &v);
3030
3031 switch (type) {
3032 case TYPE_INT:
3033 case TYPE_UINT:
3034 params[0] = INT_TO_BOOLEAN(v.value_int);
3035 break;
3036 case TYPE_INT_4:
3037 case TYPE_UINT_4:
3038 params[0] = INT_TO_BOOLEAN(v.value_int_4[0]);
3039 params[1] = INT_TO_BOOLEAN(v.value_int_4[1]);
3040 params[2] = INT_TO_BOOLEAN(v.value_int_4[2]);
3041 params[3] = INT_TO_BOOLEAN(v.value_int_4[3]);
3042 break;
3043 case TYPE_INT64:
3044 params[0] = INT64_TO_BOOLEAN(v.value_int64);
3045 break;
3046 default:
3047 ; /* nothing - GL error was recorded */
3048 }
3049 }
3050
3051 void GLAPIENTRY
_mesa_GetIntegeri_v(GLenum pname,GLuint index,GLint * params)3052 _mesa_GetIntegeri_v( GLenum pname, GLuint index, GLint *params )
3053 {
3054 union value v;
3055 enum value_type type =
3056 find_value_indexed("glGetIntegeri_v", pname, index, &v);
3057
3058 switch (type) {
3059 case TYPE_FLOAT_4:
3060 case TYPE_FLOATN_4:
3061 params[3] = lroundf(v.value_float_4[3]);
3062 FALLTHROUGH;
3063 case TYPE_FLOAT_3:
3064 case TYPE_FLOATN_3:
3065 params[2] = lroundf(v.value_float_4[2]);
3066 FALLTHROUGH;
3067 case TYPE_FLOAT_2:
3068 case TYPE_FLOATN_2:
3069 params[1] = lroundf(v.value_float_4[1]);
3070 FALLTHROUGH;
3071 case TYPE_FLOAT:
3072 case TYPE_FLOATN:
3073 params[0] = lroundf(v.value_float_4[0]);
3074 break;
3075
3076 case TYPE_DOUBLEN_2:
3077 params[1] = lroundf(v.value_double_2[1]);
3078 FALLTHROUGH;
3079 case TYPE_DOUBLEN:
3080 params[0] = lroundf(v.value_double_2[0]);
3081 break;
3082
3083 case TYPE_INT:
3084 params[0] = v.value_int;
3085 break;
3086 case TYPE_UINT:
3087 params[0] = MIN2(v.value_uint, INT_MAX);
3088 break;
3089 case TYPE_INT_4:
3090 params[0] = v.value_int_4[0];
3091 params[1] = v.value_int_4[1];
3092 params[2] = v.value_int_4[2];
3093 params[3] = v.value_int_4[3];
3094 break;
3095 case TYPE_UINT_4:
3096 params[0] = MIN2((GLuint)v.value_int_4[0], INT_MAX);
3097 params[1] = MIN2((GLuint)v.value_int_4[1], INT_MAX);
3098 params[2] = MIN2((GLuint)v.value_int_4[2], INT_MAX);
3099 params[3] = MIN2((GLuint)v.value_int_4[3], INT_MAX);
3100 break;
3101 case TYPE_INT64:
3102 params[0] = INT64_TO_INT(v.value_int64);
3103 break;
3104 default:
3105 ; /* nothing - GL error was recorded */
3106 }
3107 }
3108
3109 void GLAPIENTRY
_mesa_GetInteger64i_v(GLenum pname,GLuint index,GLint64 * params)3110 _mesa_GetInteger64i_v( GLenum pname, GLuint index, GLint64 *params )
3111 {
3112 union value v;
3113 enum value_type type =
3114 find_value_indexed("glGetInteger64i_v", pname, index, &v);
3115
3116 switch (type) {
3117 case TYPE_INT:
3118 params[0] = v.value_int;
3119 break;
3120 case TYPE_INT_4:
3121 params[0] = v.value_int_4[0];
3122 params[1] = v.value_int_4[1];
3123 params[2] = v.value_int_4[2];
3124 params[3] = v.value_int_4[3];
3125 break;
3126 case TYPE_UINT:
3127 params[0] = v.value_uint;
3128 break;
3129 case TYPE_UINT_4:
3130 params[0] = (GLuint) v.value_int_4[0];
3131 params[1] = (GLuint) v.value_int_4[1];
3132 params[2] = (GLuint) v.value_int_4[2];
3133 params[3] = (GLuint) v.value_int_4[3];
3134 break;
3135 case TYPE_INT64:
3136 params[0] = v.value_int64;
3137 break;
3138 default:
3139 ; /* nothing - GL error was recorded */
3140 }
3141 }
3142
3143 void GLAPIENTRY
_mesa_GetFloati_v(GLenum pname,GLuint index,GLfloat * params)3144 _mesa_GetFloati_v(GLenum pname, GLuint index, GLfloat *params)
3145 {
3146 int i;
3147 GLmatrix *m;
3148 union value v;
3149 enum value_type type =
3150 find_value_indexed("glGetFloati_v", pname, index, &v);
3151
3152 switch (type) {
3153 case TYPE_FLOAT_4:
3154 case TYPE_FLOATN_4:
3155 params[3] = v.value_float_4[3];
3156 FALLTHROUGH;
3157 case TYPE_FLOAT_3:
3158 case TYPE_FLOATN_3:
3159 params[2] = v.value_float_4[2];
3160 FALLTHROUGH;
3161 case TYPE_FLOAT_2:
3162 case TYPE_FLOATN_2:
3163 params[1] = v.value_float_4[1];
3164 FALLTHROUGH;
3165 case TYPE_FLOAT:
3166 case TYPE_FLOATN:
3167 params[0] = v.value_float_4[0];
3168 break;
3169
3170 case TYPE_DOUBLEN_2:
3171 params[1] = (GLfloat) v.value_double_2[1];
3172 FALLTHROUGH;
3173 case TYPE_DOUBLEN:
3174 params[0] = (GLfloat) v.value_double_2[0];
3175 break;
3176
3177 case TYPE_INT_4:
3178 params[3] = (GLfloat) v.value_int_4[3];
3179 FALLTHROUGH;
3180 case TYPE_INT_3:
3181 params[2] = (GLfloat) v.value_int_4[2];
3182 FALLTHROUGH;
3183 case TYPE_INT_2:
3184 case TYPE_ENUM_2:
3185 params[1] = (GLfloat) v.value_int_4[1];
3186 FALLTHROUGH;
3187 case TYPE_INT:
3188 case TYPE_ENUM:
3189 case TYPE_ENUM16:
3190 params[0] = (GLfloat) v.value_int_4[0];
3191 break;
3192
3193 case TYPE_INT_N:
3194 for (i = 0; i < v.value_int_n.n; i++)
3195 params[i] = (GLfloat) v.value_int_n.ints[i];
3196 break;
3197
3198 case TYPE_UINT_4:
3199 params[3] = (GLfloat) ((GLuint) v.value_int_4[3]);
3200 FALLTHROUGH;
3201 case TYPE_UINT_3:
3202 params[2] = (GLfloat) ((GLuint) v.value_int_4[2]);
3203 FALLTHROUGH;
3204 case TYPE_UINT_2:
3205 params[1] = (GLfloat) ((GLuint) v.value_int_4[1]);
3206 FALLTHROUGH;
3207 case TYPE_UINT:
3208 params[0] = (GLfloat) ((GLuint) v.value_int_4[0]);
3209 break;
3210
3211 case TYPE_INT64:
3212 params[0] = (GLfloat) v.value_int64;
3213 break;
3214
3215 case TYPE_BOOLEAN:
3216 params[0] = BOOLEAN_TO_FLOAT(v.value_bool);
3217 break;
3218
3219 case TYPE_UBYTE:
3220 params[0] = (GLfloat) v.value_ubyte;
3221 break;
3222
3223 case TYPE_SHORT:
3224 params[0] = (GLfloat) v.value_short;
3225 break;
3226
3227 case TYPE_MATRIX:
3228 m = *(GLmatrix **) &v;
3229 for (i = 0; i < 16; i++)
3230 params[i] = m->m[i];
3231 break;
3232
3233 case TYPE_MATRIX_T:
3234 m = *(GLmatrix **) &v;
3235 for (i = 0; i < 16; i++)
3236 params[i] = m->m[transpose[i]];
3237 break;
3238
3239 default:
3240 ;
3241 }
3242 }
3243
3244 void GLAPIENTRY
_mesa_GetDoublei_v(GLenum pname,GLuint index,GLdouble * params)3245 _mesa_GetDoublei_v(GLenum pname, GLuint index, GLdouble *params)
3246 {
3247 int i;
3248 GLmatrix *m;
3249 union value v;
3250 enum value_type type =
3251 find_value_indexed("glGetDoublei_v", pname, index, &v);
3252
3253 switch (type) {
3254 case TYPE_FLOAT_4:
3255 case TYPE_FLOATN_4:
3256 params[3] = (GLdouble) v.value_float_4[3];
3257 FALLTHROUGH;
3258 case TYPE_FLOAT_3:
3259 case TYPE_FLOATN_3:
3260 params[2] = (GLdouble) v.value_float_4[2];
3261 FALLTHROUGH;
3262 case TYPE_FLOAT_2:
3263 case TYPE_FLOATN_2:
3264 params[1] = (GLdouble) v.value_float_4[1];
3265 FALLTHROUGH;
3266 case TYPE_FLOAT:
3267 case TYPE_FLOATN:
3268 params[0] = (GLdouble) v.value_float_4[0];
3269 break;
3270
3271 case TYPE_DOUBLEN_2:
3272 params[1] = v.value_double_2[1];
3273 FALLTHROUGH;
3274 case TYPE_DOUBLEN:
3275 params[0] = v.value_double_2[0];
3276 break;
3277
3278 case TYPE_INT_4:
3279 params[3] = (GLdouble) v.value_int_4[3];
3280 FALLTHROUGH;
3281 case TYPE_INT_3:
3282 params[2] = (GLdouble) v.value_int_4[2];
3283 FALLTHROUGH;
3284 case TYPE_INT_2:
3285 case TYPE_ENUM_2:
3286 params[1] = (GLdouble) v.value_int_4[1];
3287 FALLTHROUGH;
3288 case TYPE_INT:
3289 case TYPE_ENUM:
3290 case TYPE_ENUM16:
3291 params[0] = (GLdouble) v.value_int_4[0];
3292 break;
3293
3294 case TYPE_INT_N:
3295 for (i = 0; i < v.value_int_n.n; i++)
3296 params[i] = (GLdouble) v.value_int_n.ints[i];
3297 break;
3298
3299 case TYPE_UINT_4:
3300 params[3] = (GLdouble) ((GLuint) v.value_int_4[3]);
3301 FALLTHROUGH;
3302 case TYPE_UINT_3:
3303 params[2] = (GLdouble) ((GLuint) v.value_int_4[2]);
3304 FALLTHROUGH;
3305 case TYPE_UINT_2:
3306 params[1] = (GLdouble) ((GLuint) v.value_int_4[1]);
3307 FALLTHROUGH;
3308 case TYPE_UINT:
3309 params[0] = (GLdouble) ((GLuint) v.value_int_4[0]);
3310 break;
3311
3312 case TYPE_INT64:
3313 params[0] = (GLdouble) v.value_int64;
3314 break;
3315
3316 case TYPE_BOOLEAN:
3317 params[0] = (GLdouble) BOOLEAN_TO_FLOAT(v.value_bool);
3318 break;
3319
3320 case TYPE_UBYTE:
3321 params[0] = (GLdouble) v.value_ubyte;
3322 break;
3323
3324 case TYPE_SHORT:
3325 params[0] = (GLdouble) v.value_short;
3326 break;
3327
3328 case TYPE_MATRIX:
3329 m = *(GLmatrix **) &v;
3330 for (i = 0; i < 16; i++)
3331 params[i] = (GLdouble) m->m[i];
3332 break;
3333
3334 case TYPE_MATRIX_T:
3335 m = *(GLmatrix **) &v;
3336 for (i = 0; i < 16; i++)
3337 params[i] = (GLdouble) m->m[transpose[i]];
3338 break;
3339
3340 default:
3341 ;
3342 }
3343 }
3344
3345 void GLAPIENTRY
_mesa_GetUnsignedBytei_vEXT(GLenum target,GLuint index,GLubyte * data)3346 _mesa_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
3347 {
3348 GLsizei size;
3349 union value v;
3350 enum value_type type;
3351 const char *func = "glGetUnsignedBytei_vEXT";
3352
3353 GET_CURRENT_CONTEXT(ctx);
3354
3355 if (!_mesa_has_EXT_memory_object(ctx)) {
3356 _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
3357 return;
3358 }
3359
3360 type = find_value_indexed(func, target, index, &v);
3361 size = get_value_size(type, &v);
3362
3363 switch (type) {
3364 case TYPE_UINT:
3365 case TYPE_INT:
3366 case TYPE_INT_2:
3367 case TYPE_UINT_2:
3368 case TYPE_INT_3:
3369 case TYPE_UINT_3:
3370 case TYPE_INT_4:
3371 case TYPE_UINT_4:
3372 case TYPE_INT64:
3373 case TYPE_ENUM16:
3374 case TYPE_ENUM:
3375 case TYPE_ENUM_2:
3376 case TYPE_BOOLEAN:
3377 case TYPE_UBYTE:
3378 case TYPE_SHORT:
3379 case TYPE_FLOAT:
3380 case TYPE_FLOATN:
3381 case TYPE_FLOAT_2:
3382 case TYPE_FLOATN_2:
3383 case TYPE_FLOAT_3:
3384 case TYPE_FLOATN_3:
3385 case TYPE_FLOAT_4:
3386 case TYPE_FLOATN_4:
3387 case TYPE_FLOAT_8:
3388 case TYPE_DOUBLEN:
3389 case TYPE_DOUBLEN_2:
3390 case TYPE_MATRIX:
3391 case TYPE_MATRIX_T:
3392 memcpy(data, &v.value_int, size);
3393 break;
3394 case TYPE_INT_N:
3395 memcpy(data, &v.value_int_n.ints, size);
3396 break;
3397 default:
3398 break; /* nothing - GL error was recorded */
3399 }
3400 }
3401
3402 void GLAPIENTRY
_mesa_GetFixedv(GLenum pname,GLfixed * params)3403 _mesa_GetFixedv(GLenum pname, GLfixed *params)
3404 {
3405 const struct value_desc *d;
3406 union value v;
3407 GLmatrix *m;
3408 int shift, i;
3409 void *p;
3410
3411 d = find_value("glGetDoublev", pname, &p, &v);
3412 switch (d->type) {
3413 case TYPE_INVALID:
3414 break;
3415 case TYPE_CONST:
3416 params[0] = INT_TO_FIXED(d->offset);
3417 break;
3418
3419 case TYPE_FLOAT_4:
3420 case TYPE_FLOATN_4:
3421 params[3] = FLOAT_TO_FIXED(((GLfloat *) p)[3]);
3422 FALLTHROUGH;
3423 case TYPE_FLOAT_3:
3424 case TYPE_FLOATN_3:
3425 params[2] = FLOAT_TO_FIXED(((GLfloat *) p)[2]);
3426 FALLTHROUGH;
3427 case TYPE_FLOAT_2:
3428 case TYPE_FLOATN_2:
3429 params[1] = FLOAT_TO_FIXED(((GLfloat *) p)[1]);
3430 FALLTHROUGH;
3431 case TYPE_FLOAT:
3432 case TYPE_FLOATN:
3433 params[0] = FLOAT_TO_FIXED(((GLfloat *) p)[0]);
3434 break;
3435
3436 case TYPE_DOUBLEN_2:
3437 params[1] = FLOAT_TO_FIXED(((GLdouble *) p)[1]);
3438 FALLTHROUGH;
3439 case TYPE_DOUBLEN:
3440 params[0] = FLOAT_TO_FIXED(((GLdouble *) p)[0]);
3441 break;
3442
3443 case TYPE_INT_4:
3444 params[3] = INT_TO_FIXED(((GLint *) p)[3]);
3445 FALLTHROUGH;
3446 case TYPE_INT_3:
3447 params[2] = INT_TO_FIXED(((GLint *) p)[2]);
3448 FALLTHROUGH;
3449 case TYPE_INT_2:
3450 case TYPE_ENUM_2:
3451 params[1] = INT_TO_FIXED(((GLint *) p)[1]);
3452 FALLTHROUGH;
3453 case TYPE_INT:
3454 case TYPE_ENUM:
3455 params[0] = INT_TO_FIXED(((GLint *) p)[0]);
3456 break;
3457
3458 case TYPE_UINT_4:
3459 params[3] = INT_TO_FIXED(((GLuint *) p)[3]);
3460 FALLTHROUGH;
3461 case TYPE_UINT_3:
3462 params[2] = INT_TO_FIXED(((GLuint *) p)[2]);
3463 FALLTHROUGH;
3464 case TYPE_UINT_2:
3465 params[1] = INT_TO_FIXED(((GLuint *) p)[1]);
3466 FALLTHROUGH;
3467 case TYPE_UINT:
3468 params[0] = INT_TO_FIXED(((GLuint *) p)[0]);
3469 break;
3470
3471 case TYPE_ENUM16:
3472 params[0] = INT_TO_FIXED((GLint)(((GLenum16 *) p)[0]));
3473 break;
3474
3475 case TYPE_INT_N:
3476 for (i = 0; i < v.value_int_n.n; i++)
3477 params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
3478 break;
3479
3480 case TYPE_INT64:
3481 params[0] = ((GLint64 *) p)[0];
3482 break;
3483
3484 case TYPE_BOOLEAN:
3485 params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
3486 break;
3487
3488 case TYPE_UBYTE:
3489 params[0] = INT_TO_FIXED(((GLubyte *) p)[0]);
3490 break;
3491
3492 case TYPE_SHORT:
3493 params[0] = INT_TO_FIXED(((GLshort *) p)[0]);
3494 break;
3495
3496 case TYPE_MATRIX:
3497 m = *(GLmatrix **) p;
3498 for (i = 0; i < 16; i++)
3499 params[i] = FLOAT_TO_FIXED(m->m[i]);
3500 break;
3501
3502 case TYPE_MATRIX_T:
3503 m = *(GLmatrix **) p;
3504 for (i = 0; i < 16; i++)
3505 params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
3506 break;
3507
3508 case TYPE_BIT_0:
3509 case TYPE_BIT_1:
3510 case TYPE_BIT_2:
3511 case TYPE_BIT_3:
3512 case TYPE_BIT_4:
3513 case TYPE_BIT_5:
3514 case TYPE_BIT_6:
3515 case TYPE_BIT_7:
3516 shift = d->type - TYPE_BIT_0;
3517 params[0] = BOOLEAN_TO_FIXED((*(GLbitfield *) p >> shift) & 1);
3518 break;
3519 }
3520 }
3521