#include "get.h"
#include "macros.h"
#include "mtypes.h"
+#include "spirv_extensions.h"
#include "state.h"
#include "texcompress.h"
#include "texstate.h"
#include "framebuffer.h"
#include "samplerobj.h"
#include "stencil.h"
+#include "version.h"
/* This is a table driven implemetation of the glGet*v() functions.
* The basic idea is that most getters just look up an int somewhere
* is about as concise as the specification in the old python script.
*/
-#define FLOAT_TO_BOOLEAN(X) ( (X) ? GL_TRUE : GL_FALSE )
-#define FLOAT_TO_FIXED(F) ( ((F) * 65536.0f > INT_MAX) ? INT_MAX : \
- ((F) * 65536.0f < INT_MIN) ? INT_MIN : \
- (GLint) ((F) * 65536.0f) )
+static inline GLboolean
+FLOAT_TO_BOOLEAN(GLfloat X)
+{
+ return ( (X) ? GL_TRUE : GL_FALSE );
+}
+
+static inline GLint
+FLOAT_TO_FIXED(GLfloat F)
+{
+ return ( ((F) * 65536.0f > INT_MAX) ? INT_MAX :
+ ((F) * 65536.0f < INT_MIN) ? INT_MIN :
+ (GLint) ((F) * 65536.0f) );
+}
+
+static inline GLboolean
+INT_TO_BOOLEAN(GLint I)
+{
+ return ( (I) ? GL_TRUE : GL_FALSE );
+}
+
+static inline GLfixed
+INT_TO_FIXED(GLint I)
+{
+ return (((I) > SHRT_MAX) ? INT_MAX :
+ ((I) < SHRT_MIN) ? INT_MIN :
+ (GLint) ((I) * 65536) );
+}
+
-#define INT_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE )
-#define INT_TO_FIXED(I) ( ((I) > SHRT_MAX) ? INT_MAX : \
- ((I) < SHRT_MIN) ? INT_MIN : \
- (GLint) ((I) * 65536) )
+static inline GLboolean
+INT64_TO_BOOLEAN(GLint64 I)
+{
+ return ( (I) ? GL_TRUE : GL_FALSE );
+}
+
+static inline GLint
+INT64_TO_INT(GLint64 I)
+{
+ return ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) );
+}
-#define INT64_TO_BOOLEAN(I) ( (I) ? GL_TRUE : GL_FALSE )
-#define INT64_TO_INT(I) ( (GLint)((I > INT_MAX) ? INT_MAX : ((I < INT_MIN) ? INT_MIN : (I))) )
+static inline GLint
+BOOLEAN_TO_INT(GLboolean B)
+{
+ return ( (GLint) (B) );
+}
-#define BOOLEAN_TO_INT(B) ( (GLint) (B) )
-#define BOOLEAN_TO_INT64(B) ( (GLint64) (B) )
-#define BOOLEAN_TO_FLOAT(B) ( (B) ? 1.0F : 0.0F )
-#define BOOLEAN_TO_FIXED(B) ( (GLint) ((B) ? 1 : 0) << 16 )
+static inline GLfloat
+BOOLEAN_TO_FLOAT(GLboolean B)
+{
+ return ( (B) ? 1.0F : 0.0F );
+}
-#define ENUM_TO_INT64(E) ( (GLint64) (E) )
-#define ENUM_TO_FIXED(E) (E)
+static inline GLfixed
+BOOLEAN_TO_FIXED(GLboolean B)
+{
+ return ( (GLint) ((B) ? 1 : 0) << 16 );
+}
enum value_type {
TYPE_INVALID,
TYPE_UINT_3,
TYPE_UINT_4,
TYPE_INT64,
+ TYPE_ENUM16,
TYPE_ENUM,
TYPE_ENUM_2,
TYPE_BOOLEAN,
+ TYPE_UBYTE,
+ TYPE_SHORT,
TYPE_BIT_0,
TYPE_BIT_1,
TYPE_BIT_2,
EXTRA_VERSION_31,
EXTRA_VERSION_32,
EXTRA_VERSION_40,
+ EXTRA_VERSION_43,
EXTRA_API_GL,
EXTRA_API_GL_CORE,
EXTRA_API_ES2,
EXTRA_API_ES3,
EXTRA_API_ES31,
EXTRA_API_ES32,
- EXTRA_NEW_BUFFERS,
- EXTRA_NEW_FRAG_CLAMP,
+ EXTRA_NEW_BUFFERS,
EXTRA_VALID_DRAW_BUFFER,
EXTRA_VALID_TEXTURE_UNIT,
EXTRA_VALID_CLIP_DISTANCE,
EXTRA_EXT_SSBO_GS,
EXTRA_EXT_FB_NO_ATTACH_GS,
EXTRA_EXT_ES_GS,
+ EXTRA_EXT_PROVOKING_VERTEX_32,
};
#define NO_EXTRA NULL
GLint value_int_4[4];
GLint64 value_int64;
GLenum value_enum;
+ GLubyte value_ubyte;
+ GLshort value_short;
+ GLuint value_uint;
/* Sigh, see GL_COMPRESSED_TEXTURE_FORMATS_ARB handling */
struct {
#define BUFFER_INT(field) BUFFER_FIELD(field, TYPE_INT)
#define BUFFER_ENUM(field) BUFFER_FIELD(field, TYPE_ENUM)
+#define BUFFER_ENUM16(field) BUFFER_FIELD(field, TYPE_ENUM16)
#define BUFFER_BOOL(field) BUFFER_FIELD(field, TYPE_BOOLEAN)
#define CONTEXT_INT(field) CONTEXT_FIELD(field, TYPE_INT)
#define CONTEXT_INT2(field) CONTEXT_FIELD(field, TYPE_INT_2)
#define CONTEXT_INT64(field) CONTEXT_FIELD(field, TYPE_INT64)
#define CONTEXT_UINT(field) CONTEXT_FIELD(field, TYPE_UINT)
+#define CONTEXT_ENUM16(field) CONTEXT_FIELD(field, TYPE_ENUM16)
#define CONTEXT_ENUM(field) CONTEXT_FIELD(field, TYPE_ENUM)
#define CONTEXT_ENUM2(field) CONTEXT_FIELD(field, TYPE_ENUM_2)
#define CONTEXT_BOOL(field) CONTEXT_FIELD(field, TYPE_BOOLEAN)
#define CONTEXT_MATRIX(field) CONTEXT_FIELD(field, TYPE_MATRIX)
#define CONTEXT_MATRIX_T(field) CONTEXT_FIELD(field, TYPE_MATRIX_T)
+/* Vertex array fields */
#define ARRAY_INT(field) ARRAY_FIELD(field, TYPE_INT)
#define ARRAY_ENUM(field) ARRAY_FIELD(field, TYPE_ENUM)
+#define ARRAY_ENUM16(field) ARRAY_FIELD(field, TYPE_ENUM16)
#define ARRAY_BOOL(field) ARRAY_FIELD(field, TYPE_BOOLEAN)
+#define ARRAY_UBYTE(field) ARRAY_FIELD(field, TYPE_UBYTE)
+#define ARRAY_SHORT(field) ARRAY_FIELD(field, TYPE_SHORT)
#define EXT(f) \
offsetof(struct gl_extensions, f)
EXTRA_END
};
-static const int extra_new_frag_clamp[] = {
- EXTRA_NEW_FRAG_CLAMP,
- EXTRA_END
-};
-
static const int extra_valid_draw_buffer[] = {
EXTRA_VALID_DRAW_BUFFER,
EXTRA_END
EXTRA_END
};
-static const int extra_GLSL_130_es3[] = {
+static const int extra_GLSL_130_es3_gpushader4[] = {
EXTRA_GLSL_130,
EXTRA_API_ES3,
+ EXT(EXT_gpu_shader4),
EXTRA_END
};
static const int extra_texture_buffer_object[] = {
- EXTRA_API_GL_CORE,
- EXTRA_VERSION_31,
EXT(ARB_texture_buffer_object),
EXTRA_END
};
EXTRA_EXT(EXT_stencil_two_side);
EXTRA_EXT(EXT_depth_bounds_test);
EXTRA_EXT(ARB_depth_clamp);
+EXTRA_EXT(AMD_depth_clamp_separate);
EXTRA_EXT(ATI_fragment_shader);
EXTRA_EXT(EXT_provoking_vertex);
EXTRA_EXT(ARB_fragment_shader);
EXTRA_EXT(INTEL_performance_query);
EXTRA_EXT(ARB_explicit_uniform_location);
EXTRA_EXT(ARB_clip_control);
-EXTRA_EXT(EXT_polygon_offset_clamp);
+EXTRA_EXT(ARB_polygon_offset_clamp);
EXTRA_EXT(ARB_framebuffer_no_attachments);
EXTRA_EXT(ARB_tessellation_shader);
-EXTRA_EXT(ARB_shader_subroutine);
EXTRA_EXT(ARB_shader_storage_buffer_object);
EXTRA_EXT(ARB_indirect_parameters);
EXTRA_EXT(ATI_meminfo);
EXTRA_EXT(ARB_compute_variable_group_size);
EXTRA_EXT(KHR_robustness);
EXTRA_EXT(ARB_sparse_buffer);
+EXTRA_EXT(NV_conservative_raster);
+EXTRA_EXT(NV_conservative_raster_dilate);
+EXTRA_EXT(NV_conservative_raster_pre_snap_triangles);
+EXTRA_EXT(ARB_sample_locations);
+EXTRA_EXT(AMD_framebuffer_multisample_advanced);
+EXTRA_EXT(ARB_spirv_extensions);
+EXTRA_EXT(NV_viewport_swizzle);
static const int
extra_ARB_color_buffer_float_or_glcore[] = {
static const int extra_version_30[] = { EXTRA_VERSION_30, EXTRA_END };
static const int extra_version_31[] = { EXTRA_VERSION_31, EXTRA_END };
static const int extra_version_32[] = { EXTRA_VERSION_32, EXTRA_END };
+static const int extra_version_43[] = { EXTRA_VERSION_43, EXTRA_END };
static const int extra_gl30_es3[] = {
EXTRA_VERSION_30,
static const int extra_EXT_shader_framebuffer_fetch[] = {
EXTRA_API_ES2,
EXTRA_API_ES3,
- EXT(MESA_shader_framebuffer_fetch),
+ EXT(EXT_shader_framebuffer_fetch),
+ EXTRA_END
+};
+
+static const int extra_EXT_provoking_vertex_32[] = {
+ EXTRA_EXT_PROVOKING_VERTEX_32,
+ EXTRA_END
+};
+
+static const int extra_EXT_disjoint_timer_query[] = {
+ EXTRA_API_ES2,
+ EXTRA_API_ES3,
+ EXT(EXT_disjoint_timer_query),
EXTRA_END
};
+
/* This is the big table describing all the enums we accept in
* glGet*v(). The table is partitioned into six parts: enums
* understood by all GL APIs (OpenGL, GLES and GLES2), enums shared
static void
find_custom_value(struct gl_context *ctx, const struct value_desc *d, union value *v)
{
- struct gl_buffer_object **buffer_obj;
+ struct gl_buffer_object **buffer_obj, *buf;
struct gl_array_attributes *array;
GLuint unit, *p;
break;
case GL_COLOR_WRITEMASK:
- v->value_int_4[0] = ctx->Color.ColorMask[0][RCOMP] ? 1 : 0;
- v->value_int_4[1] = ctx->Color.ColorMask[0][GCOMP] ? 1 : 0;
- v->value_int_4[2] = ctx->Color.ColorMask[0][BCOMP] ? 1 : 0;
- v->value_int_4[3] = ctx->Color.ColorMask[0][ACOMP] ? 1 : 0;
+ v->value_int_4[0] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 0);
+ v->value_int_4[1] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 1);
+ v->value_int_4[2] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 2);
+ v->value_int_4[3] = GET_COLORMASK_BIT(ctx->Color.ColorMask, 0, 3);
+ break;
+
+ case GL_DEPTH_CLAMP:
+ v->value_bool = ctx->Transform.DepthClampNear || ctx->Transform.DepthClampFar;
break;
case GL_EDGE_FLAG:
v->value_matrix = ctx->TextureMatrixStack[unit].Top;
break;
+ case GL_VERTEX_ARRAY:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_POS);
+ break;
+ case GL_NORMAL_ARRAY:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_NORMAL);
+ break;
+ case GL_COLOR_ARRAY:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR0);
+ break;
case GL_TEXTURE_COORD_ARRAY:
- case GL_TEXTURE_COORD_ARRAY_SIZE:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_TEX(ctx->Array.ActiveTexture));
+ break;
+ case GL_INDEX_ARRAY:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR_INDEX);
+ break;
+ case GL_EDGE_FLAG_ARRAY:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_EDGEFLAG);
+ break;
+ case GL_SECONDARY_COLOR_ARRAY:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_COLOR1);
+ break;
+ case GL_FOG_COORDINATE_ARRAY:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_FOG);
+ break;
+ case GL_POINT_SIZE_ARRAY_OES:
+ v->value_bool = !!(ctx->Array.VAO->Enabled & VERT_BIT_POINT_SIZE);
+ break;
+
case GL_TEXTURE_COORD_ARRAY_TYPE:
case GL_TEXTURE_COORD_ARRAY_STRIDE:
array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)];
v->value_int = *(GLuint *) ((char *) array + d->offset);
break;
+ case GL_TEXTURE_COORD_ARRAY_SIZE:
+ array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)];
+ v->value_int = array->Format.Size;
+ break;
+
+ case GL_VERTEX_ARRAY_SIZE:
+ array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_POS];
+ v->value_int = array->Format.Size;
+ break;
+
case GL_ACTIVE_TEXTURE_ARB:
v->value_int = GL_TEXTURE0_ARB + ctx->Texture.CurrentUnit;
break;
case GL_LIST_INDEX:
v->value_int =
- ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
+ ctx->ListState.CurrentList ? ctx->ListState.CurrentList->Name : 0;
break;
case GL_LIST_MODE:
if (!ctx->CompileFlag)
- v->value_enum = 0;
+ v->value_enum = 0;
else if (ctx->ExecuteFlag)
- v->value_enum = GL_COMPILE_AND_EXECUTE;
+ v->value_enum = GL_COMPILE_AND_EXECUTE;
else
- v->value_enum = GL_COMPILE;
+ v->value_enum = GL_COMPILE;
break;
case GL_VIEWPORT:
v->value_int = _mesa_get_compressed_formats(ctx, NULL);
break;
case GL_COMPRESSED_TEXTURE_FORMATS_ARB:
- v->value_int_n.n =
- _mesa_get_compressed_formats(ctx, v->value_int_n.ints);
+ v->value_int_n.n =
+ _mesa_get_compressed_formats(ctx, v->value_int_n.ints);
assert(v->value_int_n.n <= (int) ARRAY_SIZE(v->value_int_n.ints));
break;
case GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY:
unit = ctx->Texture.CurrentUnit;
v->value_int =
- ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
+ ctx->Texture.Unit[unit].CurrentTex[d->offset]->Name;
+ break;
+
+ /* GL_EXT_external_objects */
+ case GL_NUM_DEVICE_UUIDS_EXT:
+ v->value_int = 1;
+ break;
+ case GL_DRIVER_UUID_EXT:
+ _mesa_get_driver_uuid(ctx, v->value_int_4);
+ break;
+ case GL_DEVICE_UUID_EXT:
+ _mesa_get_device_uuid(ctx, v->value_int_4);
break;
/* GL_EXT_packed_float */
case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB:
case GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB:
buffer_obj = (struct gl_buffer_object **)
- ((char *) ctx->Array.VAO + d->offset);
- v->value_int = (*buffer_obj)->Name;
+ ((char *) ctx->Array.VAO + d->offset);
+ v->value_int = (*buffer_obj) ? (*buffer_obj)->Name : 0;
break;
case GL_ARRAY_BUFFER_BINDING_ARB:
- v->value_int = ctx->Array.ArrayBufferObj->Name;
+ buf = ctx->Array.ArrayBufferObj;
+ v->value_int = buf ? buf->Name : 0;
break;
case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB:
- v->value_int =
- ctx->Array.VAO->BufferBinding[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj->Name;
+ buf = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj;
+ v->value_int = buf ? buf->Name : 0;
break;
case GL_ELEMENT_ARRAY_BUFFER_BINDING_ARB:
- v->value_int = ctx->Array.VAO->IndexBufferObj->Name;
+ buf = ctx->Array.VAO->IndexBufferObj;
+ v->value_int = buf ? buf->Name : 0;
break;
/* ARB_vertex_array_bgra */
case GL_COLOR_ARRAY_SIZE:
array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR0];
- v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size;
+ v->value_int = array->Format.Format == GL_BGRA ? GL_BGRA : array->Format.Size;
break;
case GL_SECONDARY_COLOR_ARRAY_SIZE:
array = &ctx->Array.VAO->VertexAttrib[VERT_ATTRIB_COLOR1];
- v->value_int = array->Format == GL_BGRA ? GL_BGRA : array->Size;
+ v->value_int = array->Format.Format == GL_BGRA ? GL_BGRA : array->Format.Size;
break;
/* ARB_copy_buffer */
case GL_COPY_READ_BUFFER:
- v->value_int = ctx->CopyReadBuffer->Name;
+ v->value_int = ctx->CopyReadBuffer ? ctx->CopyReadBuffer->Name : 0;
break;
case GL_COPY_WRITE_BUFFER:
- v->value_int = ctx->CopyWriteBuffer->Name;
+ v->value_int = ctx->CopyWriteBuffer ? ctx->CopyWriteBuffer->Name : 0;
break;
case GL_PIXEL_PACK_BUFFER_BINDING_EXT:
- v->value_int = ctx->Pack.BufferObj->Name;
+ v->value_int = ctx->Pack.BufferObj ? ctx->Pack.BufferObj->Name : 0;
break;
case GL_PIXEL_UNPACK_BUFFER_BINDING_EXT:
- v->value_int = ctx->Unpack.BufferObj->Name;
+ v->value_int = ctx->Unpack.BufferObj ? ctx->Unpack.BufferObj->Name : 0;
break;
case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
- v->value_int = ctx->TransformFeedback.CurrentBuffer->Name;
+ v->value_int = ctx->TransformFeedback.CurrentBuffer ?
+ ctx->TransformFeedback.CurrentBuffer->Name : 0;
break;
case GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED:
v->value_int = ctx->TransformFeedback.CurrentObject->Paused;
* the last program set by UseProgram (bug 7822).
*/
v->value_int =
- ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
+ ctx->Shader.ActiveProgram ? ctx->Shader.ActiveProgram->Name : 0;
break;
case GL_READ_FRAMEBUFFER_BINDING_EXT:
v->value_int = ctx->ReadBuffer->Name;
break;
case GL_RENDERBUFFER_BINDING_EXT:
v->value_int =
- ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
+ ctx->CurrentRenderbuffer ? ctx->CurrentRenderbuffer->Name : 0;
break;
case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:
- v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_POINT_SIZE].BufferObj->Name;
+ buf = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_POINT_SIZE].BufferObj;
+ v->value_int = buf ? buf->Name : 0;
break;
case GL_FOG_COLOR:
/* GL_ARB_texture_buffer_object */
case GL_TEXTURE_BUFFER_ARB:
- v->value_int = ctx->Texture.BufferObject->Name;
+ v->value_int = ctx->Texture.BufferObject ? ctx->Texture.BufferObject->Name : 0;
break;
case GL_TEXTURE_BINDING_BUFFER_ARB:
unit = ctx->Texture.CurrentUnit;
break;
/* GL_ARB_uniform_buffer_object */
case GL_UNIFORM_BUFFER_BINDING:
- v->value_int = ctx->UniformBuffer->Name;
+ v->value_int = ctx->UniformBuffer ? ctx->UniformBuffer->Name : 0;
break;
/* GL_ARB_shader_storage_buffer_object */
case GL_SHADER_STORAGE_BUFFER_BINDING:
- v->value_int = ctx->ShaderStorageBuffer->Name;
+ v->value_int = ctx->ShaderStorageBuffer ? ctx->ShaderStorageBuffer->Name : 0;
break;
/* GL_ARB_query_buffer_object */
case GL_QUERY_BUFFER_BINDING:
- v->value_int = ctx->QueryBuffer->Name;
+ v->value_int = ctx->QueryBuffer ? ctx->QueryBuffer->Name : 0;
break;
/* GL_ARB_timer_query */
case GL_TIMESTAMP:
break;
/* GL_ARB_shader_atomic_counters */
case GL_ATOMIC_COUNTER_BUFFER_BINDING:
- if (ctx->AtomicBuffer) {
- v->value_int = ctx->AtomicBuffer->Name;
- } else {
- v->value_int = 0;
- }
+ v->value_int = ctx->AtomicBuffer ? ctx->AtomicBuffer->Name : 0;
+ break;
+ /* GL 4.3 */
+ case GL_NUM_SHADING_LANGUAGE_VERSIONS:
+ v->value_int = _mesa_get_shading_language_version(ctx, -1, NULL);
break;
/* GL_ARB_draw_indirect */
case GL_DRAW_INDIRECT_BUFFER_BINDING:
- v->value_int = ctx->DrawIndirectBuffer->Name;
+ v->value_int = ctx->DrawIndirectBuffer ? ctx->DrawIndirectBuffer->Name: 0;
break;
/* GL_ARB_indirect_parameters */
case GL_PARAMETER_BUFFER_BINDING_ARB:
- v->value_int = ctx->ParameterBuffer->Name;
+ v->value_int = ctx->ParameterBuffer ? ctx->ParameterBuffer->Name : 0;
break;
/* GL_ARB_separate_shader_objects */
case GL_PROGRAM_PIPELINE_BINDING:
break;
/* GL_ARB_compute_shader */
case GL_DISPATCH_INDIRECT_BUFFER_BINDING:
- v->value_int = ctx->DispatchIndirectBuffer->Name;
+ v->value_int = ctx->DispatchIndirectBuffer ?
+ ctx->DispatchIndirectBuffer->Name : 0;
break;
/* GL_ARB_multisample */
case GL_SAMPLES:
}
}
break;
+
+ /* GL_ARB_get_program_binary */
+ case GL_PROGRAM_BINARY_FORMATS:
+ assert(ctx->Const.NumProgramBinaryFormats <= 1);
+ v->value_int_n.n = MIN2(ctx->Const.NumProgramBinaryFormats, 1);
+ if (ctx->Const.NumProgramBinaryFormats > 0) {
+ v->value_int_n.ints[0] = GL_PROGRAM_BINARY_FORMAT_MESA;
+ }
+ break;
+ /* ARB_spirv_extensions */
+ case GL_NUM_SPIR_V_EXTENSIONS:
+ v->value_int = _mesa_get_spirv_extension_count(ctx);
+ break;
+ /* GL_EXT_disjoint_timer_query */
+ case GL_GPU_DISJOINT_EXT:
+ {
+ simple_mtx_lock(&ctx->Shared->Mutex);
+ v->value_int = ctx->Shared->DisjointOperation;
+ /* Reset state as expected by the spec. */
+ ctx->Shared->DisjointOperation = false;
+ simple_mtx_unlock(&ctx->Shared->Mutex);
+ }
+ break;
+ /* GL_ARB_sample_locations */
+ case GL_SAMPLE_LOCATION_SUBPIXEL_BITS_ARB:
+ case GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB:
+ case GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB:
+ {
+ GLuint bits, width, height;
+
+ if (ctx->NewState & _NEW_BUFFERS)
+ _mesa_update_state(ctx);
+
+ if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE) {
+ v->value_uint = 0;
+ break;
+ }
+
+ ctx->Driver.GetProgrammableSampleCaps(ctx, ctx->DrawBuffer,
+ &bits, &width, &height);
+
+ if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_WIDTH_ARB)
+ v->value_uint = width;
+ else if (d->pname == GL_SAMPLE_LOCATION_PIXEL_GRID_HEIGHT_ARB)
+ v->value_uint = height;
+ else
+ v->value_uint = bits;
+ }
+ break;
+ case GL_PROGRAMMABLE_SAMPLE_LOCATION_TABLE_SIZE_ARB:
+ v->value_uint = MAX_SAMPLE_LOCATION_TABLE_SIZE;
+ break;
+
+ /* GL_AMD_framebuffer_multisample_advanced */
+ case GL_SUPPORTED_MULTISAMPLE_MODES_AMD:
+ v->value_int_n.n = ctx->Const.NumSupportedMultisampleModes * 3;
+ memcpy(v->value_int_n.ints, ctx->Const.SupportedMultisampleModes,
+ v->value_int_n.n * sizeof(GLint));
+ break;
+
+ /* GL_NV_viewport_swizzle */
+ case GL_VIEWPORT_SWIZZLE_X_NV:
+ v->value_enum = ctx->ViewportArray[0].SwizzleX;
+ break;
+ case GL_VIEWPORT_SWIZZLE_Y_NV:
+ v->value_enum = ctx->ViewportArray[0].SwizzleY;
+ break;
+ case GL_VIEWPORT_SWIZZLE_Z_NV:
+ v->value_enum = ctx->ViewportArray[0].SwizzleZ;
+ break;
+ case GL_VIEWPORT_SWIZZLE_W_NV:
+ v->value_enum = ctx->ViewportArray[0].SwizzleW;
+ break;
}
}
api_check = GL_TRUE;
if (version >= 30)
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_VERSION_31:
api_check = GL_TRUE;
if (version >= 31)
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_VERSION_32:
api_check = GL_TRUE;
if (version >= 32)
api_found = GL_TRUE;
- break;
- case EXTRA_NEW_FRAG_CLAMP:
- if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
- _mesa_update_state(ctx);
+ break;
+ case EXTRA_VERSION_40:
+ api_check = GL_TRUE;
+ if (version >= 40)
+ api_found = GL_TRUE;
+ break;
+ case EXTRA_VERSION_43:
+ api_check = GL_TRUE;
+ if (_mesa_is_desktop_gl(ctx) && version >= 43)
+ api_found = GL_TRUE;
break;
case EXTRA_API_ES2:
api_check = GL_TRUE;
if (ctx->API == API_OPENGLES2)
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_API_ES3:
api_check = GL_TRUE;
if (_mesa_is_gles3(ctx))
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_API_ES31:
api_check = GL_TRUE;
if (_mesa_is_gles31(ctx))
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_API_ES32:
api_check = GL_TRUE;
if (_mesa_is_gles32(ctx))
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_API_GL:
api_check = GL_TRUE;
if (_mesa_is_desktop_gl(ctx))
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_API_GL_CORE:
api_check = GL_TRUE;
if (ctx->API == API_OPENGL_CORE)
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_NEW_BUFFERS:
- if (ctx->NewState & _NEW_BUFFERS)
- _mesa_update_state(ctx);
- break;
+ if (ctx->NewState & _NEW_BUFFERS)
+ _mesa_update_state(ctx);
+ break;
case EXTRA_FLUSH_CURRENT:
- FLUSH_CURRENT(ctx, 0);
- break;
+ FLUSH_CURRENT(ctx, 0);
+ break;
case EXTRA_VALID_DRAW_BUFFER:
- if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
- func, d->pname - GL_DRAW_BUFFER0_ARB);
- return GL_FALSE;
- }
- break;
+ if (d->pname - GL_DRAW_BUFFER0_ARB >= ctx->Const.MaxDrawBuffers) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "%s(draw buffer %u)",
+ func, d->pname - GL_DRAW_BUFFER0_ARB);
+ return GL_FALSE;
+ }
+ break;
case EXTRA_VALID_TEXTURE_UNIT:
- if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
- func, ctx->Texture.CurrentUnit);
- return GL_FALSE;
- }
- break;
+ if (ctx->Texture.CurrentUnit >= ctx->Const.MaxTextureCoordUnits) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "%s(texture %u)",
+ func, ctx->Texture.CurrentUnit);
+ return GL_FALSE;
+ }
+ break;
case EXTRA_VALID_CLIP_DISTANCE:
- if (d->pname - GL_CLIP_DISTANCE0 >= ctx->Const.MaxClipPlanes) {
- _mesa_error(ctx, GL_INVALID_ENUM, "%s(clip distance %u)",
- func, d->pname - GL_CLIP_DISTANCE0);
- return GL_FALSE;
- }
- break;
+ if (d->pname - GL_CLIP_DISTANCE0 >= ctx->Const.MaxClipPlanes) {
+ _mesa_error(ctx, GL_INVALID_ENUM, "%s(clip distance %u)",
+ func, d->pname - GL_CLIP_DISTANCE0);
+ return GL_FALSE;
+ }
+ break;
case EXTRA_GLSL_130:
api_check = GL_TRUE;
if (ctx->Const.GLSLVersion >= 130)
api_found = GL_TRUE;
- break;
+ break;
case EXTRA_EXT_UBO_GS:
api_check = GL_TRUE;
if (ctx->Extensions.ARB_uniform_buffer_object &&
if (_mesa_has_OES_geometry_shader(ctx))
api_found = GL_TRUE;
break;
+ case EXTRA_EXT_PROVOKING_VERTEX_32:
+ api_check = GL_TRUE;
+ if (ctx->API == API_OPENGL_COMPAT || version == 32)
+ api_found = ctx->Extensions.EXT_provoking_vertex;
+ break;
case EXTRA_END:
- break;
+ break;
default: /* *e is a offset into the extension struct */
- api_check = GL_TRUE;
- if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
- api_found = GL_TRUE;
- break;
+ api_check = GL_TRUE;
+ if (*(GLboolean *) ((char *) &ctx->Extensions + *e))
+ api_found = GL_TRUE;
+ break;
}
}
/**
* Find the struct value_desc corresponding to the enum 'pname'.
- *
+ *
* We hash the enum value to get an index into the 'table' array,
* which holds the index in the 'values' array of struct value_desc.
* Once we've found the entry, we do the extra checks, if any, then
* If the value has to be computed (for example, it's the result of a
* function call or we need to add 1 to it), we use the tmp 'v' to
* store the result.
- *
+ *
* \param func name of glGet*v() func for error reporting
* \param pname the enum value we're looking up
* \param p is were we return the pointer to the value
find_value(const char *func, GLenum pname, void **p, union value *v)
{
GET_CURRENT_CONTEXT(ctx);
- struct gl_texture_unit *unit;
int mask, hash;
const struct value_desc *d;
int api;
+ *p = NULL;
+
api = ctx->API;
/* We index into the table_set[] list of per-API hash tables using the API's
* value in the gl_api enum. Since GLES 3 doesn't have an API_OPENGL* enum
*p = ((char *) ctx->Array.VAO + d->offset);
return d;
case LOC_TEXUNIT:
- unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
- *p = ((char *) unit + d->offset);
- return d;
+ if (ctx->Texture.CurrentUnit < ARRAY_SIZE(ctx->Texture.FixedFuncUnit)) {
+ unsigned index = ctx->Texture.CurrentUnit;
+ *p = ((char *)&ctx->Texture.FixedFuncUnit[index] + d->offset);
+ return d;
+ }
+ _mesa_error(ctx, GL_INVALID_VALUE, "%s(pname=%s,unit=%d)", func,
+ _mesa_enum_to_string(pname),
+ ctx->Texture.CurrentUnit);
+ return &error_value;
case LOC_CUSTOM:
find_custom_value(ctx, d, v);
*p = v;
3, 7, 11, 15
};
+static GLsizei
+get_value_size(enum value_type type, const union value *v)
+{
+ switch (type) {
+ case TYPE_INVALID:
+ return 0;
+ case TYPE_CONST:
+ case TYPE_UINT:
+ case TYPE_INT:
+ return sizeof(GLint);
+ case TYPE_INT_2:
+ case TYPE_UINT_2:
+ return sizeof(GLint) * 2;
+ case TYPE_INT_3:
+ case TYPE_UINT_3:
+ return sizeof(GLint) * 3;
+ case TYPE_INT_4:
+ case TYPE_UINT_4:
+ return sizeof(GLint) * 4;
+ case TYPE_INT_N:
+ return sizeof(GLint) * v->value_int_n.n;
+ case TYPE_INT64:
+ return sizeof(GLint64);
+ break;
+ case TYPE_ENUM16:
+ return sizeof(GLenum16);
+ case TYPE_ENUM:
+ return sizeof(GLenum);
+ case TYPE_ENUM_2:
+ return sizeof(GLenum) * 2;
+ case TYPE_BOOLEAN:
+ return sizeof(GLboolean);
+ case TYPE_UBYTE:
+ return sizeof(GLubyte);
+ case TYPE_SHORT:
+ return sizeof(GLshort);
+ case TYPE_BIT_0:
+ case TYPE_BIT_1:
+ case TYPE_BIT_2:
+ case TYPE_BIT_3:
+ case TYPE_BIT_4:
+ case TYPE_BIT_5:
+ case TYPE_BIT_6:
+ case TYPE_BIT_7:
+ return 1;
+ case TYPE_FLOAT:
+ case TYPE_FLOATN:
+ return sizeof(GLfloat);
+ case TYPE_FLOAT_2:
+ case TYPE_FLOATN_2:
+ return sizeof(GLfloat) * 2;
+ case TYPE_FLOAT_3:
+ case TYPE_FLOATN_3:
+ return sizeof(GLfloat) * 3;
+ case TYPE_FLOAT_4:
+ case TYPE_FLOATN_4:
+ return sizeof(GLfloat) * 4;
+ case TYPE_FLOAT_8:
+ return sizeof(GLfloat) * 8;
+ case TYPE_DOUBLEN:
+ return sizeof(GLdouble);
+ case TYPE_DOUBLEN_2:
+ return sizeof(GLdouble) * 2;
+ case TYPE_MATRIX:
+ return sizeof (GLfloat) * 16;
+ case TYPE_MATRIX_T:
+ return sizeof (GLfloat) * 16;
+ default:
+ return -1;
+ }
+}
+
void GLAPIENTRY
_mesa_GetBooleanv(GLenum pname, GLboolean *params)
{
params[0] = INT_TO_BOOLEAN(((GLint *) p)[0]);
break;
+ case TYPE_ENUM16:
+ params[0] = INT_TO_BOOLEAN(((GLenum16 *) p)[0]);
+ break;
+
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
+ params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
break;
case TYPE_INT64:
case TYPE_BOOLEAN:
params[0] = ((GLboolean*) p)[0];
- break;
+ break;
+
+ case TYPE_UBYTE:
+ params[0] = INT_TO_BOOLEAN(((GLubyte *) p)[0]);
+ break;
+
+ case TYPE_SHORT:
+ params[0] = INT_TO_BOOLEAN(((GLshort *) p)[0]);
+ break;
case TYPE_MATRIX:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
+ params[i] = FLOAT_TO_BOOLEAN(m->m[i]);
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
+ params[i] = FLOAT_TO_BOOLEAN(m->m[transpose[i]]);
break;
case TYPE_BIT_0:
params[0] = (GLfloat) (((GLint *) p)[0]);
break;
+ case TYPE_ENUM16:
+ params[0] = (GLfloat) (((GLenum16 *) p)[0]);
+ break;
+
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = (GLfloat) v.value_int_n.ints[i];
+ params[i] = (GLfloat) v.value_int_n.ints[i];
break;
case TYPE_UINT_4:
case TYPE_BOOLEAN:
params[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
- break;
+ break;
+
+ case TYPE_UBYTE:
+ params[0] = (GLfloat) ((GLubyte *) p)[0];
+ break;
+
+ case TYPE_SHORT:
+ params[0] = (GLfloat) ((GLshort *) p)[0];
+ break;
case TYPE_MATRIX:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = m->m[i];
+ params[i] = m->m[i];
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = m->m[transpose[i]];
+ params[i] = m->m[transpose[i]];
break;
case TYPE_BIT_0:
break;
case TYPE_FLOAT_8:
- params[7] = IROUND(((GLfloat *) p)[7]);
- params[6] = IROUND(((GLfloat *) p)[6]);
- params[5] = IROUND(((GLfloat *) p)[5]);
- params[4] = IROUND(((GLfloat *) p)[4]);
+ params[7] = lroundf(((GLfloat *) p)[7]);
+ params[6] = lroundf(((GLfloat *) p)[6]);
+ params[5] = lroundf(((GLfloat *) p)[5]);
+ params[4] = lroundf(((GLfloat *) p)[4]);
case TYPE_FLOAT_4:
- params[3] = IROUND(((GLfloat *) p)[3]);
+ params[3] = lroundf(((GLfloat *) p)[3]);
case TYPE_FLOAT_3:
- params[2] = IROUND(((GLfloat *) p)[2]);
+ params[2] = lroundf(((GLfloat *) p)[2]);
case TYPE_FLOAT_2:
- params[1] = IROUND(((GLfloat *) p)[1]);
+ params[1] = lroundf(((GLfloat *) p)[1]);
case TYPE_FLOAT:
- params[0] = IROUND(((GLfloat *) p)[0]);
+ params[0] = lroundf(((GLfloat *) p)[0]);
break;
case TYPE_FLOATN_4:
params[0] = ((GLint *) p)[0];
break;
+ case TYPE_ENUM16:
+ params[0] = ((GLenum16 *) p)[0];
+ break;
+
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = v.value_int_n.ints[i];
+ params[i] = v.value_int_n.ints[i];
break;
case TYPE_INT64:
case TYPE_BOOLEAN:
params[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
- break;
+ break;
+
+ case TYPE_UBYTE:
+ params[0] = ((GLubyte *) p)[0];
+ break;
+
+ case TYPE_SHORT:
+ params[0] = ((GLshort *) p)[0];
+ break;
case TYPE_MATRIX:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_INT(m->m[i]);
+ params[i] = FLOAT_TO_INT(m->m[i]);
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
+ params[i] = FLOAT_TO_INT(m->m[transpose[i]]);
break;
case TYPE_BIT_0:
break;
case TYPE_FLOAT_8:
- params[7] = IROUND64(((GLfloat *) p)[7]);
- params[6] = IROUND64(((GLfloat *) p)[6]);
- params[5] = IROUND64(((GLfloat *) p)[5]);
- params[4] = IROUND64(((GLfloat *) p)[4]);
+ params[7] = llround(((GLfloat *) p)[7]);
+ params[6] = llround(((GLfloat *) p)[6]);
+ params[5] = llround(((GLfloat *) p)[5]);
+ params[4] = llround(((GLfloat *) p)[4]);
case TYPE_FLOAT_4:
- params[3] = IROUND64(((GLfloat *) p)[3]);
+ params[3] = llround(((GLfloat *) p)[3]);
case TYPE_FLOAT_3:
- params[2] = IROUND64(((GLfloat *) p)[2]);
+ params[2] = llround(((GLfloat *) p)[2]);
case TYPE_FLOAT_2:
- params[1] = IROUND64(((GLfloat *) p)[1]);
+ params[1] = llround(((GLfloat *) p)[1]);
case TYPE_FLOAT:
- params[0] = IROUND64(((GLfloat *) p)[0]);
+ params[0] = llround(((GLfloat *) p)[0]);
break;
case TYPE_FLOATN_4:
params[0] = ((GLint *) p)[0];
break;
+ case TYPE_ENUM16:
+ params[0] = ((GLenum16 *) p)[0];
+ break;
+
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = INT_TO_BOOLEAN(v.value_int_n.ints[i]);
+ params[i] = v.value_int_n.ints[i];
break;
case TYPE_UINT_4:
case TYPE_BOOLEAN:
params[0] = ((GLboolean*) p)[0];
- break;
+ break;
case TYPE_MATRIX:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_INT64(m->m[i]);
+ params[i] = FLOAT_TO_INT64(m->m[i]);
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
+ params[i] = FLOAT_TO_INT64(m->m[transpose[i]]);
break;
case TYPE_BIT_0:
params[0] = ((GLint *) p)[0];
break;
+ case TYPE_ENUM16:
+ params[0] = ((GLenum16 *) p)[0];
+ break;
+
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = v.value_int_n.ints[i];
+ params[i] = v.value_int_n.ints[i];
break;
case TYPE_UINT_4:
case TYPE_BOOLEAN:
params[0] = *(GLboolean*) p;
- break;
+ break;
+
+ case TYPE_UBYTE:
+ params[0] = ((GLubyte *) p)[0];
+ break;
+
+ case TYPE_SHORT:
+ params[0] = ((GLshort *) p)[0];
+ break;
case TYPE_MATRIX:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = m->m[i];
+ params[i] = m->m[i];
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = m->m[transpose[i]];
+ params[i] = m->m[transpose[i]];
break;
case TYPE_BIT_0:
}
}
+void GLAPIENTRY
+_mesa_GetUnsignedBytevEXT(GLenum pname, GLubyte *data)
+{
+ const struct value_desc *d;
+ union value v;
+ int shift;
+ void *p = NULL;
+ GLsizei size;
+ const char *func = "glGetUnsignedBytevEXT";
+
+ GET_CURRENT_CONTEXT(ctx);
+
+ if (!ctx->Extensions.EXT_memory_object) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
+ return;
+ }
+
+ d = find_value(func, pname, &p, &v);
+ size = get_value_size(d->type, &v);
+ if (size <= 0) {
+ _mesa_problem(ctx, "invalid value type in GetUnsignedBytevEXT()");
+ }
+
+ switch (d->type) {
+ case TYPE_BIT_0:
+ case TYPE_BIT_1:
+ case TYPE_BIT_2:
+ case TYPE_BIT_3:
+ case TYPE_BIT_4:
+ case TYPE_BIT_5:
+ case TYPE_BIT_6:
+ case TYPE_BIT_7:
+ shift = d->type - TYPE_BIT_0;
+ data[0] = (*(GLbitfield *) p >> shift) & 1;
+ break;
+ case TYPE_CONST:
+ memcpy(data, &d->offset, size);
+ break;
+ case TYPE_INT_N:
+ memcpy(data, &v.value_int_n.ints, size);
+ break;
+ case TYPE_UINT:
+ case TYPE_INT:
+ case TYPE_INT_2:
+ case TYPE_UINT_2:
+ case TYPE_INT_3:
+ case TYPE_UINT_3:
+ case TYPE_INT_4:
+ case TYPE_UINT_4:
+ case TYPE_INT64:
+ case TYPE_ENUM:
+ case TYPE_ENUM_2:
+ case TYPE_BOOLEAN:
+ case TYPE_UBYTE:
+ case TYPE_SHORT:
+ case TYPE_FLOAT:
+ case TYPE_FLOATN:
+ case TYPE_FLOAT_2:
+ case TYPE_FLOATN_2:
+ case TYPE_FLOAT_3:
+ case TYPE_FLOATN_3:
+ case TYPE_FLOAT_4:
+ case TYPE_FLOATN_4:
+ case TYPE_FLOAT_8:
+ case TYPE_DOUBLEN:
+ case TYPE_DOUBLEN_2:
+ case TYPE_MATRIX:
+ case TYPE_MATRIX_T:
+ memcpy(data, p, size);
+ break;
+ case TYPE_ENUM16: {
+ GLenum e = *(GLenum16 *)p;
+ memcpy(data, &e, sizeof(e));
+ break;
+ }
+ default:
+ break; /* nothing - GL error was recorded */
+ }
+}
+
/**
* Convert a GL texture binding enum such as GL_TEXTURE_BINDING_2D
* into the corresponding Mesa texture target index.
find_value_indexed(const char *func, GLenum pname, GLuint index, union value *v)
{
GET_CURRENT_CONTEXT(ctx);
+ struct gl_buffer_object *buf;
switch (pname) {
case GL_BLEND:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.EXT_draw_buffers2)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = (ctx->Color.BlendEnabled >> index) & 1;
return TYPE_INT;
/* fall-through */
case GL_BLEND_SRC_RGB:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_draw_buffers_blend)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->Color.Blend[index].SrcRGB;
return TYPE_INT;
case GL_BLEND_SRC_ALPHA:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_draw_buffers_blend)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->Color.Blend[index].SrcA;
return TYPE_INT;
case GL_BLEND_DST:
/* fall-through */
case GL_BLEND_DST_RGB:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_draw_buffers_blend)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->Color.Blend[index].DstRGB;
return TYPE_INT;
case GL_BLEND_DST_ALPHA:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_draw_buffers_blend)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->Color.Blend[index].DstA;
return TYPE_INT;
case GL_BLEND_EQUATION_RGB:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_draw_buffers_blend)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->Color.Blend[index].EquationRGB;
return TYPE_INT;
case GL_BLEND_EQUATION_ALPHA:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_draw_buffers_blend)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->Color.Blend[index].EquationA;
return TYPE_INT;
case GL_COLOR_WRITEMASK:
if (index >= ctx->Const.MaxDrawBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.EXT_draw_buffers2)
- goto invalid_enum;
- v->value_int_4[0] = ctx->Color.ColorMask[index][RCOMP] ? 1 : 0;
- v->value_int_4[1] = ctx->Color.ColorMask[index][GCOMP] ? 1 : 0;
- v->value_int_4[2] = ctx->Color.ColorMask[index][BCOMP] ? 1 : 0;
- v->value_int_4[3] = ctx->Color.ColorMask[index][ACOMP] ? 1 : 0;
+ goto invalid_enum;
+ v->value_int_4[0] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 0);
+ v->value_int_4[1] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 1);
+ v->value_int_4[2] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 2);
+ v->value_int_4[3] = GET_COLORMASK_BIT(ctx->Color.ColorMask, index, 3);
return TYPE_INT_4;
case GL_SCISSOR_BOX:
case GL_TRANSFORM_FEEDBACK_BUFFER_START:
if (index >= ctx->Const.MaxTransformFeedbackBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.EXT_transform_feedback)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int64 = ctx->TransformFeedback.CurrentObject->Offset[index];
return TYPE_INT64;
case GL_TRANSFORM_FEEDBACK_BUFFER_SIZE:
if (index >= ctx->Const.MaxTransformFeedbackBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.EXT_transform_feedback)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int64
= ctx->TransformFeedback.CurrentObject->RequestedSize[index];
return TYPE_INT64;
case GL_TRANSFORM_FEEDBACK_BUFFER_BINDING:
if (index >= ctx->Const.MaxTransformFeedbackBuffers)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.EXT_transform_feedback)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->TransformFeedback.CurrentObject->BufferNames[index];
return TYPE_INT;
case GL_UNIFORM_BUFFER_BINDING:
if (index >= ctx->Const.MaxUniformBufferBindings)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_uniform_buffer_object)
- goto invalid_enum;
- v->value_int = ctx->UniformBufferBindings[index].BufferObject->Name;
+ goto invalid_enum;
+ buf = ctx->UniformBufferBindings[index].BufferObject;
+ v->value_int = buf ? buf->Name : 0;
return TYPE_INT;
case GL_UNIFORM_BUFFER_START:
if (index >= ctx->Const.MaxUniformBufferBindings)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_uniform_buffer_object)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->UniformBufferBindings[index].Offset < 0 ? 0 :
ctx->UniformBufferBindings[index].Offset;
return TYPE_INT;
case GL_UNIFORM_BUFFER_SIZE:
if (index >= ctx->Const.MaxUniformBufferBindings)
- goto invalid_value;
+ goto invalid_value;
if (!ctx->Extensions.ARB_uniform_buffer_object)
- goto invalid_enum;
+ goto invalid_enum;
v->value_int = ctx->UniformBufferBindings[index].Size < 0 ? 0 :
ctx->UniformBufferBindings[index].Size;
return TYPE_INT;
goto invalid_enum;
if (index >= ctx->Const.MaxShaderStorageBufferBindings)
goto invalid_value;
- v->value_int = ctx->ShaderStorageBufferBindings[index].BufferObject->Name;
+ buf = ctx->ShaderStorageBufferBindings[index].BufferObject;
+ v->value_int = buf ? buf->Name : 0;
return TYPE_INT;
case GL_SHADER_STORAGE_BUFFER_START:
goto invalid_enum;
if (index >= ctx->Const.MaxAtomicBufferBindings)
goto invalid_value;
- v->value_int = ctx->AtomicBufferBindings[index].BufferObject->Name;
+ buf = ctx->AtomicBufferBindings[index].BufferObject;
+ v->value_int = buf ? buf->Name : 0;
return TYPE_INT;
case GL_ATOMIC_COUNTER_BUFFER_START:
goto invalid_enum;
if (index >= ctx->Const.MaxAtomicBufferBindings)
goto invalid_value;
- v->value_int64 = ctx->AtomicBufferBindings[index].Offset;
+ v->value_int64 = ctx->AtomicBufferBindings[index].Offset < 0 ? 0 :
+ ctx->AtomicBufferBindings[index].Offset;
return TYPE_INT64;
case GL_ATOMIC_COUNTER_BUFFER_SIZE:
goto invalid_enum;
if (index >= ctx->Const.MaxAtomicBufferBindings)
goto invalid_value;
- v->value_int64 = ctx->AtomicBufferBindings[index].Size;
+ v->value_int64 = ctx->AtomicBufferBindings[index].Size < 0 ? 0 :
+ ctx->AtomicBufferBindings[index].Size;
return TYPE_INT64;
case GL_VERTEX_BINDING_DIVISOR:
goto invalid_enum;
if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs)
goto invalid_value;
- v->value_int = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj->Name;
+ buf = ctx->Array.VAO->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj;
+ v->value_int = buf ? buf->Name : 0;
return TYPE_INT;
/* ARB_shader_image_load_store */
case GL_TEXTURE_BINDING_RECTANGLE: {
int target;
- if (ctx->API != API_OPENGL_CORE)
- goto invalid_enum;
target = tex_binding_to_index(ctx, pname);
if (target < 0)
goto invalid_enum;
case GL_SAMPLER_BINDING: {
struct gl_sampler_object *samp;
- if (ctx->API != API_OPENGL_CORE)
+ if (!_mesa_is_desktop_gl(ctx) || ctx->Version < 33)
goto invalid_enum;
if (index >= _mesa_max_tex_unit(ctx))
goto invalid_value;
goto invalid_value;
v->value_int = ctx->Const.MaxComputeVariableGroupSize[index];
return TYPE_INT;
+
+ /* GL_EXT_external_objects */
+ case GL_NUM_DEVICE_UUIDS_EXT:
+ v->value_int = 1;
+ return TYPE_INT;
+ case GL_DRIVER_UUID_EXT:
+ if (index >= 1)
+ goto invalid_value;
+ _mesa_get_driver_uuid(ctx, v->value_int_4);
+ return TYPE_INT_4;
+ case GL_DEVICE_UUID_EXT:
+ if (index >= 1)
+ goto invalid_value;
+ _mesa_get_device_uuid(ctx, v->value_int_4);
+ return TYPE_INT_4;
+ /* GL_EXT_direct_state_access */
+ case GL_TEXTURE_1D:
+ case GL_TEXTURE_2D:
+ case GL_TEXTURE_3D:
+ case GL_TEXTURE_CUBE_MAP:
+ case GL_TEXTURE_GEN_S:
+ case GL_TEXTURE_GEN_T:
+ case GL_TEXTURE_GEN_R:
+ case GL_TEXTURE_GEN_Q:
+ case GL_TEXTURE_RECTANGLE_ARB: {
+ GLuint curTexUnitSave;
+ if (index >= _mesa_max_tex_unit(ctx))
+ goto invalid_enum;
+ curTexUnitSave = ctx->Texture.CurrentUnit;
+ _mesa_ActiveTexture_no_error(GL_TEXTURE0 + index);
+ v->value_int = _mesa_IsEnabled(pname);
+ _mesa_ActiveTexture_no_error(GL_TEXTURE0 + curTexUnitSave);
+ return TYPE_INT;
+ }
+ case GL_TEXTURE_COORD_ARRAY: {
+ GLuint curTexUnitSave;
+ if (index >= ctx->Const.MaxTextureCoordUnits)
+ goto invalid_enum;
+ curTexUnitSave = ctx->Array.ActiveTexture;
+ _mesa_ClientActiveTexture(GL_TEXTURE0 + index);
+ v->value_int = _mesa_IsEnabled(pname);
+ _mesa_ClientActiveTexture(GL_TEXTURE0 + curTexUnitSave);
+ return TYPE_INT;
+ }
+ case GL_TEXTURE_MATRIX:
+ if (index >= ARRAY_SIZE(ctx->TextureMatrixStack))
+ goto invalid_enum;
+ v->value_matrix = ctx->TextureMatrixStack[index].Top;
+ return TYPE_MATRIX;
+ case GL_TRANSPOSE_TEXTURE_MATRIX:
+ if (index >= ARRAY_SIZE(ctx->TextureMatrixStack))
+ goto invalid_enum;
+ v->value_matrix = ctx->TextureMatrixStack[index].Top;
+ return TYPE_MATRIX_T;
+ /* GL_NV_viewport_swizzle */
+ case GL_VIEWPORT_SWIZZLE_X_NV:
+ if (!ctx->Extensions.NV_viewport_swizzle)
+ goto invalid_enum;
+ if (index >= ctx->Const.MaxViewports)
+ goto invalid_value;
+ v->value_int = ctx->ViewportArray[index].SwizzleX;
+ return TYPE_INT;
+ case GL_VIEWPORT_SWIZZLE_Y_NV:
+ if (!ctx->Extensions.NV_viewport_swizzle)
+ goto invalid_enum;
+ if (index >= ctx->Const.MaxViewports)
+ goto invalid_value;
+ v->value_int = ctx->ViewportArray[index].SwizzleY;
+ return TYPE_INT;
+ case GL_VIEWPORT_SWIZZLE_Z_NV:
+ if (!ctx->Extensions.NV_viewport_swizzle)
+ goto invalid_enum;
+ if (index >= ctx->Const.MaxViewports)
+ goto invalid_value;
+ v->value_int = ctx->ViewportArray[index].SwizzleZ;
+ return TYPE_INT;
+ case GL_VIEWPORT_SWIZZLE_W_NV:
+ if (!ctx->Extensions.NV_viewport_swizzle)
+ goto invalid_enum;
+ if (index >= ctx->Const.MaxViewports)
+ goto invalid_value;
+ v->value_int = ctx->ViewportArray[index].SwizzleW;
+ return TYPE_INT;
}
invalid_enum:
switch (type) {
case TYPE_FLOAT_4:
case TYPE_FLOATN_4:
- params[3] = IROUND(v.value_float_4[3]);
+ params[3] = lroundf(v.value_float_4[3]);
case TYPE_FLOAT_3:
case TYPE_FLOATN_3:
- params[2] = IROUND(v.value_float_4[2]);
+ params[2] = lroundf(v.value_float_4[2]);
case TYPE_FLOAT_2:
case TYPE_FLOATN_2:
- params[1] = IROUND(v.value_float_4[1]);
+ params[1] = lroundf(v.value_float_4[1]);
case TYPE_FLOAT:
case TYPE_FLOATN:
- params[0] = IROUND(v.value_float_4[0]);
+ params[0] = lroundf(v.value_float_4[0]);
break;
case TYPE_DOUBLEN_2:
- params[1] = IROUND(v.value_double_2[1]);
+ params[1] = lroundf(v.value_double_2[1]);
case TYPE_DOUBLEN:
- params[0] = IROUND(v.value_double_2[0]);
+ params[0] = lroundf(v.value_double_2[0]);
break;
case TYPE_INT:
params[1] = (GLfloat) v.value_int_4[1];
case TYPE_INT:
case TYPE_ENUM:
+ case TYPE_ENUM16:
params[0] = (GLfloat) v.value_int_4[0];
break;
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = (GLfloat) v.value_int_n.ints[i];
+ params[i] = (GLfloat) v.value_int_n.ints[i];
break;
case TYPE_UINT_4:
params[0] = BOOLEAN_TO_FLOAT(v.value_bool);
break;
+ case TYPE_UBYTE:
+ params[0] = (GLfloat) v.value_ubyte;
+ break;
+
+ case TYPE_SHORT:
+ params[0] = (GLfloat) v.value_short;
+ break;
+
case TYPE_MATRIX:
m = *(GLmatrix **) &v;
for (i = 0; i < 16; i++)
- params[i] = m->m[i];
+ params[i] = m->m[i];
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) &v;
for (i = 0; i < 16; i++)
- params[i] = m->m[transpose[i]];
+ params[i] = m->m[transpose[i]];
break;
default:
params[1] = (GLdouble) v.value_int_4[1];
case TYPE_INT:
case TYPE_ENUM:
+ case TYPE_ENUM16:
params[0] = (GLdouble) v.value_int_4[0];
break;
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = (GLdouble) v.value_int_n.ints[i];
+ params[i] = (GLdouble) v.value_int_n.ints[i];
break;
case TYPE_UINT_4:
params[0] = (GLdouble) BOOLEAN_TO_FLOAT(v.value_bool);
break;
+ case TYPE_UBYTE:
+ params[0] = (GLdouble) v.value_ubyte;
+ break;
+
+ case TYPE_SHORT:
+ params[0] = (GLdouble) v.value_short;
+ break;
+
case TYPE_MATRIX:
m = *(GLmatrix **) &v;
for (i = 0; i < 16; i++)
- params[i] = (GLdouble) m->m[i];
+ params[i] = (GLdouble) m->m[i];
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) &v;
for (i = 0; i < 16; i++)
- params[i] = (GLdouble) m->m[transpose[i]];
+ params[i] = (GLdouble) m->m[transpose[i]];
break;
default:
}
}
+void GLAPIENTRY
+_mesa_GetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
+{
+ GLsizei size;
+ union value v;
+ enum value_type type;
+ const char *func = "glGetUnsignedBytei_vEXT";
+
+ GET_CURRENT_CONTEXT(ctx);
+
+ if (!ctx->Extensions.EXT_memory_object) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "%s(unsupported)", func);
+ return;
+ }
+
+ type = find_value_indexed(func, target, index, &v);
+ size = get_value_size(type, &v);
+ if (size <= 0) {
+ _mesa_problem(ctx, "invalid value type in GetUnsignedBytei_vEXT()");
+ }
+
+ switch (type) {
+ case TYPE_UINT:
+ case TYPE_INT:
+ case TYPE_INT_2:
+ case TYPE_UINT_2:
+ case TYPE_INT_3:
+ case TYPE_UINT_3:
+ case TYPE_INT_4:
+ case TYPE_UINT_4:
+ case TYPE_INT64:
+ case TYPE_ENUM16:
+ case TYPE_ENUM:
+ case TYPE_ENUM_2:
+ case TYPE_BOOLEAN:
+ case TYPE_UBYTE:
+ case TYPE_SHORT:
+ case TYPE_FLOAT:
+ case TYPE_FLOATN:
+ case TYPE_FLOAT_2:
+ case TYPE_FLOATN_2:
+ case TYPE_FLOAT_3:
+ case TYPE_FLOATN_3:
+ case TYPE_FLOAT_4:
+ case TYPE_FLOATN_4:
+ case TYPE_FLOAT_8:
+ case TYPE_DOUBLEN:
+ case TYPE_DOUBLEN_2:
+ case TYPE_MATRIX:
+ case TYPE_MATRIX_T:
+ memcpy(data, &v.value_int, size);
+ break;
+ case TYPE_INT_N:
+ memcpy(data, &v.value_int_n.ints, size);
+ break;
+ default:
+ break; /* nothing - GL error was recorded */
+ }
+}
+
void GLAPIENTRY
_mesa_GetFixedv(GLenum pname, GLfixed *params)
{
params[0] = INT_TO_FIXED(((GLint *) p)[0]);
break;
+ case TYPE_ENUM16:
+ params[0] = INT_TO_FIXED((GLint)(((GLenum16 *) p)[0]));
+ break;
+
case TYPE_INT_N:
for (i = 0; i < v.value_int_n.n; i++)
- params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
+ params[i] = INT_TO_FIXED(v.value_int_n.ints[i]);
break;
case TYPE_INT64:
case TYPE_BOOLEAN:
params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
- break;
+ break;
+
+ case TYPE_UBYTE:
+ params[0] = INT_TO_FIXED(((GLubyte *) p)[0]);
+ break;
+
+ case TYPE_SHORT:
+ params[0] = INT_TO_FIXED(((GLshort *) p)[0]);
+ break;
case TYPE_MATRIX:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_FIXED(m->m[i]);
+ params[i] = FLOAT_TO_FIXED(m->m[i]);
break;
case TYPE_MATRIX_T:
m = *(GLmatrix **) p;
for (i = 0; i < 16; i++)
- params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
+ params[i] = FLOAT_TO_FIXED(m->m[transpose[i]]);
break;
case TYPE_BIT_0: