static bool
supported_interface_enum(struct gl_context *ctx, GLenum iface)
{
switch (iface) {
case GL_UNIFORM:
case GL_UNIFORM_BLOCK:
case GL_PROGRAM_INPUT:
case GL_PROGRAM_OUTPUT:
case GL_TRANSFORM_FEEDBACK_VARYING:
case GL_ATOMIC_COUNTER_BUFFER:
case GL_BUFFER_VARIABLE:
case GL_SHADER_STORAGE_BLOCK:
return true;
case GL_VERTEX_SUBROUTINE:
case GL_FRAGMENT_SUBROUTINE:
case GL_VERTEX_SUBROUTINE_UNIFORM:
case GL_FRAGMENT_SUBROUTINE_UNIFORM:
return _mesa_has_shader_subroutine(ctx);
case GL_GEOMETRY_SUBROUTINE:
case GL_GEOMETRY_SUBROUTINE_UNIFORM:
return _mesa_has_geometry_shaders(ctx) && _mesa_has_shader_subroutine(ctx);
case GL_COMPUTE_SUBROUTINE:
case GL_COMPUTE_SUBROUTINE_UNIFORM:
return _mesa_has_compute_shaders(ctx) && _mesa_has_shader_subroutine(ctx);
case GL_TESS_CONTROL_SUBROUTINE:
case GL_TESS_EVALUATION_SUBROUTINE:
case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
return _mesa_has_tessellation(ctx) && _mesa_has_shader_subroutine(ctx);
default:
return false;
}
}
/**
* Is 'mode' a valid value for glBegin(), glDrawArrays(), glDrawElements(),
* etc? The set of legal values depends on whether geometry shaders/programs
* are supported.
* Note: This may be called during display list compilation.
*/
bool
_mesa_is_valid_prim_mode(struct gl_context *ctx, GLenum mode)
{
switch (mode) {
case GL_POINTS:
case GL_LINES:
case GL_LINE_LOOP:
case GL_LINE_STRIP:
case GL_TRIANGLES:
case GL_TRIANGLE_STRIP:
case GL_TRIANGLE_FAN:
return true;
case GL_QUADS:
case GL_QUAD_STRIP:
case GL_POLYGON:
return (ctx->API == API_OPENGL_COMPAT);
case GL_LINES_ADJACENCY:
case GL_LINE_STRIP_ADJACENCY:
case GL_TRIANGLES_ADJACENCY:
case GL_TRIANGLE_STRIP_ADJACENCY:
return _mesa_has_geometry_shaders(ctx);
default:
return false;
}
}
/**
* glGetProgramPipelineiv() - get pipeline shader state.
*/
void GLAPIENTRY
_mesa_GetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_pipeline_object *pipe = lookup_pipeline_object(ctx, pipeline);
/* Are geometry shaders available in this context?
*/
const bool has_gs = _mesa_has_geometry_shaders(ctx);
if (!pipe) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glGetProgramPipelineiv(pipeline)");
return;
}
/* Object is created by any Pipeline call but glGenProgramPipelines,
* glIsProgramPipeline and GetProgramPipelineInfoLog
*/
pipe->EverBound = GL_TRUE;
switch (pname) {
case GL_ACTIVE_PROGRAM:
*params = pipe->ActiveProgram ? pipe->ActiveProgram->Name : 0;
return;
case GL_INFO_LOG_LENGTH:
*params = pipe->InfoLog ? strlen(pipe->InfoLog) + 1 : 0;
return;
case GL_VALIDATE_STATUS:
*params = pipe->Validated;
return;
case GL_VERTEX_SHADER:
*params = pipe->CurrentProgram[MESA_SHADER_VERTEX]
? pipe->CurrentProgram[MESA_SHADER_VERTEX]->Name : 0;
return;
case GL_TESS_EVALUATION_SHADER:
/* NOT YET SUPPORTED */
break;
case GL_TESS_CONTROL_SHADER:
/* NOT YET SUPPORTED */
break;
case GL_GEOMETRY_SHADER:
if (!has_gs)
break;
*params = pipe->CurrentProgram[MESA_SHADER_GEOMETRY]
? pipe->CurrentProgram[MESA_SHADER_GEOMETRY]->Name : 0;
return;
case GL_FRAGMENT_SHADER:
*params = pipe->CurrentProgram[MESA_SHADER_FRAGMENT]
? pipe->CurrentProgram[MESA_SHADER_FRAGMENT]->Name : 0;
return;
default:
break;
}
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramPipelineiv(pname=%s)",
_mesa_lookup_enum_by_nr(pname));
}
GLint GLAPIENTRY
_mesa_GetProgramResourceLocation(GLuint program, GLenum programInterface,
const GLchar *name)
{
GET_CURRENT_CONTEXT(ctx);
if (MESA_VERBOSE & VERBOSE_API) {
_mesa_debug(ctx, "glGetProgramResourceLocation(%u, %s, %s)\n",
program, _mesa_enum_to_string(programInterface), name);
}
struct gl_shader_program *shProg =
lookup_linked_program(program, "glGetProgramResourceLocation");
if (!shProg || !name)
return -1;
/* Validate programInterface. */
switch (programInterface) {
case GL_UNIFORM:
case GL_PROGRAM_INPUT:
case GL_PROGRAM_OUTPUT:
break;
case GL_VERTEX_SUBROUTINE_UNIFORM:
case GL_FRAGMENT_SUBROUTINE_UNIFORM:
if (!_mesa_has_shader_subroutine(ctx))
goto fail;
break;
case GL_GEOMETRY_SUBROUTINE_UNIFORM:
if (!_mesa_has_geometry_shaders(ctx) || !_mesa_has_shader_subroutine(ctx))
goto fail;
break;
case GL_COMPUTE_SUBROUTINE_UNIFORM:
if (!_mesa_has_compute_shaders(ctx) || !_mesa_has_shader_subroutine(ctx))
goto fail;
break;
case GL_TESS_CONTROL_SUBROUTINE_UNIFORM:
case GL_TESS_EVALUATION_SUBROUTINE_UNIFORM:
if (!_mesa_has_tessellation(ctx) || !_mesa_has_shader_subroutine(ctx))
goto fail;
break;
default:
goto fail;
}
return _mesa_program_resource_location(shProg, programInterface, name);
fail:
_mesa_error(ctx, GL_INVALID_ENUM, "glGetProgramResourceLocation(%s %s)",
_mesa_enum_to_string(programInterface), name);
return -1;
}
/**
* Confirm that the a shader type is valid and supported by the implementation
*
* \param ctx Current GL context
* \param type Shader target
*
*/
static bool
validate_shader_target(const struct gl_context *ctx, GLenum type)
{
switch (type) {
case GL_FRAGMENT_SHADER:
return ctx->Extensions.ARB_fragment_shader;
case GL_VERTEX_SHADER:
return ctx->Extensions.ARB_vertex_shader;
case GL_GEOMETRY_SHADER_ARB:
return _mesa_has_geometry_shaders(ctx);
default:
return false;
}
}
/**
* Is 'mode' a valid value for glBegin(), glDrawArrays(), glDrawElements(),
* etc? The set of legal values depends on whether geometry shaders/programs
* are supported.
* Note: This may be called during display list compilation.
*/
bool
_mesa_is_valid_prim_mode(struct gl_context *ctx, GLenum mode)
{
/* The overwhelmingly common case is (mode <= GL_TRIANGLE_FAN). Test that
* first and exit. You would think that a switch-statement would be the
* right approach, but at least GCC 4.7.2 generates some pretty dire code
* for the common case.
*/
if (likely(mode <= GL_TRIANGLE_FAN))
return true;
if (mode <= GL_POLYGON)
return (ctx->API == API_OPENGL_COMPAT);
if (mode <= GL_TRIANGLE_STRIP_ADJACENCY)
return _mesa_has_geometry_shaders(ctx);
if (mode == GL_PATCHES)
return _mesa_has_tessellation(ctx);
return false;
}
/**
* Bound program to severals stages of the pipeline
*/
void GLAPIENTRY
_mesa_UseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
{
GET_CURRENT_CONTEXT(ctx);
struct gl_pipeline_object *pipe = lookup_pipeline_object(ctx, pipeline);
struct gl_shader_program *shProg = NULL;
GLbitfield any_valid_stages;
if (!pipe) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glUseProgramStages(pipeline)");
return;
}
/* Object is created by any Pipeline call but glGenProgramPipelines,
* glIsProgramPipeline and GetProgramPipelineInfoLog
*/
pipe->EverBound = GL_TRUE;
/* Section 2.11.4 (Program Pipeline Objects) of the OpenGL 4.1 spec says:
*
* "If stages is not the special value ALL_SHADER_BITS, and has a bit
* set that is not recognized, the error INVALID_VALUE is generated."
*
* NOT YET SUPPORTED:
* GL_TESS_CONTROL_SHADER_BIT
* GL_TESS_EVALUATION_SHADER_BIT
*/
any_valid_stages = GL_VERTEX_SHADER_BIT | GL_FRAGMENT_SHADER_BIT;
if (_mesa_has_geometry_shaders(ctx))
any_valid_stages |= GL_GEOMETRY_SHADER_BIT;
if (stages != GL_ALL_SHADER_BITS && (stages & ~any_valid_stages) != 0) {
_mesa_error(ctx, GL_INVALID_VALUE, "glUseProgramStages(Stages)");
return;
}
/* Section 2.17.2 (Transform Feedback Primitive Capture) of the OpenGL 4.1
* spec says:
*
* "The error INVALID_OPERATION is generated:
*
* ...
*
* - by UseProgramStages if the program pipeline object it refers
* to is current and the current transform feedback object is
* active and not paused;
*/
if (ctx->_Shader == pipe) {
if (_mesa_is_xfb_active_and_unpaused(ctx)) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glUseProgramStages(transform feedback active)");
return;
}
}
if (program) {
shProg = _mesa_lookup_shader_program_err(ctx, program,
"glUseProgramStages");
if (shProg == NULL)
return;
/* Section 2.11.4 (Program Pipeline Objects) of the OpenGL 4.1 spec
* says:
*
* "If the program object named by program was linked without the
* PROGRAM_SEPARABLE parameter set, or was not linked successfully,
* the error INVALID_OPERATION is generated and the corresponding
* shader stages in the pipeline program pipeline object are not
* modified."
*/
if (!shProg->LinkStatus) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glUseProgramStages(program not linked)");
return;
}
if (!shProg->SeparateShader) {
_mesa_error(ctx, GL_INVALID_OPERATION,
"glUseProgramStages(program wasn't linked with the "
"PROGRAM_SEPARABLE flag)");
return;
}
}
/* Enable individual stages from the program as requested by the
* application. If there is no shader for a requested stage in the
* program, _mesa_use_shader_program will enable fixed-function processing
* as dictated by the spec.
*
* Section 2.11.4 (Program Pipeline Objects) of the OpenGL 4.1 spec
* says:
*
* "If UseProgramStages is called with program set to zero or with a
* program object that contains no executable code for the given
* stages, it is as if the pipeline object has no programmable stage
* configured for the indicated shader stages."
*/
if ((stages & GL_VERTEX_SHADER_BIT) != 0)
_mesa_use_shader_program(ctx, GL_VERTEX_SHADER, shProg, pipe);
if ((stages & GL_FRAGMENT_SHADER_BIT) != 0)
_mesa_use_shader_program(ctx, GL_FRAGMENT_SHADER, shProg, pipe);
if ((stages & GL_GEOMETRY_SHADER_BIT) != 0)
_mesa_use_shader_program(ctx, GL_GEOMETRY_SHADER, shProg, pipe);
}
void GLAPIENTRY
_mesa_GetInternalformativ(GLenum target, GLenum internalformat, GLenum pname,
GLsizei bufSize, GLint *params)
{
GLint buffer[16];
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
/* ARB_internalformat_query is also mandatory for ARB_internalformat_query2 */
if (!(_mesa_has_ARB_internalformat_query(ctx) ||
_mesa_is_gles3(ctx))) {
_mesa_error(ctx, GL_INVALID_OPERATION, "glGetInternalformativ");
return;
}
assert(ctx->Driver.QueryInternalFormat != NULL);
if (!_legal_parameters(ctx, target, internalformat, pname, bufSize, params))
return;
/* initialize the contents of the temporary buffer */
memcpy(buffer, params, MIN2(bufSize, 16) * sizeof(GLint));
/* Use the 'unsupported' response defined by the spec for every pname
* as the default answer.
*/
_set_default_response(pname, buffer);
if (!_is_target_supported(ctx, target) ||
!_is_internalformat_supported(ctx, target, internalformat) ||
!_is_resource_supported(ctx, target, internalformat, pname))
goto end;
switch (pname) {
case GL_SAMPLES:
/* fall-through */
case GL_NUM_SAMPLE_COUNTS:
/* The ARB_internalformat_query2 sets the response as 'unsupported' for
* SAMPLES and NUM_SAMPLE_COUNTS:
*
* "If <internalformat> is not color-renderable, depth-renderable, or
* stencil-renderable (as defined in section 4.4.4), or if <target>
* does not support multiple samples (ie other than
* TEXTURE_2D_MULTISAMPLE, TEXTURE_2D_MULTISAMPLE_ARRAY,
* or RENDERBUFFER)."
*/
if ((target != GL_RENDERBUFFER &&
target != GL_TEXTURE_2D_MULTISAMPLE &&
target != GL_TEXTURE_2D_MULTISAMPLE_ARRAY) ||
!_is_renderable(ctx, internalformat))
goto end;
/* The GL ES 3.0 specification, section 6.1.15 page 236 says:
*
* "Since multisampling is not supported for signed and unsigned
* integer internal formats, the value of NUM_SAMPLE_COUNTS will be
* zero for such formats.
*
* Since OpenGL ES 3.1 adds support for multisampled integer formats, we
* have to check the version for 30 exactly.
*/
if (pname == GL_NUM_SAMPLE_COUNTS && ctx->API == API_OPENGLES2 &&
ctx->Version == 30 && _mesa_is_enum_format_integer(internalformat)) {
goto end;
}
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_INTERNALFORMAT_SUPPORTED:
/* Having a supported <internalformat> is implemented as a prerequisite
* for all the <pnames>. Thus, if we reach this point, the internalformat is
* supported.
*/
buffer[0] = GL_TRUE;
break;
case GL_INTERNALFORMAT_PREFERRED:
/* The ARB_internalformat_query2 spec says:
*
* "- INTERNALFORMAT_PREFERRED: The implementation-preferred internal
* format for representing resources of the specified <internalformat> is
* returned in <params>.
*
* Therefore, we let the driver answer. Note that if we reach this
* point, it means that the internalformat is supported, so the driver
* is called just to try to get a preferred format. If not supported,
* GL_NONE was already returned and the driver is not called.
*/
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_INTERNALFORMAT_RED_SIZE:
case GL_INTERNALFORMAT_GREEN_SIZE:
case GL_INTERNALFORMAT_BLUE_SIZE:
case GL_INTERNALFORMAT_ALPHA_SIZE:
case GL_INTERNALFORMAT_DEPTH_SIZE:
case GL_INTERNALFORMAT_STENCIL_SIZE:
case GL_INTERNALFORMAT_SHARED_SIZE:
case GL_INTERNALFORMAT_RED_TYPE:
case GL_INTERNALFORMAT_GREEN_TYPE:
case GL_INTERNALFORMAT_BLUE_TYPE:
case GL_INTERNALFORMAT_ALPHA_TYPE:
case GL_INTERNALFORMAT_DEPTH_TYPE:
case GL_INTERNALFORMAT_STENCIL_TYPE: {
GLint baseformat;
mesa_format texformat;
if (target != GL_RENDERBUFFER) {
if (!_mesa_legal_get_tex_level_parameter_target(ctx, target, true))
goto end;
baseformat = _mesa_base_tex_format(ctx, internalformat);
} else {
baseformat = _mesa_base_fbo_format(ctx, internalformat);
}
/* Let the driver choose the texture format.
*
* Disclaimer: I am considering that drivers use for renderbuffers the
* same format-choice logic as for textures.
*/
texformat = ctx->Driver.ChooseTextureFormat(ctx, target, internalformat,
GL_NONE /*format */, GL_NONE /* type */);
if (texformat == MESA_FORMAT_NONE || baseformat <= 0)
goto end;
/* Implementation based on what Mesa does for glGetTexLevelParameteriv
* and glGetRenderbufferParameteriv functions.
*/
if (pname == GL_INTERNALFORMAT_SHARED_SIZE) {
if (_mesa_has_EXT_texture_shared_exponent(ctx) &&
target != GL_TEXTURE_BUFFER &&
target != GL_RENDERBUFFER &&
texformat == MESA_FORMAT_R9G9B9E5_FLOAT) {
buffer[0] = 5;
}
goto end;
}
if (!_mesa_base_format_has_channel(baseformat, pname))
goto end;
switch (pname) {
case GL_INTERNALFORMAT_DEPTH_SIZE:
if (ctx->API != API_OPENGL_CORE &&
!_mesa_has_ARB_depth_texture(ctx) &&
target != GL_RENDERBUFFER &&
target != GL_TEXTURE_BUFFER)
goto end;
/* fallthrough */
case GL_INTERNALFORMAT_RED_SIZE:
case GL_INTERNALFORMAT_GREEN_SIZE:
case GL_INTERNALFORMAT_BLUE_SIZE:
case GL_INTERNALFORMAT_ALPHA_SIZE:
case GL_INTERNALFORMAT_STENCIL_SIZE:
buffer[0] = _mesa_get_format_bits(texformat, pname);
break;
case GL_INTERNALFORMAT_DEPTH_TYPE:
if (!_mesa_has_ARB_texture_float(ctx))
goto end;
/* fallthrough */
case GL_INTERNALFORMAT_RED_TYPE:
case GL_INTERNALFORMAT_GREEN_TYPE:
case GL_INTERNALFORMAT_BLUE_TYPE:
case GL_INTERNALFORMAT_ALPHA_TYPE:
case GL_INTERNALFORMAT_STENCIL_TYPE:
buffer[0] = _mesa_get_format_datatype(texformat);
break;
default:
break;
}
break;
}
/* For WIDTH/HEIGHT/DEPTH/LAYERS there is no reason to think that the
* returned values should be different to the values returned by
* GetInteger with MAX_TEXTURE_SIZE, MAX_3D_TEXTURE_SIZE, etc.*/
case GL_MAX_WIDTH:
case GL_MAX_HEIGHT:
case GL_MAX_DEPTH: {
GLenum get_pname;
GLint dimensions;
GLint min_dimensions;
/* From query2:MAX_HEIGHT spec (as example):
*
* "If the resource does not have at least two dimensions, or if the
* resource is unsupported, zero is returned."
*/
dimensions = _get_target_dimensions(target);
min_dimensions = _get_min_dimensions(pname);
if (dimensions < min_dimensions)
goto end;
get_pname = _equivalent_size_pname(target, pname);
if (get_pname == 0)
goto end;
_mesa_GetIntegerv(get_pname, buffer);
break;
}
case GL_MAX_LAYERS:
if (!_mesa_has_EXT_texture_array(ctx))
goto end;
if (!_mesa_is_array_texture(target))
goto end;
_mesa_GetIntegerv(GL_MAX_ARRAY_TEXTURE_LAYERS, buffer);
break;
case GL_MAX_COMBINED_DIMENSIONS:{
GLint64 combined_value = 1;
GLenum max_dimensions_pnames[] = {
GL_MAX_WIDTH,
GL_MAX_HEIGHT,
GL_MAX_DEPTH,
GL_SAMPLES
};
unsigned i;
GLint current_value;
/* Combining the dimensions. Note that for array targets, this would
* automatically include the value of MAX_LAYERS, as that value is
* returned as MAX_HEIGHT or MAX_DEPTH */
for (i = 0; i < 4; i++) {
if (max_dimensions_pnames[i] == GL_SAMPLES &&
!_is_multisample_target(target))
continue;
_mesa_GetInternalformativ(target, internalformat,
max_dimensions_pnames[i],
1, ¤t_value);
if (current_value != 0)
combined_value *= current_value;
}
if (_mesa_is_cube_map_texture(target))
combined_value *= 6;
/* We pack the 64-bit value on two 32-bit values. Calling the 32-bit
* query, this would work as far as the value can be hold on a 32-bit
* signed integer. For the 64-bit query, the wrapper around the 32-bit
* query will unpack the value */
memcpy(buffer, &combined_value, sizeof(GLint64));
break;
}
case GL_COLOR_COMPONENTS:
/* The ARB_internalformat_query2 spec says:
*
* "- COLOR_COMPONENTS: If the internal format contains any color
* components (R, G, B, or A), TRUE is returned in <params>.
* If the internal format is unsupported or contains no color
* components, FALSE is returned."
*/
if (_mesa_is_color_format(internalformat))
buffer[0] = GL_TRUE;
break;
case GL_DEPTH_COMPONENTS:
/* The ARB_internalformat_query2 spec says:
*
* "- DEPTH_COMPONENTS: If the internal format contains a depth
* component (D), TRUE is returned in <params>. If the internal format
* is unsupported or contains no depth component, FALSE is returned."
*/
if (_mesa_is_depth_format(internalformat) ||
_mesa_is_depthstencil_format(internalformat))
buffer[0] = GL_TRUE;
break;
case GL_STENCIL_COMPONENTS:
/* The ARB_internalformat_query2 spec says:
*
* "- STENCIL_COMPONENTS: If the internal format contains a stencil
* component (S), TRUE is returned in <params>. If the internal format
* is unsupported or contains no stencil component, FALSE is returned.
*/
if (_mesa_is_stencil_format(internalformat) ||
_mesa_is_depthstencil_format(internalformat))
buffer[0] = GL_TRUE;
break;
case GL_COLOR_RENDERABLE:
case GL_DEPTH_RENDERABLE:
case GL_STENCIL_RENDERABLE:
if (!_is_renderable(ctx, internalformat))
goto end;
if (pname == GL_COLOR_RENDERABLE) {
if (!_mesa_is_color_format(internalformat))
goto end;
} else {
GLenum baseFormat = _mesa_base_fbo_format(ctx, internalformat);
if (baseFormat != GL_DEPTH_STENCIL &&
((pname == GL_DEPTH_RENDERABLE && baseFormat != GL_DEPTH_COMPONENT) ||
(pname == GL_STENCIL_RENDERABLE && baseFormat != GL_STENCIL_INDEX)))
goto end;
}
buffer[0] = GL_TRUE;
break;
case GL_FRAMEBUFFER_RENDERABLE_LAYERED:
if (!_mesa_has_EXT_texture_array(ctx) ||
_legal_target_for_framebuffer_texture_layer(ctx, target))
goto end;
/* fallthrough */
case GL_FRAMEBUFFER_RENDERABLE:
case GL_FRAMEBUFFER_BLEND:
if (!_mesa_has_ARB_framebuffer_object(ctx))
goto end;
if (target == GL_TEXTURE_BUFFER ||
!_is_renderable(ctx, internalformat))
goto end;
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_READ_PIXELS:
case GL_READ_PIXELS_FORMAT:
case GL_READ_PIXELS_TYPE:
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_TEXTURE_IMAGE_FORMAT:
case GL_GET_TEXTURE_IMAGE_FORMAT:
case GL_TEXTURE_IMAGE_TYPE:
case GL_GET_TEXTURE_IMAGE_TYPE:
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_MIPMAP:
case GL_MANUAL_GENERATE_MIPMAP:
case GL_AUTO_GENERATE_MIPMAP:
if (!_mesa_is_valid_generate_texture_mipmap_target(ctx, target) ||
!_mesa_is_valid_generate_texture_mipmap_internalformat(ctx,
internalformat)) {
goto end;
}
if (pname == GL_MIPMAP) {
buffer[0] = GL_TRUE;
goto end;
}
else if (pname == GL_MANUAL_GENERATE_MIPMAP) {
if (!_mesa_has_ARB_framebuffer_object(ctx))
goto end;
}
else {
/* From ARB_internalformat_query2:
* "Dependencies on OpenGL 3.2 (Core Profile)
* In core profiles for OpenGL 3.2 and later versions, queries
* for the AUTO_GENERATE_MIPMAP <pname> return the appropriate
* unsupported response."
*/
if (_mesa_is_desktop_gl(ctx) && ctx->Version >= 32)
goto end;
}
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_COLOR_ENCODING:
if (!_mesa_is_color_format(internalformat))
goto end;
if (_mesa_is_srgb_format(internalformat))
buffer[0] = GL_SRGB;
else
buffer[0] = GL_LINEAR;
break;
case GL_SRGB_READ:
if (!_mesa_has_EXT_texture_sRGB(ctx) ||
!_mesa_is_srgb_format(internalformat)) {
goto end;
}
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_SRGB_WRITE:
if (!_mesa_has_EXT_framebuffer_sRGB(ctx) ||
!_mesa_is_color_format(internalformat)) {
goto end;
}
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_SRGB_DECODE_ARB:
/* Presence of EXT_texture_sRGB_decode was already verified */
if (!_mesa_has_EXT_texture_sRGB(ctx) ||
target == GL_RENDERBUFFER ||
!_mesa_is_srgb_format(internalformat)) {
goto end;
}
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_FILTER:
/* If it doesn't allow to set sampler parameters then it would not allow
* to set a filter different to GL_NEAREST. In practice, this method
* only filters out MULTISAMPLE/MULTISAMPLE_ARRAY */
if (!_mesa_target_allows_setting_sampler_parameters(target))
goto end;
if (_mesa_is_enum_format_integer(internalformat))
goto end;
if (target == GL_TEXTURE_BUFFER)
goto end;
/* At this point we know that multi-texel filtering is supported. We
* need to call the driver to know if it is CAVEAT_SUPPORT or
* FULL_SUPPORT.
*/
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_VERTEX_TEXTURE:
case GL_TESS_CONTROL_TEXTURE:
case GL_TESS_EVALUATION_TEXTURE:
case GL_GEOMETRY_TEXTURE:
case GL_FRAGMENT_TEXTURE:
case GL_COMPUTE_TEXTURE:
if (target == GL_RENDERBUFFER)
goto end;
if ((pname == GL_TESS_CONTROL_TEXTURE ||
pname == GL_TESS_EVALUATION_TEXTURE) &&
!_mesa_has_tessellation(ctx))
goto end;
if (pname == GL_GEOMETRY_TEXTURE && !_mesa_has_geometry_shaders(ctx))
goto end;
if (pname == GL_COMPUTE_TEXTURE && !_mesa_has_compute_shaders(ctx))
goto end;
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_TEXTURE_GATHER:
case GL_TEXTURE_GATHER_SHADOW:
if (!_mesa_has_ARB_texture_gather(ctx))
goto end;
/* fallthrough */
case GL_TEXTURE_SHADOW:
/* Only depth or depth-stencil image formats make sense in shadow
samplers */
if (pname != GL_TEXTURE_GATHER &&
!_mesa_is_depth_format(internalformat) &&
!_mesa_is_depthstencil_format(internalformat))
goto end;
/* Validate the target for shadow and gather operations */
switch (target) {
case GL_TEXTURE_2D:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_ARRAY:
case GL_TEXTURE_RECTANGLE:
break;
case GL_TEXTURE_1D:
case GL_TEXTURE_1D_ARRAY:
/* 1D and 1DArray textures are not admitted in gather operations */
if (pname != GL_TEXTURE_SHADOW)
goto end;
break;
default:
goto end;
}
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_SHADER_IMAGE_LOAD:
case GL_SHADER_IMAGE_STORE:
if (!_mesa_has_ARB_shader_image_load_store(ctx))
goto end;
/* We call to _mesa_is_shader_image_format_supported
* using "internalformat" as parameter, because the
* the ARB_internalformat_query2 spec says:
* "In this case the <internalformat> is the value of the <format>
* parameter that is passed to BindImageTexture."
*/
if (target == GL_RENDERBUFFER ||
!_mesa_is_shader_image_format_supported(ctx, internalformat))
goto end;
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_SHADER_IMAGE_ATOMIC:
if (!_mesa_has_ARB_shader_image_load_store(ctx))
goto end;
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_IMAGE_TEXEL_SIZE: {
mesa_format image_format;
if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
target == GL_RENDERBUFFER)
goto end;
image_format = _mesa_get_shader_image_format(internalformat);
if (image_format == MESA_FORMAT_NONE)
goto end;
/* We return bits */
buffer[0] = (_mesa_get_format_bytes(image_format) * 8);
break;
}
case GL_IMAGE_COMPATIBILITY_CLASS:
if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
target == GL_RENDERBUFFER)
goto end;
buffer[0] = _mesa_get_image_format_class(internalformat);
break;
case GL_IMAGE_PIXEL_FORMAT: {
GLint base_format;
if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
target == GL_RENDERBUFFER ||
!_mesa_is_shader_image_format_supported(ctx, internalformat))
goto end;
base_format = _mesa_base_tex_format(ctx, internalformat);
if (base_format == -1)
goto end;
if (_mesa_is_enum_format_integer(internalformat))
buffer[0] = _mesa_base_format_to_integer_format(base_format);
else
buffer[0] = base_format;
break;
}
case GL_IMAGE_PIXEL_TYPE: {
mesa_format image_format;
GLenum datatype;
GLuint comps;
if (!_mesa_has_ARB_shader_image_load_store(ctx) ||
target == GL_RENDERBUFFER)
goto end;
image_format = _mesa_get_shader_image_format(internalformat);
if (image_format == MESA_FORMAT_NONE)
goto end;
_mesa_uncompressed_format_to_type_and_comps(image_format, &datatype,
&comps);
if (!datatype)
goto end;
buffer[0] = datatype;
break;
}
case GL_IMAGE_FORMAT_COMPATIBILITY_TYPE: {
if (!_mesa_has_ARB_shader_image_load_store(ctx))
goto end;
if (!_mesa_legal_get_tex_level_parameter_target(ctx, target, true))
goto end;
/* From spec: "Equivalent to calling GetTexParameter with <value> set
* to IMAGE_FORMAT_COMPATIBILITY_TYPE."
*
* GetTexParameter just returns
* tex_obj->ImageFormatCompatibilityType. We create a fake tex_obj
* just with the purpose of getting the value.
*/
struct gl_texture_object *tex_obj = _mesa_new_texture_object(ctx, 0, target);
buffer[0] = tex_obj->ImageFormatCompatibilityType;
_mesa_delete_texture_object(ctx, tex_obj);
break;
}
case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST:
case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST:
case GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE:
case GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE:
if (target == GL_RENDERBUFFER)
goto end;
if (!_mesa_is_depthstencil_format(internalformat)) {
if (((pname == GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST ||
pname == GL_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE) &&
!_mesa_is_depth_format(internalformat)) ||
((pname == GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST ||
pname == GL_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE) &&
!_mesa_is_stencil_format(internalformat)))
goto end;
}
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_TEXTURE_COMPRESSED:
buffer[0] = _mesa_is_compressed_format(ctx, internalformat);
break;
case GL_TEXTURE_COMPRESSED_BLOCK_WIDTH:
case GL_TEXTURE_COMPRESSED_BLOCK_HEIGHT:
case GL_TEXTURE_COMPRESSED_BLOCK_SIZE: {
mesa_format mesaformat;
GLint block_size;
mesaformat = _mesa_glenum_to_compressed_format(internalformat);
if (mesaformat == MESA_FORMAT_NONE)
goto end;
block_size = _mesa_get_format_bytes(mesaformat);
assert(block_size > 0);
if (pname == GL_TEXTURE_COMPRESSED_BLOCK_SIZE) {
buffer[0] = block_size;
} else {
GLuint bwidth, bheight;
/* Returns the width and height in pixels. We return bytes */
_mesa_get_format_block_size(mesaformat, &bwidth, &bheight);
assert(bwidth > 0 && bheight > 0);
if (pname == GL_TEXTURE_COMPRESSED_BLOCK_WIDTH)
buffer[0] = block_size / bheight;
else
buffer[0] = block_size / bwidth;
}
break;
}
case GL_CLEAR_BUFFER:
if (target != GL_TEXTURE_BUFFER)
goto end;
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
break;
case GL_TEXTURE_VIEW:
case GL_VIEW_COMPATIBILITY_CLASS:
if (!_mesa_has_ARB_texture_view(ctx) ||
target == GL_TEXTURE_BUFFER ||
target == GL_RENDERBUFFER)
goto end;
if (pname == GL_TEXTURE_VIEW) {
ctx->Driver.QueryInternalFormat(ctx, target, internalformat, pname,
buffer);
} else {
GLenum view_class = _mesa_texture_view_lookup_view_class(ctx,
internalformat);
if (view_class == GL_FALSE)
goto end;
buffer[0] = view_class;
}
break;
default:
unreachable("bad param");
}
end:
if (bufSize != 0 && params == NULL) {
/* Emit a warning to aid application debugging, but go ahead and do the
* memcpy (and probably crash) anyway.
*/
_mesa_warning(ctx,
"glGetInternalformativ(bufSize = %d, but params = NULL)",
bufSize);
}
/* Copy the data from the temporary buffer to the buffer supplied by the
* application. Clamp the size of the copy to the size supplied by the
* application.
*/
memcpy(params, buffer, MIN2(bufSize, 16) * sizeof(GLint));
return;
}
