#include "get.h"
#include "macros.h"
#include "mtypes.h"
+#include "spirv_extensions.h"
#include "state.h"
#include "texcompress.h"
#include "texstate.h"
* 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 );
+}
-#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 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) );
+}
-#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 GLboolean
+INT_TO_BOOLEAN(GLint I)
+{
+ return ( (I) ? GL_TRUE : GL_FALSE );
+}
-#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 GLfixed
+INT_TO_FIXED(GLint I)
+{
+ return (((I) > SHRT_MAX) ? INT_MAX :
+ ((I) < SHRT_MIN) ? INT_MIN :
+ (GLint) ((I) * 65536) );
+}
-#define ENUM_TO_INT64(E) ( (GLint64) (E) )
-#define ENUM_TO_FIXED(E) (E)
+
+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))) );
+}
+
+static inline GLint
+BOOLEAN_TO_INT(GLboolean B)
+{
+ return ( (GLint) (B) );
+}
+
+static inline GLfloat
+BOOLEAN_TO_FLOAT(GLboolean B)
+{
+ return ( (B) ? 1.0F : 0.0F );
+}
+
+static inline GLfixed
+BOOLEAN_TO_FIXED(GLboolean B)
+{
+ return ( (GLint) ((B) ? 1 : 0) << 16 );
+}
enum value_type {
TYPE_INVALID,
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,
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 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_GLSL_130_es3[] = {
+static const int extra_GLSL_130_es3_gpushader4[] = {
EXTRA_GLSL_130,
EXTRA_API_ES3,
+ EXT(EXT_gpu_shader4),
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(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);
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
};
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_bool = ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG][0] == 1.0F;
break;
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;
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;
/* 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 */
v->value_int = 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_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_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;
}
}
if (version >= 32)
api_found = GL_TRUE;
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_NEW_FRAG_CLAMP:
if (ctx->NewState & (_NEW_BUFFERS | _NEW_FRAG_CLAMP))
_mesa_update_state(ctx);
api_found = GL_TRUE;
break;
case EXTRA_EXT_PROVOKING_VERTEX_32:
- api_check = TRUE;
+ api_check = GL_TRUE;
if (ctx->API == API_OPENGL_COMPAT || version == 32)
api_found = ctx->Extensions.EXT_provoking_vertex;
break;
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 = ((char *) ctx->Array.VAO + d->offset);
return d;
case LOC_TEXUNIT:
- unit = &ctx->Texture.Unit[ctx->Texture.CurrentUnit];
- *p = ((char *) unit + d->offset);
+ if (ctx->Texture.CurrentUnit < ARRAY_SIZE(ctx->Texture.FixedFuncUnit)) {
+ unsigned index = ctx->Texture.CurrentUnit;
+ *p = ((char *)&ctx->Texture.FixedFuncUnit[index] + d->offset);
+ }
return d;
case LOC_CUSTOM:
find_custom_value(ctx, d, v);
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:
params[0] = ((GLboolean*) p)[0];
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[0] = BOOLEAN_TO_FLOAT(*(GLboolean*) p);
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[0] = BOOLEAN_TO_INT(*(GLboolean*) p);
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++)
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:
params[0] = *(GLboolean*) p;
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++)
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 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;
_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;
}
invalid_enum:
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[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++)
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:
break;
case TYPE_ENUM16:
- params[0] = INT_TO_FIXED(((GLenum16 *) p)[0]);
+ params[0] = INT_TO_FIXED((GLint)(((GLenum16 *) p)[0]));
break;
case TYPE_INT_N:
params[0] = BOOLEAN_TO_FIXED(((GLboolean*) p)[0]);
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++)