2 * Copyright © 2012 Intel Corporation
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * 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 OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
26 #include "glformats.h"
30 #include "formatquery.h"
35 #include "genmipmap.h"
36 #include "shaderimage.h"
37 #include "texcompress.h"
38 #include "textureview.h"
41 _is_renderable(struct gl_context
*ctx
, GLenum internalformat
)
43 /* Section 4.4.4 on page 212 of the GLES 3.0.4 spec says:
45 * "An internal format is color-renderable if it is one of the
46 * formats from table 3.13 noted as color-renderable or if it
47 * is unsized format RGBA or RGB."
49 * Therefore, we must accept GL_RGB and GL_RGBA here.
51 if (internalformat
!= GL_RGB
&& internalformat
!= GL_RGBA
&&
52 _mesa_base_fbo_format(ctx
, internalformat
) == 0)
58 /* Handles the cases where either ARB_internalformat_query or
59 * ARB_internalformat_query2 have to return an error.
62 _legal_parameters(struct gl_context
*ctx
, GLenum target
, GLenum internalformat
,
63 GLenum pname
, GLsizei bufSize
, GLint
*params
)
66 bool query2
= _mesa_has_ARB_internalformat_query2(ctx
);
68 /* The ARB_internalformat_query2 spec says:
70 * "The INVALID_ENUM error is generated if the <target> parameter to
71 * GetInternalformati*v is not one of the targets listed in Table 6.xx.
75 case GL_TEXTURE_1D_ARRAY
:
77 case GL_TEXTURE_2D_ARRAY
:
79 case GL_TEXTURE_CUBE_MAP
:
80 case GL_TEXTURE_CUBE_MAP_ARRAY
:
81 case GL_TEXTURE_RECTANGLE
:
82 case GL_TEXTURE_BUFFER
:
84 /* The ARB_internalformat_query spec says:
86 * "If the <target> parameter to GetInternalformativ is not one of
87 * TEXTURE_2D_MULTISAMPLE, TEXTURE_2D_MULTISAMPLE_ARRAY
88 * or RENDERBUFFER then an INVALID_ENUM error is generated.
90 _mesa_error(ctx
, GL_INVALID_ENUM
,
91 "glGetInternalformativ(target=%s)",
92 _mesa_enum_to_string(target
));
101 case GL_TEXTURE_2D_MULTISAMPLE
:
102 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY
:
103 /* The non-existence of ARB_texture_multisample is treated in
104 * ARB_internalformat_query implementation like an error.
107 !(_mesa_has_ARB_texture_multisample(ctx
) || _mesa_is_gles31(ctx
))) {
108 _mesa_error(ctx
, GL_INVALID_ENUM
,
109 "glGetInternalformativ(target=%s)",
110 _mesa_enum_to_string(target
));
117 _mesa_error(ctx
, GL_INVALID_ENUM
,
118 "glGetInternalformativ(target=%s)",
119 _mesa_enum_to_string(target
));
124 /* The ARB_internalformat_query2 spec says:
126 * "The INVALID_ENUM error is generated if the <pname> parameter is
127 * not one of the listed possibilities.
131 case GL_NUM_SAMPLE_COUNTS
:
134 case GL_SRGB_DECODE_ARB
:
135 /* The ARB_internalformat_query2 spec says:
137 * "If ARB_texture_sRGB_decode or EXT_texture_sRGB_decode or
138 * equivalent functionality is not supported, queries for the
139 * SRGB_DECODE_ARB <pname> set the INVALID_ENUM error.
141 if (!_mesa_has_EXT_texture_sRGB_decode(ctx
)) {
142 _mesa_error(ctx
, GL_INVALID_ENUM
,
143 "glGetInternalformativ(pname=%s)",
144 _mesa_enum_to_string(pname
));
148 case GL_INTERNALFORMAT_SUPPORTED
:
149 case GL_INTERNALFORMAT_PREFERRED
:
150 case GL_INTERNALFORMAT_RED_SIZE
:
151 case GL_INTERNALFORMAT_GREEN_SIZE
:
152 case GL_INTERNALFORMAT_BLUE_SIZE
:
153 case GL_INTERNALFORMAT_ALPHA_SIZE
:
154 case GL_INTERNALFORMAT_DEPTH_SIZE
:
155 case GL_INTERNALFORMAT_STENCIL_SIZE
:
156 case GL_INTERNALFORMAT_SHARED_SIZE
:
157 case GL_INTERNALFORMAT_RED_TYPE
:
158 case GL_INTERNALFORMAT_GREEN_TYPE
:
159 case GL_INTERNALFORMAT_BLUE_TYPE
:
160 case GL_INTERNALFORMAT_ALPHA_TYPE
:
161 case GL_INTERNALFORMAT_DEPTH_TYPE
:
162 case GL_INTERNALFORMAT_STENCIL_TYPE
:
167 case GL_MAX_COMBINED_DIMENSIONS
:
168 case GL_COLOR_COMPONENTS
:
169 case GL_DEPTH_COMPONENTS
:
170 case GL_STENCIL_COMPONENTS
:
171 case GL_COLOR_RENDERABLE
:
172 case GL_DEPTH_RENDERABLE
:
173 case GL_STENCIL_RENDERABLE
:
174 case GL_FRAMEBUFFER_RENDERABLE
:
175 case GL_FRAMEBUFFER_RENDERABLE_LAYERED
:
176 case GL_FRAMEBUFFER_BLEND
:
178 case GL_READ_PIXELS_FORMAT
:
179 case GL_READ_PIXELS_TYPE
:
180 case GL_TEXTURE_IMAGE_FORMAT
:
181 case GL_TEXTURE_IMAGE_TYPE
:
182 case GL_GET_TEXTURE_IMAGE_FORMAT
:
183 case GL_GET_TEXTURE_IMAGE_TYPE
:
185 case GL_MANUAL_GENERATE_MIPMAP
:
186 case GL_AUTO_GENERATE_MIPMAP
:
187 case GL_COLOR_ENCODING
:
191 case GL_VERTEX_TEXTURE
:
192 case GL_TESS_CONTROL_TEXTURE
:
193 case GL_TESS_EVALUATION_TEXTURE
:
194 case GL_GEOMETRY_TEXTURE
:
195 case GL_FRAGMENT_TEXTURE
:
196 case GL_COMPUTE_TEXTURE
:
197 case GL_TEXTURE_SHADOW
:
198 case GL_TEXTURE_GATHER
:
199 case GL_TEXTURE_GATHER_SHADOW
:
200 case GL_SHADER_IMAGE_LOAD
:
201 case GL_SHADER_IMAGE_STORE
:
202 case GL_SHADER_IMAGE_ATOMIC
:
203 case GL_IMAGE_TEXEL_SIZE
:
204 case GL_IMAGE_COMPATIBILITY_CLASS
:
205 case GL_IMAGE_PIXEL_FORMAT
:
206 case GL_IMAGE_PIXEL_TYPE
:
207 case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE
:
208 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST
:
209 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST
:
210 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE
:
211 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE
:
212 case GL_TEXTURE_COMPRESSED
:
213 case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH
:
214 case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT
:
215 case GL_TEXTURE_COMPRESSED_BLOCK_SIZE
:
216 case GL_CLEAR_BUFFER
:
217 case GL_TEXTURE_VIEW
:
218 case GL_VIEW_COMPATIBILITY_CLASS
:
219 case GL_NUM_TILING_TYPES_EXT
:
220 case GL_TILING_TYPES_EXT
:
221 /* The ARB_internalformat_query spec says:
223 * "If the <pname> parameter to GetInternalformativ is not SAMPLES
224 * or NUM_SAMPLE_COUNTS, then an INVALID_ENUM error is generated."
227 _mesa_error(ctx
, GL_INVALID_ENUM
,
228 "glGetInternalformativ(pname=%s)",
229 _mesa_enum_to_string(pname
));
236 _mesa_error(ctx
, GL_INVALID_ENUM
,
237 "glGetInternalformativ(pname=%s)",
238 _mesa_enum_to_string(pname
));
242 /* The ARB_internalformat_query spec says:
244 * "If the <bufSize> parameter to GetInternalformativ is negative, then
245 * an INVALID_VALUE error is generated."
247 * Nothing is said in ARB_internalformat_query2 but we assume the same.
250 _mesa_error(ctx
, GL_INVALID_VALUE
,
251 "glGetInternalformativ(target=%s)",
252 _mesa_enum_to_string(target
));
256 /* The ARB_internalformat_query spec says:
258 * "If the <internalformat> parameter to GetInternalformativ is not
259 * color-, depth- or stencil-renderable, then an INVALID_ENUM error is
262 if (!query2
&& !_is_renderable(ctx
, internalformat
)) {
263 _mesa_error(ctx
, GL_INVALID_ENUM
,
264 "glGetInternalformativ(internalformat=%s)",
265 _mesa_enum_to_string(internalformat
));
272 /* Sets the appropriate "unsupported" response as defined by the
273 * ARB_internalformat_query2 spec for each each <pname>.
276 _set_default_response(GLenum pname
, GLint buffer
[16])
278 /* The ARB_internalformat_query2 defines which is the reponse best
279 * representing "not supported" or "not applicable" for each <pname>.
282 * - size- or count-based queries will return zero,
283 * - support-, format- or type-based queries will return NONE,
284 * - boolean-based queries will return FALSE, and
285 * - list-based queries return no entries."
289 case GL_TILING_TYPES_EXT
:
292 case GL_MAX_COMBINED_DIMENSIONS
:
293 /* This value can be a 64-bit value. As the default is the 32-bit query,
294 * we pack 2 32-bit integers. So we need to clean both */
299 case GL_NUM_SAMPLE_COUNTS
:
300 case GL_INTERNALFORMAT_RED_SIZE
:
301 case GL_INTERNALFORMAT_GREEN_SIZE
:
302 case GL_INTERNALFORMAT_BLUE_SIZE
:
303 case GL_INTERNALFORMAT_ALPHA_SIZE
:
304 case GL_INTERNALFORMAT_DEPTH_SIZE
:
305 case GL_INTERNALFORMAT_STENCIL_SIZE
:
306 case GL_INTERNALFORMAT_SHARED_SIZE
:
311 case GL_IMAGE_TEXEL_SIZE
:
312 case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH
:
313 case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT
:
314 case GL_TEXTURE_COMPRESSED_BLOCK_SIZE
:
315 case GL_NUM_TILING_TYPES_EXT
:
319 case GL_INTERNALFORMAT_PREFERRED
:
320 case GL_INTERNALFORMAT_RED_TYPE
:
321 case GL_INTERNALFORMAT_GREEN_TYPE
:
322 case GL_INTERNALFORMAT_BLUE_TYPE
:
323 case GL_INTERNALFORMAT_ALPHA_TYPE
:
324 case GL_INTERNALFORMAT_DEPTH_TYPE
:
325 case GL_INTERNALFORMAT_STENCIL_TYPE
:
326 case GL_FRAMEBUFFER_RENDERABLE
:
327 case GL_FRAMEBUFFER_RENDERABLE_LAYERED
:
328 case GL_FRAMEBUFFER_BLEND
:
330 case GL_READ_PIXELS_FORMAT
:
331 case GL_READ_PIXELS_TYPE
:
332 case GL_TEXTURE_IMAGE_FORMAT
:
333 case GL_TEXTURE_IMAGE_TYPE
:
334 case GL_GET_TEXTURE_IMAGE_FORMAT
:
335 case GL_GET_TEXTURE_IMAGE_TYPE
:
336 case GL_MANUAL_GENERATE_MIPMAP
:
337 case GL_AUTO_GENERATE_MIPMAP
:
338 case GL_COLOR_ENCODING
:
341 case GL_SRGB_DECODE_ARB
:
343 case GL_VERTEX_TEXTURE
:
344 case GL_TESS_CONTROL_TEXTURE
:
345 case GL_TESS_EVALUATION_TEXTURE
:
346 case GL_GEOMETRY_TEXTURE
:
347 case GL_FRAGMENT_TEXTURE
:
348 case GL_COMPUTE_TEXTURE
:
349 case GL_TEXTURE_SHADOW
:
350 case GL_TEXTURE_GATHER
:
351 case GL_TEXTURE_GATHER_SHADOW
:
352 case GL_SHADER_IMAGE_LOAD
:
353 case GL_SHADER_IMAGE_STORE
:
354 case GL_SHADER_IMAGE_ATOMIC
:
355 case GL_IMAGE_COMPATIBILITY_CLASS
:
356 case GL_IMAGE_PIXEL_FORMAT
:
357 case GL_IMAGE_PIXEL_TYPE
:
358 case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE
:
359 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST
:
360 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST
:
361 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE
:
362 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE
:
363 case GL_CLEAR_BUFFER
:
364 case GL_TEXTURE_VIEW
:
365 case GL_VIEW_COMPATIBILITY_CLASS
:
369 case GL_INTERNALFORMAT_SUPPORTED
:
370 case GL_COLOR_COMPONENTS
:
371 case GL_DEPTH_COMPONENTS
:
372 case GL_STENCIL_COMPONENTS
:
373 case GL_COLOR_RENDERABLE
:
374 case GL_DEPTH_RENDERABLE
:
375 case GL_STENCIL_RENDERABLE
:
377 case GL_TEXTURE_COMPRESSED
:
378 buffer
[0] = GL_FALSE
;
382 unreachable("invalid 'pname'");
387 _is_target_supported(struct gl_context
*ctx
, GLenum target
)
389 /* The ARB_internalformat_query2 spec says:
391 * "if a particular type of <target> is not supported by the
392 * implementation the "unsupported" answer should be given.
393 * This is not an error."
395 * Note that legality of targets has already been verified.
403 case GL_TEXTURE_1D_ARRAY
:
404 if (!_mesa_has_EXT_texture_array(ctx
))
408 case GL_TEXTURE_2D_ARRAY
:
409 if (!_mesa_has_EXT_texture_array(ctx
))
413 case GL_TEXTURE_CUBE_MAP
:
414 if (ctx
->API
!= API_OPENGL_CORE
&& !_mesa_has_ARB_texture_cube_map(ctx
))
418 case GL_TEXTURE_CUBE_MAP_ARRAY
:
419 if (!_mesa_has_ARB_texture_cube_map_array(ctx
))
423 case GL_TEXTURE_RECTANGLE
:
424 if (!_mesa_has_ARB_texture_rectangle(ctx
))
428 case GL_TEXTURE_BUFFER
:
429 if (!_mesa_has_ARB_texture_buffer_object(ctx
))
433 case GL_RENDERBUFFER
:
434 if (!(_mesa_has_ARB_framebuffer_object(ctx
) ||
435 _mesa_is_gles3(ctx
)))
439 case GL_TEXTURE_2D_MULTISAMPLE
:
440 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY
:
441 if (!(_mesa_has_ARB_texture_multisample(ctx
) ||
442 _mesa_is_gles31(ctx
)))
447 unreachable("invalid target");
454 _is_resource_supported(struct gl_context
*ctx
, GLenum target
,
455 GLenum internalformat
, GLenum pname
)
457 /* From the ARB_internalformat_query2 spec:
459 * In the following descriptions, the term /resource/ is used to generically
460 * refer to an object of the appropriate type that has been created with
461 * <internalformat> and <target>. If the particular <target> and
462 * <internalformat> combination do not make sense, ... the "unsupported"
463 * answer should be given. This is not an error.
466 /* In the ARB_internalformat_query2 spec wording, some <pnames> do not care
467 * about the /resource/ being supported or not, we return 'true' for those.
470 case GL_INTERNALFORMAT_SUPPORTED
:
471 case GL_INTERNALFORMAT_PREFERRED
:
472 case GL_COLOR_COMPONENTS
:
473 case GL_DEPTH_COMPONENTS
:
474 case GL_STENCIL_COMPONENTS
:
475 case GL_COLOR_RENDERABLE
:
476 case GL_DEPTH_RENDERABLE
:
477 case GL_STENCIL_RENDERABLE
:
485 case GL_TEXTURE_1D_ARRAY
:
487 case GL_TEXTURE_2D_ARRAY
:
489 case GL_TEXTURE_CUBE_MAP
:
490 case GL_TEXTURE_CUBE_MAP_ARRAY
:
491 case GL_TEXTURE_RECTANGLE
:
492 /* Based on what Mesa does for glTexImage1D/2D/3D and
493 * glCompressedTexImage1D/2D/3D functions.
495 if (_mesa_base_tex_format(ctx
, internalformat
) < 0)
498 /* additional checks for depth textures */
499 if (!_mesa_legal_texture_base_format_for_target(ctx
, target
, internalformat
))
502 /* additional checks for compressed textures */
503 if (_mesa_is_compressed_format(ctx
, internalformat
) &&
504 (!_mesa_target_can_be_compressed(ctx
, target
, internalformat
, NULL
) ||
505 _mesa_format_no_online_compression(ctx
, internalformat
)))
509 case GL_TEXTURE_2D_MULTISAMPLE
:
510 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY
:
511 /* Based on what Mesa does for glTexImage2D/3DMultisample,
512 * glTexStorage2D/3DMultisample and
513 * glTextureStorage2D/3DMultisample functions.
515 if (!_mesa_is_renderable_texture_format(ctx
, internalformat
))
519 case GL_TEXTURE_BUFFER
:
520 /* Based on what Mesa does for the glTexBuffer function. */
521 if (_mesa_validate_texbuffer_format(ctx
, internalformat
) ==
526 case GL_RENDERBUFFER
:
527 /* Based on what Mesa does for glRenderbufferStorage(Multisample) and
528 * glNamedRenderbufferStorage functions.
530 if (!_mesa_base_fbo_format(ctx
, internalformat
))
535 unreachable("bad target");
542 _is_internalformat_supported(struct gl_context
*ctx
, GLenum target
,
543 GLenum internalformat
)
545 /* From the ARB_internalformat_query2 specification:
547 * "- INTERNALFORMAT_SUPPORTED: If <internalformat> is an internal format
548 * that is supported by the implementation in at least some subset of
549 * possible operations, TRUE is written to <params>. If <internalformat>
550 * if not a valid token for any internal format usage, FALSE is returned.
552 * <internalformats> that must be supported (in GL 4.2 or later) include
554 * - "sized internal formats" from Table 3.12, 3.13, and 3.15,
555 * - any specific "compressed internal format" from Table 3.14,
556 * - any "image unit format" from Table 3.21.
557 * - any generic "compressed internal format" from Table 3.14, if the
558 * implementation accepts it for any texture specification commands, and
559 * - unsized or base internal format, if the implementation accepts
560 * it for texture or image specification.
563 * "If the particualar <target> and <internalformat> combination do not make
564 * sense, or if a particular type of <target> is not supported by the
565 * implementation the "unsupported" answer should be given. This is not an
570 if (target
== GL_RENDERBUFFER
) {
571 if (_mesa_base_fbo_format(ctx
, internalformat
) == 0) {
574 } else if (target
== GL_TEXTURE_BUFFER
) {
575 if (_mesa_validate_texbuffer_format(ctx
, internalformat
) ==
580 if (_mesa_base_tex_format(ctx
, internalformat
) < 0) {
585 /* Let the driver have the final word */
586 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
,
587 GL_INTERNALFORMAT_SUPPORTED
, buffer
);
589 return (buffer
[0] == GL_TRUE
);
593 _legal_target_for_framebuffer_texture_layer(struct gl_context
*ctx
,
598 case GL_TEXTURE_1D_ARRAY
:
599 case GL_TEXTURE_2D_ARRAY
:
600 case GL_TEXTURE_CUBE_MAP_ARRAY
:
601 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY
:
602 case GL_TEXTURE_CUBE_MAP
:
610 _mesa_generic_type_for_internal_format(GLenum internalFormat
)
612 if (_mesa_is_enum_format_unsigned_int(internalFormat
))
613 return GL_UNSIGNED_BYTE
;
614 else if (_mesa_is_enum_format_signed_int(internalFormat
))
620 /* default implementation of QueryInternalFormat driverfunc, for
621 * drivers not implementing ARB_internalformat_query2.
624 _mesa_query_internal_format_default(struct gl_context
*ctx
, GLenum target
,
625 GLenum internalFormat
, GLenum pname
,
632 case GL_NUM_SAMPLE_COUNTS
:
636 case GL_INTERNALFORMAT_SUPPORTED
:
640 case GL_INTERNALFORMAT_PREFERRED
:
641 params
[0] = internalFormat
;
644 case GL_READ_PIXELS_FORMAT
: {
645 GLenum base_format
= _mesa_base_tex_format(ctx
, internalFormat
);
646 switch (base_format
) {
647 case GL_STENCIL_INDEX
:
648 case GL_DEPTH_COMPONENT
:
649 case GL_DEPTH_STENCIL
:
655 params
[0] = base_format
;
664 case GL_READ_PIXELS_TYPE
:
665 case GL_TEXTURE_IMAGE_TYPE
:
666 case GL_GET_TEXTURE_IMAGE_TYPE
: {
667 GLenum base_format
= _mesa_base_tex_format(ctx
, internalFormat
);
669 params
[0] = _mesa_generic_type_for_internal_format(internalFormat
);
675 case GL_TEXTURE_IMAGE_FORMAT
:
676 case GL_GET_TEXTURE_IMAGE_FORMAT
: {
677 GLenum format
= GL_NONE
;
678 GLenum base_format
= _mesa_base_tex_format(ctx
, internalFormat
);
679 if (base_format
> 0) {
680 if (_mesa_is_enum_format_integer(internalFormat
))
681 format
= _mesa_base_format_to_integer_format(base_format
);
683 format
= base_format
;
690 case GL_MANUAL_GENERATE_MIPMAP
:
691 case GL_AUTO_GENERATE_MIPMAP
:
694 case GL_SRGB_DECODE_ARB
:
695 case GL_VERTEX_TEXTURE
:
696 case GL_TESS_CONTROL_TEXTURE
:
697 case GL_TESS_EVALUATION_TEXTURE
:
698 case GL_GEOMETRY_TEXTURE
:
699 case GL_FRAGMENT_TEXTURE
:
700 case GL_COMPUTE_TEXTURE
:
701 case GL_SHADER_IMAGE_LOAD
:
702 case GL_SHADER_IMAGE_STORE
:
703 case GL_SHADER_IMAGE_ATOMIC
:
704 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST
:
705 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST
:
706 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE
:
707 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE
:
708 case GL_CLEAR_BUFFER
:
709 case GL_TEXTURE_VIEW
:
710 case GL_TEXTURE_SHADOW
:
711 case GL_TEXTURE_GATHER
:
712 case GL_TEXTURE_GATHER_SHADOW
:
713 case GL_FRAMEBUFFER_RENDERABLE
:
714 case GL_FRAMEBUFFER_RENDERABLE_LAYERED
:
715 case GL_FRAMEBUFFER_BLEND
:
718 * TODO seems a tad optimistic just saying yes to everything here.
719 * Even for combinations which make no sense...
720 * And things like TESS_CONTROL_TEXTURE should definitely default to
721 * NONE if the driver doesn't even support tessellation...
723 params
[0] = GL_FULL_SUPPORT
;
725 case GL_NUM_TILING_TYPES_EXT
:
728 case GL_TILING_TYPES_EXT
:
729 params
[0] = GL_OPTIMAL_TILING_EXT
;
730 params
[1] = GL_LINEAR_TILING_EXT
;
734 _set_default_response(pname
, params
);
740 * For MAX_WIDTH/MAX_HEIGHT/MAX_DEPTH it returns the equivalent GetInteger
741 * pname for a Getinternalformat pname/target combination. target/pname
742 * combinations that would return 0 due dimension number or unsupported status
743 * should be already filtered out
745 * Note that this means that the returned value would be independent of the
746 * internalformat. This possibility is already mentioned at the Issue 7 of the
747 * arb_internalformat_query2 spec.
750 _equivalent_size_pname(GLenum target
,
756 case GL_TEXTURE_2D_MULTISAMPLE
:
757 return GL_MAX_TEXTURE_SIZE
;
759 return GL_MAX_3D_TEXTURE_SIZE
;
760 case GL_TEXTURE_CUBE_MAP
:
761 return GL_MAX_CUBE_MAP_TEXTURE_SIZE
;
762 case GL_TEXTURE_RECTANGLE
:
763 return GL_MAX_RECTANGLE_TEXTURE_SIZE
;
764 case GL_RENDERBUFFER
:
765 return GL_MAX_RENDERBUFFER_SIZE
;
766 case GL_TEXTURE_1D_ARRAY
:
767 if (pname
== GL_MAX_HEIGHT
)
768 return GL_MAX_ARRAY_TEXTURE_LAYERS
;
770 return GL_MAX_TEXTURE_SIZE
;
771 case GL_TEXTURE_2D_ARRAY
:
772 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY
:
773 if (pname
== GL_MAX_DEPTH
)
774 return GL_MAX_ARRAY_TEXTURE_LAYERS
;
776 return GL_MAX_TEXTURE_SIZE
;
777 case GL_TEXTURE_CUBE_MAP_ARRAY
:
778 if (pname
== GL_MAX_DEPTH
)
779 return GL_MAX_ARRAY_TEXTURE_LAYERS
;
781 return GL_MAX_CUBE_MAP_TEXTURE_SIZE
;
782 case GL_TEXTURE_BUFFER
:
783 return GL_MAX_TEXTURE_BUFFER_SIZE
;
790 * Returns the dimensions associated to a target. GL_TEXTURE_BUFFER and
791 * GL_RENDERBUFFER have associated a dimension, but they are not textures
792 * per-se, so we can't just call _mesa_get_texture_dimension directly.
795 _get_target_dimensions(GLenum target
)
798 case GL_TEXTURE_BUFFER
:
800 case GL_RENDERBUFFER
:
803 return _mesa_get_texture_dimensions(target
);
808 * Returns the minimum amount of dimensions associated to a pname. So for
809 * example, if querying GL_MAX_HEIGHT, it is assumed that your target would
810 * have as minimum 2 dimensions.
812 * Useful to handle sentences like this from query2 spec:
816 * If the resource does not have at least two dimensions
820 _get_min_dimensions(GLenum pname
)
835 * Similar to teximage.c:check_multisample_target, but independent of the
839 _is_multisample_target(GLenum target
)
842 case GL_TEXTURE_2D_MULTISAMPLE
:
843 case GL_TEXTURE_2D_MULTISAMPLE_ARRAY
:
852 _mesa_GetInternalformativ(GLenum target
, GLenum internalformat
, GLenum pname
,
853 GLsizei bufSize
, GLint
*params
)
856 GET_CURRENT_CONTEXT(ctx
);
858 ASSERT_OUTSIDE_BEGIN_END(ctx
);
860 /* ARB_internalformat_query is also mandatory for ARB_internalformat_query2 */
861 if (!(_mesa_has_ARB_internalformat_query(ctx
) ||
862 _mesa_is_gles3(ctx
))) {
863 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInternalformativ");
867 assert(ctx
->Driver
.QueryInternalFormat
!= NULL
);
869 if (!_legal_parameters(ctx
, target
, internalformat
, pname
, bufSize
, params
))
872 /* initialize the contents of the temporary buffer */
873 memcpy(buffer
, params
, MIN2(bufSize
, 16) * sizeof(GLint
));
875 /* Use the 'unsupported' response defined by the spec for every pname
876 * as the default answer.
878 _set_default_response(pname
, buffer
);
880 if (!_is_target_supported(ctx
, target
) ||
881 !_is_internalformat_supported(ctx
, target
, internalformat
) ||
882 !_is_resource_supported(ctx
, target
, internalformat
, pname
))
888 case GL_NUM_SAMPLE_COUNTS
:
889 /* The ARB_internalformat_query2 sets the response as 'unsupported' for
890 * SAMPLES and NUM_SAMPLE_COUNTS:
892 * "If <internalformat> is not color-renderable, depth-renderable, or
893 * stencil-renderable (as defined in section 4.4.4), or if <target>
894 * does not support multiple samples (ie other than
895 * TEXTURE_2D_MULTISAMPLE, TEXTURE_2D_MULTISAMPLE_ARRAY,
898 if ((target
!= GL_RENDERBUFFER
&&
899 target
!= GL_TEXTURE_2D_MULTISAMPLE
&&
900 target
!= GL_TEXTURE_2D_MULTISAMPLE_ARRAY
) ||
901 !_is_renderable(ctx
, internalformat
))
904 /* The GL ES 3.0 specification, section 6.1.15 page 236 says:
906 * "Since multisampling is not supported for signed and unsigned
907 * integer internal formats, the value of NUM_SAMPLE_COUNTS will be
908 * zero for such formats.
910 * Since OpenGL ES 3.1 adds support for multisampled integer formats, we
911 * have to check the version for 30 exactly.
913 if (pname
== GL_NUM_SAMPLE_COUNTS
&& ctx
->API
== API_OPENGLES2
&&
914 ctx
->Version
== 30 && _mesa_is_enum_format_integer(internalformat
)) {
918 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
922 case GL_INTERNALFORMAT_SUPPORTED
:
923 /* Having a supported <internalformat> is implemented as a prerequisite
924 * for all the <pnames>. Thus, if we reach this point, the internalformat is
930 case GL_INTERNALFORMAT_PREFERRED
:
931 /* The ARB_internalformat_query2 spec says:
933 * "- INTERNALFORMAT_PREFERRED: The implementation-preferred internal
934 * format for representing resources of the specified <internalformat> is
935 * returned in <params>.
937 * Therefore, we let the driver answer. Note that if we reach this
938 * point, it means that the internalformat is supported, so the driver
939 * is called just to try to get a preferred format. If not supported,
940 * GL_NONE was already returned and the driver is not called.
942 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
946 case GL_INTERNALFORMAT_RED_SIZE
:
947 case GL_INTERNALFORMAT_GREEN_SIZE
:
948 case GL_INTERNALFORMAT_BLUE_SIZE
:
949 case GL_INTERNALFORMAT_ALPHA_SIZE
:
950 case GL_INTERNALFORMAT_DEPTH_SIZE
:
951 case GL_INTERNALFORMAT_STENCIL_SIZE
:
952 case GL_INTERNALFORMAT_SHARED_SIZE
:
953 case GL_INTERNALFORMAT_RED_TYPE
:
954 case GL_INTERNALFORMAT_GREEN_TYPE
:
955 case GL_INTERNALFORMAT_BLUE_TYPE
:
956 case GL_INTERNALFORMAT_ALPHA_TYPE
:
957 case GL_INTERNALFORMAT_DEPTH_TYPE
:
958 case GL_INTERNALFORMAT_STENCIL_TYPE
: {
960 mesa_format texformat
;
962 if (target
!= GL_RENDERBUFFER
) {
963 baseformat
= _mesa_base_tex_format(ctx
, internalformat
);
965 baseformat
= _mesa_base_fbo_format(ctx
, internalformat
);
968 /* Let the driver choose the texture format.
970 * Disclaimer: I am considering that drivers use for renderbuffers the
971 * same format-choice logic as for textures.
973 texformat
= ctx
->Driver
.ChooseTextureFormat(ctx
, target
, internalformat
,
974 GL_NONE
/*format */, GL_NONE
/* type */);
976 if (texformat
== MESA_FORMAT_NONE
|| baseformat
<= 0)
979 /* Implementation based on what Mesa does for glGetTexLevelParameteriv
980 * and glGetRenderbufferParameteriv functions.
982 if (pname
== GL_INTERNALFORMAT_SHARED_SIZE
) {
983 if (texformat
== MESA_FORMAT_R9G9B9E5_FLOAT
) {
989 if (!_mesa_base_format_has_channel(baseformat
, pname
))
993 case GL_INTERNALFORMAT_DEPTH_SIZE
:
994 if (ctx
->API
!= API_OPENGL_CORE
&&
995 !_mesa_has_ARB_depth_texture(ctx
) &&
996 target
!= GL_RENDERBUFFER
&&
997 target
!= GL_TEXTURE_BUFFER
)
1000 case GL_INTERNALFORMAT_RED_SIZE
:
1001 case GL_INTERNALFORMAT_GREEN_SIZE
:
1002 case GL_INTERNALFORMAT_BLUE_SIZE
:
1003 case GL_INTERNALFORMAT_ALPHA_SIZE
:
1004 case GL_INTERNALFORMAT_STENCIL_SIZE
:
1005 buffer
[0] = _mesa_get_format_bits(texformat
, pname
);
1008 case GL_INTERNALFORMAT_DEPTH_TYPE
:
1009 if (!_mesa_has_ARB_texture_float(ctx
))
1012 case GL_INTERNALFORMAT_RED_TYPE
:
1013 case GL_INTERNALFORMAT_GREEN_TYPE
:
1014 case GL_INTERNALFORMAT_BLUE_TYPE
:
1015 case GL_INTERNALFORMAT_ALPHA_TYPE
:
1016 case GL_INTERNALFORMAT_STENCIL_TYPE
:
1017 buffer
[0] = _mesa_get_format_datatype(texformat
);
1027 /* For WIDTH/HEIGHT/DEPTH/LAYERS there is no reason to think that the
1028 * returned values should be different to the values returned by
1029 * GetInteger with MAX_TEXTURE_SIZE, MAX_3D_TEXTURE_SIZE, etc.*/
1032 case GL_MAX_DEPTH
: {
1035 GLint min_dimensions
;
1037 /* From query2:MAX_HEIGHT spec (as example):
1039 * "If the resource does not have at least two dimensions, or if the
1040 * resource is unsupported, zero is returned."
1042 dimensions
= _get_target_dimensions(target
);
1043 min_dimensions
= _get_min_dimensions(pname
);
1044 if (dimensions
< min_dimensions
)
1047 get_pname
= _equivalent_size_pname(target
, pname
);
1051 _mesa_GetIntegerv(get_pname
, buffer
);
1056 if (!_mesa_has_EXT_texture_array(ctx
))
1059 if (!_mesa_is_array_texture(target
))
1062 _mesa_GetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS
, buffer
);
1065 case GL_MAX_COMBINED_DIMENSIONS
:{
1066 GLint64 combined_value
= 1;
1067 GLenum max_dimensions_pnames
[] = {
1074 GLint current_value
;
1076 /* Combining the dimensions. Note that for array targets, this would
1077 * automatically include the value of MAX_LAYERS, as that value is
1078 * returned as MAX_HEIGHT or MAX_DEPTH */
1079 for (i
= 0; i
< 4; i
++) {
1080 if (max_dimensions_pnames
[i
] == GL_SAMPLES
&&
1081 !_is_multisample_target(target
))
1084 _mesa_GetInternalformativ(target
, internalformat
,
1085 max_dimensions_pnames
[i
],
1088 if (current_value
!= 0)
1089 combined_value
*= current_value
;
1092 if (_mesa_is_cube_map_texture(target
))
1093 combined_value
*= 6;
1095 /* We pack the 64-bit value on two 32-bit values. Calling the 32-bit
1096 * query, this would work as far as the value can be hold on a 32-bit
1097 * signed integer. For the 64-bit query, the wrapper around the 32-bit
1098 * query will unpack the value */
1099 memcpy(buffer
, &combined_value
, sizeof(GLint64
));
1103 case GL_COLOR_COMPONENTS
:
1104 /* The ARB_internalformat_query2 spec says:
1106 * "- COLOR_COMPONENTS: If the internal format contains any color
1107 * components (R, G, B, or A), TRUE is returned in <params>.
1108 * If the internal format is unsupported or contains no color
1109 * components, FALSE is returned."
1111 if (_mesa_is_color_format(internalformat
))
1112 buffer
[0] = GL_TRUE
;
1115 case GL_DEPTH_COMPONENTS
:
1116 /* The ARB_internalformat_query2 spec says:
1118 * "- DEPTH_COMPONENTS: If the internal format contains a depth
1119 * component (D), TRUE is returned in <params>. If the internal format
1120 * is unsupported or contains no depth component, FALSE is returned."
1122 if (_mesa_is_depth_format(internalformat
) ||
1123 _mesa_is_depthstencil_format(internalformat
))
1124 buffer
[0] = GL_TRUE
;
1127 case GL_STENCIL_COMPONENTS
:
1128 /* The ARB_internalformat_query2 spec says:
1130 * "- STENCIL_COMPONENTS: If the internal format contains a stencil
1131 * component (S), TRUE is returned in <params>. If the internal format
1132 * is unsupported or contains no stencil component, FALSE is returned.
1134 if (_mesa_is_stencil_format(internalformat
) ||
1135 _mesa_is_depthstencil_format(internalformat
))
1136 buffer
[0] = GL_TRUE
;
1139 case GL_COLOR_RENDERABLE
:
1140 case GL_DEPTH_RENDERABLE
:
1141 case GL_STENCIL_RENDERABLE
:
1142 if (!_is_renderable(ctx
, internalformat
))
1145 if (pname
== GL_COLOR_RENDERABLE
) {
1146 if (!_mesa_is_color_format(internalformat
))
1149 GLenum baseFormat
= _mesa_base_fbo_format(ctx
, internalformat
);
1150 if (baseFormat
!= GL_DEPTH_STENCIL
&&
1151 ((pname
== GL_DEPTH_RENDERABLE
&& baseFormat
!= GL_DEPTH_COMPONENT
) ||
1152 (pname
== GL_STENCIL_RENDERABLE
&& baseFormat
!= GL_STENCIL_INDEX
)))
1156 buffer
[0] = GL_TRUE
;
1159 case GL_FRAMEBUFFER_RENDERABLE_LAYERED
:
1160 if (!_mesa_has_EXT_texture_array(ctx
) ||
1161 _legal_target_for_framebuffer_texture_layer(ctx
, target
))
1164 case GL_FRAMEBUFFER_RENDERABLE
:
1165 case GL_FRAMEBUFFER_BLEND
:
1166 if (!_mesa_has_ARB_framebuffer_object(ctx
))
1169 if (target
== GL_TEXTURE_BUFFER
||
1170 !_is_renderable(ctx
, internalformat
))
1173 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1177 case GL_READ_PIXELS
:
1178 case GL_READ_PIXELS_FORMAT
:
1179 case GL_READ_PIXELS_TYPE
:
1180 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1184 case GL_TEXTURE_IMAGE_FORMAT
:
1185 case GL_GET_TEXTURE_IMAGE_FORMAT
:
1186 case GL_TEXTURE_IMAGE_TYPE
:
1187 case GL_GET_TEXTURE_IMAGE_TYPE
:
1188 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1193 case GL_MANUAL_GENERATE_MIPMAP
:
1194 case GL_AUTO_GENERATE_MIPMAP
:
1195 if (!_mesa_is_valid_generate_texture_mipmap_target(ctx
, target
) ||
1196 !_mesa_is_valid_generate_texture_mipmap_internalformat(ctx
,
1201 if (pname
== GL_MIPMAP
) {
1202 buffer
[0] = GL_TRUE
;
1205 else if (pname
== GL_MANUAL_GENERATE_MIPMAP
) {
1206 if (!_mesa_has_ARB_framebuffer_object(ctx
))
1210 /* From ARB_internalformat_query2:
1211 * "Dependencies on OpenGL 3.2 (Core Profile)
1212 * In core profiles for OpenGL 3.2 and later versions, queries
1213 * for the AUTO_GENERATE_MIPMAP <pname> return the appropriate
1214 * unsupported response."
1216 if (_mesa_is_desktop_gl(ctx
) && ctx
->Version
>= 32)
1220 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1224 case GL_COLOR_ENCODING
:
1225 if (!_mesa_is_color_format(internalformat
))
1228 if (_mesa_is_srgb_format(internalformat
))
1229 buffer
[0] = GL_SRGB
;
1231 buffer
[0] = GL_LINEAR
;
1235 if (!_mesa_has_EXT_texture_sRGB(ctx
) ||
1236 !_mesa_is_srgb_format(internalformat
)) {
1240 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1245 if (!_mesa_has_EXT_framebuffer_sRGB(ctx
) ||
1246 !_mesa_is_color_format(internalformat
)) {
1250 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1254 case GL_SRGB_DECODE_ARB
:
1255 /* Presence of EXT_texture_sRGB_decode was already verified */
1256 if (!_mesa_has_EXT_texture_sRGB(ctx
) ||
1257 target
== GL_RENDERBUFFER
||
1258 !_mesa_is_srgb_format(internalformat
)) {
1262 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1267 /* If it doesn't allow to set sampler parameters then it would not allow
1268 * to set a filter different to GL_NEAREST. In practice, this method
1269 * only filters out MULTISAMPLE/MULTISAMPLE_ARRAY */
1270 if (!_mesa_target_allows_setting_sampler_parameters(target
))
1273 if (_mesa_is_enum_format_integer(internalformat
))
1276 if (target
== GL_TEXTURE_BUFFER
)
1279 /* At this point we know that multi-texel filtering is supported. We
1280 * need to call the driver to know if it is CAVEAT_SUPPORT or
1283 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1287 case GL_VERTEX_TEXTURE
:
1288 case GL_TESS_CONTROL_TEXTURE
:
1289 case GL_TESS_EVALUATION_TEXTURE
:
1290 case GL_GEOMETRY_TEXTURE
:
1291 case GL_FRAGMENT_TEXTURE
:
1292 case GL_COMPUTE_TEXTURE
:
1293 if (target
== GL_RENDERBUFFER
)
1296 if ((pname
== GL_TESS_CONTROL_TEXTURE
||
1297 pname
== GL_TESS_EVALUATION_TEXTURE
) &&
1298 !_mesa_has_tessellation(ctx
))
1301 if (pname
== GL_GEOMETRY_TEXTURE
&& !_mesa_has_geometry_shaders(ctx
))
1304 if (pname
== GL_COMPUTE_TEXTURE
&& !_mesa_has_compute_shaders(ctx
))
1307 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1311 case GL_TEXTURE_GATHER
:
1312 case GL_TEXTURE_GATHER_SHADOW
:
1313 if (!_mesa_has_ARB_texture_gather(ctx
))
1317 case GL_TEXTURE_SHADOW
:
1318 /* Only depth or depth-stencil image formats make sense in shadow
1320 if (pname
!= GL_TEXTURE_GATHER
&&
1321 !_mesa_is_depth_format(internalformat
) &&
1322 !_mesa_is_depthstencil_format(internalformat
))
1325 /* Validate the target for shadow and gather operations */
1328 case GL_TEXTURE_2D_ARRAY
:
1329 case GL_TEXTURE_CUBE_MAP
:
1330 case GL_TEXTURE_CUBE_MAP_ARRAY
:
1331 case GL_TEXTURE_RECTANGLE
:
1335 case GL_TEXTURE_1D_ARRAY
:
1336 /* 1D and 1DArray textures are not admitted in gather operations */
1337 if (pname
!= GL_TEXTURE_SHADOW
)
1345 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1349 case GL_SHADER_IMAGE_LOAD
:
1350 case GL_SHADER_IMAGE_STORE
:
1351 if (!_mesa_has_ARB_shader_image_load_store(ctx
))
1354 /* We call to _mesa_is_shader_image_format_supported
1355 * using "internalformat" as parameter, because the
1356 * the ARB_internalformat_query2 spec says:
1357 * "In this case the <internalformat> is the value of the <format>
1358 * parameter that is passed to BindImageTexture."
1360 if (target
== GL_RENDERBUFFER
||
1361 !_mesa_is_shader_image_format_supported(ctx
, internalformat
))
1364 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1368 case GL_SHADER_IMAGE_ATOMIC
:
1369 if (!_mesa_has_ARB_shader_image_load_store(ctx
))
1372 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1376 case GL_IMAGE_TEXEL_SIZE
: {
1377 mesa_format image_format
;
1379 if (!_mesa_has_ARB_shader_image_load_store(ctx
) ||
1380 target
== GL_RENDERBUFFER
)
1383 image_format
= _mesa_get_shader_image_format(internalformat
);
1384 if (image_format
== MESA_FORMAT_NONE
)
1387 /* We return bits */
1388 buffer
[0] = (_mesa_get_format_bytes(image_format
) * 8);
1392 case GL_IMAGE_COMPATIBILITY_CLASS
:
1393 if (!_mesa_has_ARB_shader_image_load_store(ctx
) ||
1394 target
== GL_RENDERBUFFER
)
1397 buffer
[0] = _mesa_get_image_format_class(internalformat
);
1400 case GL_IMAGE_PIXEL_FORMAT
: {
1403 if (!_mesa_has_ARB_shader_image_load_store(ctx
) ||
1404 target
== GL_RENDERBUFFER
||
1405 !_mesa_is_shader_image_format_supported(ctx
, internalformat
))
1408 base_format
= _mesa_base_tex_format(ctx
, internalformat
);
1409 if (base_format
== -1)
1412 if (_mesa_is_enum_format_integer(internalformat
))
1413 buffer
[0] = _mesa_base_format_to_integer_format(base_format
);
1415 buffer
[0] = base_format
;
1419 case GL_IMAGE_PIXEL_TYPE
: {
1420 mesa_format image_format
;
1424 if (!_mesa_has_ARB_shader_image_load_store(ctx
) ||
1425 target
== GL_RENDERBUFFER
)
1428 image_format
= _mesa_get_shader_image_format(internalformat
);
1429 if (image_format
== MESA_FORMAT_NONE
)
1432 _mesa_uncompressed_format_to_type_and_comps(image_format
, &datatype
,
1437 buffer
[0] = datatype
;
1441 case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE
: {
1442 if (!_mesa_has_ARB_shader_image_load_store(ctx
))
1445 /* As pointed by the spec quote below, this pname query should return
1446 * the same value that GetTexParameter. So if the target is not valid
1447 * for GetTexParameter we return the unsupported value. The check below
1448 * is the same target check used by GetTexParameter.
1450 int targetIndex
= _mesa_tex_target_to_index(ctx
, target
);
1451 if (targetIndex
< 0 || targetIndex
== TEXTURE_BUFFER_INDEX
)
1454 /* From spec: "Equivalent to calling GetTexParameter with <value> set
1455 * to IMAGE_FORMAT_COMPATIBILITY_TYPE."
1457 * GetTexParameter just returns
1458 * tex_obj->ImageFormatCompatibilityType. We create a fake tex_obj
1459 * just with the purpose of getting the value.
1461 struct gl_texture_object
*tex_obj
= _mesa_new_texture_object(ctx
, 0, target
);
1462 buffer
[0] = tex_obj
->ImageFormatCompatibilityType
;
1463 _mesa_delete_texture_object(ctx
, tex_obj
);
1468 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST
:
1469 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST
:
1470 case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE
:
1471 case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE
:
1472 if (target
== GL_RENDERBUFFER
)
1475 if (!_mesa_is_depthstencil_format(internalformat
)) {
1476 if (((pname
== GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST
||
1477 pname
== GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE
) &&
1478 !_mesa_is_depth_format(internalformat
)) ||
1479 ((pname
== GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST
||
1480 pname
== GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE
) &&
1481 !_mesa_is_stencil_format(internalformat
)))
1485 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1489 case GL_TEXTURE_COMPRESSED
:
1490 buffer
[0] = _mesa_is_compressed_format(ctx
, internalformat
);
1493 case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH
:
1494 case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT
:
1495 case GL_TEXTURE_COMPRESSED_BLOCK_SIZE
: {
1496 mesa_format mesaformat
;
1499 mesaformat
= _mesa_glenum_to_compressed_format(internalformat
);
1500 if (mesaformat
== MESA_FORMAT_NONE
)
1503 block_size
= _mesa_get_format_bytes(mesaformat
);
1504 assert(block_size
> 0);
1506 if (pname
== GL_TEXTURE_COMPRESSED_BLOCK_SIZE
) {
1507 buffer
[0] = block_size
;
1509 GLuint bwidth
, bheight
;
1511 /* Returns the width and height in pixels. We return bytes */
1512 _mesa_get_format_block_size(mesaformat
, &bwidth
, &bheight
);
1513 assert(bwidth
> 0 && bheight
> 0);
1515 if (pname
== GL_TEXTURE_COMPRESSED_BLOCK_WIDTH
)
1516 buffer
[0] = block_size
/ bheight
;
1518 buffer
[0] = block_size
/ bwidth
;
1523 case GL_CLEAR_BUFFER
:
1524 if (target
!= GL_TEXTURE_BUFFER
)
1527 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1531 case GL_TEXTURE_VIEW
:
1532 case GL_VIEW_COMPATIBILITY_CLASS
:
1533 if (!_mesa_has_ARB_texture_view(ctx
) ||
1534 target
== GL_TEXTURE_BUFFER
||
1535 target
== GL_RENDERBUFFER
)
1538 if (pname
== GL_TEXTURE_VIEW
) {
1539 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1542 GLenum view_class
= _mesa_texture_view_lookup_view_class(ctx
,
1544 if (view_class
== GL_FALSE
)
1547 buffer
[0] = view_class
;
1551 case GL_NUM_TILING_TYPES_EXT
:
1552 case GL_TILING_TYPES_EXT
:
1553 ctx
->Driver
.QueryInternalFormat(ctx
, target
, internalformat
, pname
,
1558 unreachable("bad param");
1562 if (bufSize
!= 0 && params
== NULL
) {
1563 /* Emit a warning to aid application debugging, but go ahead and do the
1564 * memcpy (and probably crash) anyway.
1567 "glGetInternalformativ(bufSize = %d, but params = NULL)",
1571 /* Copy the data from the temporary buffer to the buffer supplied by the
1572 * application. Clamp the size of the copy to the size supplied by the
1575 memcpy(params
, buffer
, MIN2(bufSize
, 16) * sizeof(GLint
));
1581 _mesa_GetInternalformati64v(GLenum target
, GLenum internalformat
,
1582 GLenum pname
, GLsizei bufSize
, GLint64
*params
)
1586 GLsizei realSize
= MIN2(bufSize
, 16);
1589 GET_CURRENT_CONTEXT(ctx
);
1591 ASSERT_OUTSIDE_BEGIN_END(ctx
);
1593 if (!_mesa_has_ARB_internalformat_query2(ctx
)) {
1594 _mesa_error(ctx
, GL_INVALID_OPERATION
, "glGetInternalformati64v");
1598 /* For SAMPLES there are cases where params needs to remain unmodified. As
1599 * no pname can return a negative value, we fill params32 with negative
1600 * values as reference values, that can be used to know what copy-back to
1602 for (i
= 0; i
< realSize
; i
++)
1605 /* For GL_MAX_COMBINED_DIMENSIONS we need to get back 2 32-bit integers,
1606 * and at the same time we only need 2. So for that pname, we call the
1607 * 32-bit query with bufSize 2, except on the case of bufSize 0, that is
1608 * basically like asking to not get the value, but that is a caller
1610 if (pname
== GL_MAX_COMBINED_DIMENSIONS
&& bufSize
> 0)
1615 _mesa_GetInternalformativ(target
, internalformat
, pname
, callSize
, params32
);
1617 if (pname
== GL_MAX_COMBINED_DIMENSIONS
) {
1618 memcpy(params
, params32
, sizeof(GLint64
));
1620 for (i
= 0; i
< realSize
; i
++) {
1621 /* We only copy back the values that changed */
1622 if (params32
[i
] < 0)
1624 params
[i
] = (GLint64
) params32
[i
];