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