#include <inttypes.h> /* for PRId64 macro */
#include "glheader.h"
-#include "imports.h"
+#include "util/imports.h"
#include "bufferobj.h"
#include "context.h"
#include "enable.h"
#include "enums.h"
+#include "glformats.h"
#include "hash.h"
#include "image.h"
#include "macros.h"
#include "mtypes.h"
#include "varray.h"
#include "arrayobj.h"
+#include "get.h"
#include "main/dispatch.h"
case GL_UNSIGNED_INT:
return UNSIGNED_INT_BIT;
case GL_HALF_FLOAT:
+ case GL_HALF_FLOAT_OES:
if (ctx->Extensions.ARB_half_float_vertex)
return HALF_BIT;
else
/**
- * Sets the VertexBinding field in the vertex attribute given by attribIndex.
+ * Depending on the position and generic0 attributes enable flags select
+ * the one that is used for both attributes.
+ * The generic0 attribute takes precedence.
*/
-static void
-vertex_attrib_binding(struct gl_context *ctx,
- struct gl_vertex_array_object *vao,
- GLuint attribIndex,
- GLuint bindingIndex)
+static inline void
+update_attribute_map_mode(const struct gl_context *ctx,
+ struct gl_vertex_array_object *vao)
{
- struct gl_vertex_attrib_array *array = &vao->VertexAttrib[attribIndex];
-
- if (!_mesa_is_bufferobj(vao->VertexBinding[bindingIndex].BufferObj))
- vao->VertexAttribBufferMask &= ~VERT_BIT(attribIndex);
+ /*
+ * There is no need to change the mapping away from the
+ * identity mapping if we are not in compat mode.
+ */
+ if (ctx->API != API_OPENGL_COMPAT)
+ return;
+ /* The generic0 attribute superseeds the position attribute */
+ const GLbitfield enabled = vao->Enabled;
+ if (enabled & VERT_BIT_GENERIC0)
+ vao->_AttributeMapMode = ATTRIBUTE_MAP_MODE_GENERIC0;
+ else if (enabled & VERT_BIT_POS)
+ vao->_AttributeMapMode = ATTRIBUTE_MAP_MODE_POSITION;
else
- vao->VertexAttribBufferMask |= VERT_BIT(attribIndex);
+ vao->_AttributeMapMode = ATTRIBUTE_MAP_MODE_IDENTITY;
+}
+
+
+/**
+ * Sets the BufferBindingIndex field for the vertex attribute given by
+ * attribIndex.
+ */
+void
+_mesa_vertex_attrib_binding(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ gl_vert_attrib attribIndex,
+ GLuint bindingIndex)
+{
+ struct gl_array_attributes *array = &vao->VertexAttrib[attribIndex];
+ assert(!vao->SharedAndImmutable);
+
+ if (array->BufferBindingIndex != bindingIndex) {
+ const GLbitfield array_bit = VERT_BIT(attribIndex);
- if (array->VertexBinding != bindingIndex) {
- const GLbitfield64 array_bit = VERT_BIT(attribIndex);
+ if (_mesa_is_bufferobj(vao->BufferBinding[bindingIndex].BufferObj))
+ vao->VertexAttribBufferMask |= array_bit;
+ else
+ vao->VertexAttribBufferMask &= ~array_bit;
- FLUSH_VERTICES(ctx, _NEW_ARRAY);
+ if (vao->BufferBinding[bindingIndex].InstanceDivisor)
+ vao->NonZeroDivisorMask |= array_bit;
+ else
+ vao->NonZeroDivisorMask &= ~array_bit;
- vao->VertexBinding[array->VertexBinding]._BoundArrays &= ~array_bit;
- vao->VertexBinding[bindingIndex]._BoundArrays |= array_bit;
+ vao->BufferBinding[array->BufferBindingIndex]._BoundArrays &= ~array_bit;
+ vao->BufferBinding[bindingIndex]._BoundArrays |= array_bit;
- array->VertexBinding = bindingIndex;
+ array->BufferBindingIndex = bindingIndex;
- vao->NewArrays |= array_bit;
+ vao->NewArrays |= vao->Enabled & array_bit;
}
}
struct gl_buffer_object *vbo,
GLintptr offset, GLsizei stride)
{
- struct gl_vertex_buffer_binding *binding = &vao->VertexBinding[index];
+ assert(index < ARRAY_SIZE(vao->BufferBinding));
+ assert(!vao->SharedAndImmutable);
+ struct gl_vertex_buffer_binding *binding = &vao->BufferBinding[index];
+
+ if (ctx->Const.VertexBufferOffsetIsInt32 && (int)offset < 0 &&
+ _mesa_is_bufferobj(vbo)) {
+ /* The offset will be interpreted as a signed int, so make sure
+ * the user supplied offset is not negative (driver limitation).
+ */
+ _mesa_warning(ctx, "Received negative int32 vertex buffer offset. "
+ "(driver limitation)\n");
+
+ /* We can't disable this binding, so use a non-negative offset value
+ * instead.
+ */
+ offset = 0;
+ }
if (binding->BufferObj != vbo ||
binding->Offset != offset ||
binding->Stride != stride) {
- FLUSH_VERTICES(ctx, _NEW_ARRAY);
-
_mesa_reference_buffer_object(ctx, &binding->BufferObj, vbo);
binding->Offset = offset;
binding->Stride = stride;
- if (!_mesa_is_bufferobj(vbo))
+ if (!_mesa_is_bufferobj(vbo)) {
vao->VertexAttribBufferMask &= ~binding->_BoundArrays;
- else
+ } else {
vao->VertexAttribBufferMask |= binding->_BoundArrays;
+ vbo->UsageHistory |= USAGE_ARRAY_BUFFER;
+ }
- vao->NewArrays |= binding->_BoundArrays;
+ vao->NewArrays |= vao->Enabled & binding->_BoundArrays;
}
}
GLuint divisor)
{
struct gl_vertex_buffer_binding *binding =
- &vao->VertexBinding[bindingIndex];
+ &vao->BufferBinding[bindingIndex];
+ assert(!vao->SharedAndImmutable);
if (binding->InstanceDivisor != divisor) {
- FLUSH_VERTICES(ctx, _NEW_ARRAY);
binding->InstanceDivisor = divisor;
- vao->NewArrays |= binding->_BoundArrays;
+
+ if (divisor)
+ vao->NonZeroDivisorMask |= binding->_BoundArrays;
+ else
+ vao->NonZeroDivisorMask &= ~binding->_BoundArrays;
+
+ vao->NewArrays |= vao->Enabled & binding->_BoundArrays;
+ }
+}
+
+/* vertex_formats[gltype - GL_BYTE][integer*2 + normalized][size - 1] */
+static const uint16_t vertex_formats[][4][4] = {
+ { /* GL_BYTE */
+ {
+ PIPE_FORMAT_R8_SSCALED,
+ PIPE_FORMAT_R8G8_SSCALED,
+ PIPE_FORMAT_R8G8B8_SSCALED,
+ PIPE_FORMAT_R8G8B8A8_SSCALED
+ },
+ {
+ PIPE_FORMAT_R8_SNORM,
+ PIPE_FORMAT_R8G8_SNORM,
+ PIPE_FORMAT_R8G8B8_SNORM,
+ PIPE_FORMAT_R8G8B8A8_SNORM
+ },
+ {
+ PIPE_FORMAT_R8_SINT,
+ PIPE_FORMAT_R8G8_SINT,
+ PIPE_FORMAT_R8G8B8_SINT,
+ PIPE_FORMAT_R8G8B8A8_SINT
+ },
+ },
+ { /* GL_UNSIGNED_BYTE */
+ {
+ PIPE_FORMAT_R8_USCALED,
+ PIPE_FORMAT_R8G8_USCALED,
+ PIPE_FORMAT_R8G8B8_USCALED,
+ PIPE_FORMAT_R8G8B8A8_USCALED
+ },
+ {
+ PIPE_FORMAT_R8_UNORM,
+ PIPE_FORMAT_R8G8_UNORM,
+ PIPE_FORMAT_R8G8B8_UNORM,
+ PIPE_FORMAT_R8G8B8A8_UNORM
+ },
+ {
+ PIPE_FORMAT_R8_UINT,
+ PIPE_FORMAT_R8G8_UINT,
+ PIPE_FORMAT_R8G8B8_UINT,
+ PIPE_FORMAT_R8G8B8A8_UINT
+ },
+ },
+ { /* GL_SHORT */
+ {
+ PIPE_FORMAT_R16_SSCALED,
+ PIPE_FORMAT_R16G16_SSCALED,
+ PIPE_FORMAT_R16G16B16_SSCALED,
+ PIPE_FORMAT_R16G16B16A16_SSCALED
+ },
+ {
+ PIPE_FORMAT_R16_SNORM,
+ PIPE_FORMAT_R16G16_SNORM,
+ PIPE_FORMAT_R16G16B16_SNORM,
+ PIPE_FORMAT_R16G16B16A16_SNORM
+ },
+ {
+ PIPE_FORMAT_R16_SINT,
+ PIPE_FORMAT_R16G16_SINT,
+ PIPE_FORMAT_R16G16B16_SINT,
+ PIPE_FORMAT_R16G16B16A16_SINT
+ },
+ },
+ { /* GL_UNSIGNED_SHORT */
+ {
+ PIPE_FORMAT_R16_USCALED,
+ PIPE_FORMAT_R16G16_USCALED,
+ PIPE_FORMAT_R16G16B16_USCALED,
+ PIPE_FORMAT_R16G16B16A16_USCALED
+ },
+ {
+ PIPE_FORMAT_R16_UNORM,
+ PIPE_FORMAT_R16G16_UNORM,
+ PIPE_FORMAT_R16G16B16_UNORM,
+ PIPE_FORMAT_R16G16B16A16_UNORM
+ },
+ {
+ PIPE_FORMAT_R16_UINT,
+ PIPE_FORMAT_R16G16_UINT,
+ PIPE_FORMAT_R16G16B16_UINT,
+ PIPE_FORMAT_R16G16B16A16_UINT
+ },
+ },
+ { /* GL_INT */
+ {
+ PIPE_FORMAT_R32_SSCALED,
+ PIPE_FORMAT_R32G32_SSCALED,
+ PIPE_FORMAT_R32G32B32_SSCALED,
+ PIPE_FORMAT_R32G32B32A32_SSCALED
+ },
+ {
+ PIPE_FORMAT_R32_SNORM,
+ PIPE_FORMAT_R32G32_SNORM,
+ PIPE_FORMAT_R32G32B32_SNORM,
+ PIPE_FORMAT_R32G32B32A32_SNORM
+ },
+ {
+ PIPE_FORMAT_R32_SINT,
+ PIPE_FORMAT_R32G32_SINT,
+ PIPE_FORMAT_R32G32B32_SINT,
+ PIPE_FORMAT_R32G32B32A32_SINT
+ },
+ },
+ { /* GL_UNSIGNED_INT */
+ {
+ PIPE_FORMAT_R32_USCALED,
+ PIPE_FORMAT_R32G32_USCALED,
+ PIPE_FORMAT_R32G32B32_USCALED,
+ PIPE_FORMAT_R32G32B32A32_USCALED
+ },
+ {
+ PIPE_FORMAT_R32_UNORM,
+ PIPE_FORMAT_R32G32_UNORM,
+ PIPE_FORMAT_R32G32B32_UNORM,
+ PIPE_FORMAT_R32G32B32A32_UNORM
+ },
+ {
+ PIPE_FORMAT_R32_UINT,
+ PIPE_FORMAT_R32G32_UINT,
+ PIPE_FORMAT_R32G32B32_UINT,
+ PIPE_FORMAT_R32G32B32A32_UINT
+ },
+ },
+ { /* GL_FLOAT */
+ {
+ PIPE_FORMAT_R32_FLOAT,
+ PIPE_FORMAT_R32G32_FLOAT,
+ PIPE_FORMAT_R32G32B32_FLOAT,
+ PIPE_FORMAT_R32G32B32A32_FLOAT
+ },
+ {
+ PIPE_FORMAT_R32_FLOAT,
+ PIPE_FORMAT_R32G32_FLOAT,
+ PIPE_FORMAT_R32G32B32_FLOAT,
+ PIPE_FORMAT_R32G32B32A32_FLOAT
+ },
+ },
+ {{0}}, /* GL_2_BYTES */
+ {{0}}, /* GL_3_BYTES */
+ {{0}}, /* GL_4_BYTES */
+ { /* GL_DOUBLE */
+ {
+ PIPE_FORMAT_R64_FLOAT,
+ PIPE_FORMAT_R64G64_FLOAT,
+ PIPE_FORMAT_R64G64B64_FLOAT,
+ PIPE_FORMAT_R64G64B64A64_FLOAT
+ },
+ {
+ PIPE_FORMAT_R64_FLOAT,
+ PIPE_FORMAT_R64G64_FLOAT,
+ PIPE_FORMAT_R64G64B64_FLOAT,
+ PIPE_FORMAT_R64G64B64A64_FLOAT
+ },
+ },
+ { /* GL_HALF_FLOAT */
+ {
+ PIPE_FORMAT_R16_FLOAT,
+ PIPE_FORMAT_R16G16_FLOAT,
+ PIPE_FORMAT_R16G16B16_FLOAT,
+ PIPE_FORMAT_R16G16B16A16_FLOAT
+ },
+ {
+ PIPE_FORMAT_R16_FLOAT,
+ PIPE_FORMAT_R16G16_FLOAT,
+ PIPE_FORMAT_R16G16B16_FLOAT,
+ PIPE_FORMAT_R16G16B16A16_FLOAT
+ },
+ },
+ { /* GL_FIXED */
+ {
+ PIPE_FORMAT_R32_FIXED,
+ PIPE_FORMAT_R32G32_FIXED,
+ PIPE_FORMAT_R32G32B32_FIXED,
+ PIPE_FORMAT_R32G32B32A32_FIXED
+ },
+ {
+ PIPE_FORMAT_R32_FIXED,
+ PIPE_FORMAT_R32G32_FIXED,
+ PIPE_FORMAT_R32G32B32_FIXED,
+ PIPE_FORMAT_R32G32B32A32_FIXED
+ },
+ },
+};
+
+/**
+ * Return a PIPE_FORMAT_x for the given GL datatype and size.
+ */
+static enum pipe_format
+vertex_format_to_pipe_format(GLubyte size, GLenum16 type, GLenum16 format,
+ GLboolean normalized, GLboolean integer,
+ GLboolean doubles)
+{
+ assert(size >= 1 && size <= 4);
+ assert(format == GL_RGBA || format == GL_BGRA);
+
+ /* 64-bit attributes are translated by drivers. */
+ if (doubles)
+ return PIPE_FORMAT_NONE;
+
+ switch (type) {
+ case GL_HALF_FLOAT_OES:
+ type = GL_HALF_FLOAT;
+ break;
+
+ case GL_INT_2_10_10_10_REV:
+ assert(size == 4 && !integer);
+
+ if (format == GL_BGRA) {
+ if (normalized)
+ return PIPE_FORMAT_B10G10R10A2_SNORM;
+ else
+ return PIPE_FORMAT_B10G10R10A2_SSCALED;
+ } else {
+ if (normalized)
+ return PIPE_FORMAT_R10G10B10A2_SNORM;
+ else
+ return PIPE_FORMAT_R10G10B10A2_SSCALED;
+ }
+ break;
+
+ case GL_UNSIGNED_INT_2_10_10_10_REV:
+ assert(size == 4 && !integer);
+
+ if (format == GL_BGRA) {
+ if (normalized)
+ return PIPE_FORMAT_B10G10R10A2_UNORM;
+ else
+ return PIPE_FORMAT_B10G10R10A2_USCALED;
+ } else {
+ if (normalized)
+ return PIPE_FORMAT_R10G10B10A2_UNORM;
+ else
+ return PIPE_FORMAT_R10G10B10A2_USCALED;
+ }
+ break;
+
+ case GL_UNSIGNED_INT_10F_11F_11F_REV:
+ assert(size == 3 && !integer && format == GL_RGBA);
+ return PIPE_FORMAT_R11G11B10_FLOAT;
+
+ case GL_UNSIGNED_BYTE:
+ if (format == GL_BGRA) {
+ /* this is an odd-ball case */
+ assert(normalized);
+ return PIPE_FORMAT_B8G8R8A8_UNORM;
+ }
+ break;
}
+
+ unsigned index = integer*2 + normalized;
+ assert(index <= 2);
+ assert(type >= GL_BYTE && type <= GL_FIXED);
+ return vertex_formats[type - GL_BYTE][index][size-1];
+}
+
+void
+_mesa_set_vertex_format(struct gl_vertex_format *vertex_format,
+ GLubyte size, GLenum16 type, GLenum16 format,
+ GLboolean normalized, GLboolean integer,
+ GLboolean doubles)
+{
+ assert(size <= 4);
+ vertex_format->Type = type;
+ vertex_format->Format = format;
+ vertex_format->Size = size;
+ vertex_format->Normalized = normalized;
+ vertex_format->Integer = integer;
+ vertex_format->Doubles = doubles;
+ vertex_format->_ElementSize = _mesa_bytes_per_vertex_attrib(size, type);
+ assert(vertex_format->_ElementSize <= 4*sizeof(double));
+ vertex_format->_PipeFormat =
+ vertex_format_to_pipe_format(size, type, format, normalized, integer,
+ doubles);
}
legalTypesMask &= ~(UNSIGNED_INT_BIT |
INT_BIT |
UNSIGNED_INT_2_10_10_10_REV_BIT |
- INT_2_10_10_10_REV_BIT |
- HALF_BIT);
+ INT_2_10_10_10_REV_BIT);
+
+ if (!_mesa_has_OES_vertex_half_float(ctx))
+ legalTypesMask &= ~HALF_BIT;
}
}
else {
return legalTypesMask;
}
+static GLenum
+get_array_format(const struct gl_context *ctx, GLint sizeMax, GLint *size)
+{
+ GLenum format = GL_RGBA;
+
+ /* Do size parameter checking.
+ * If sizeMax = BGRA_OR_4 it means that size = GL_BGRA is legal and
+ * must be handled specially.
+ */
+ if (ctx->Extensions.EXT_vertex_array_bgra && sizeMax == BGRA_OR_4 &&
+ *size == GL_BGRA) {
+ format = GL_BGRA;
+ *size = 4;
+ }
+
+ return format;
+}
+
/**
* \param attrib The index of the attribute array
* \param doubles Double values not reduced to floats
* \param relativeOffset Offset of the first element relative to the binding
* offset.
- * \param flush_verties Should \c FLUSH_VERTICES be invoked before updating
- * state?
*/
void
_mesa_update_array_format(struct gl_context *ctx,
struct gl_vertex_array_object *vao,
- GLuint attrib, GLint size, GLenum type,
+ gl_vert_attrib attrib, GLint size, GLenum type,
GLenum format, GLboolean normalized,
GLboolean integer, GLboolean doubles,
- GLuint relativeOffset, bool flush_vertices)
+ GLuint relativeOffset)
{
- struct gl_vertex_attrib_array *const array = &vao->VertexAttrib[attrib];
- GLint elementSize;
+ struct gl_array_attributes *const array = &vao->VertexAttrib[attrib];
+ assert(!vao->SharedAndImmutable);
assert(size <= 4);
- if (flush_vertices) {
- FLUSH_VERTICES(ctx, 0);
- }
-
- elementSize = _mesa_bytes_per_vertex_attrib(size, type);
- assert(elementSize != -1);
-
- array->Size = size;
- array->Type = type;
- array->Format = format;
- array->Normalized = normalized;
- array->Integer = integer;
- array->Doubles = doubles;
array->RelativeOffset = relativeOffset;
- array->_ElementSize = elementSize;
+ _mesa_set_vertex_format(&array->Format, size, type, format,
+ normalized, integer, doubles);
- vao->NewArrays |= VERT_BIT(attrib);
- ctx->NewState |= _NEW_ARRAY;
+ vao->NewArrays |= vao->Enabled & VERT_BIT(attrib);
}
/**
- * Does error checking and updates the format in an attrib array.
+ * Does error checking of the format in an attrib array.
*
- * Called by update_array() and VertexAttrib*Format().
+ * Called by *Pointer() and VertexAttrib*Format().
*
* \param func Name of calling function used for error reporting
* \param attrib The index of the attribute array
* \param integer Integer-valued values (will not be normalized to [-1, 1])
* \param doubles Double values not reduced to floats
* \param relativeOffset Offset of the first element relative to the binding offset.
+ * \return bool True if validation is successful, False otherwise.
*/
static bool
-update_array_format(struct gl_context *ctx,
- const char *func,
- struct gl_vertex_array_object *vao,
- GLuint attrib, GLbitfield legalTypesMask,
- GLint sizeMin, GLint sizeMax,
- GLint size, GLenum type,
- GLboolean normalized, GLboolean integer, GLboolean doubles,
- GLuint relativeOffset)
+validate_array_format(struct gl_context *ctx, const char *func,
+ struct gl_vertex_array_object *vao,
+ GLuint attrib, GLbitfield legalTypesMask,
+ GLint sizeMin, GLint sizeMax,
+ GLint size, GLenum type, GLboolean normalized,
+ GLboolean integer, GLboolean doubles,
+ GLuint relativeOffset, GLenum format)
{
GLbitfield typeBit;
- GLenum format = GL_RGBA;
+
+ /* at most, one of these bools can be true */
+ assert((int) normalized + (int) integer + (int) doubles <= 1);
if (ctx->Array.LegalTypesMask == 0 || ctx->Array.LegalTypesMaskAPI != ctx->API) {
/* Compute the LegalTypesMask only once, unless the context API has
return false;
}
- /* Do size parameter checking.
- * If sizeMax = BGRA_OR_4 it means that size = GL_BGRA is legal and
- * must be handled specially.
- */
- if (ctx->Extensions.EXT_vertex_array_bgra &&
- sizeMax == BGRA_OR_4 &&
- size == GL_BGRA) {
+ if (format == GL_BGRA) {
/* Page 298 of the PDF of the OpenGL 4.3 (Core Profile) spec says:
*
* "An INVALID_OPERATION error is generated under any of the following
"%s(size=GL_BGRA and normalized=GL_FALSE)", func);
return false;
}
-
- format = GL_BGRA;
- size = 4;
}
else if (size < sizeMin || size > sizeMax || size > 4) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(size=%d)", func, size);
return false;
}
- _mesa_update_array_format(ctx, vao, attrib, size, type, format,
- normalized, integer, doubles, relativeOffset,
- false);
-
return true;
}
-
/**
- * Do error checking and update state for glVertex/Color/TexCoord/...Pointer
- * functions.
+ * Do error checking for glVertex/Color/TexCoord/...Pointer functions.
*
* \param func name of calling function used for error reporting
+ * \param vao the vao to update
+ * \param obj the bound buffer object
* \param attrib the attribute array index to update
* \param legalTypes bitmask of *_BIT above indicating legal datatypes
* \param sizeMin min allowable size value
* \param ptr the address (or offset inside VBO) of the array data
*/
static void
-update_array(struct gl_context *ctx,
- const char *func,
- GLuint attrib, GLbitfield legalTypesMask,
- GLint sizeMin, GLint sizeMax,
- GLint size, GLenum type, GLsizei stride,
- GLboolean normalized, GLboolean integer, GLboolean doubles,
- const GLvoid *ptr)
+validate_array(struct gl_context *ctx, const char *func,
+ struct gl_vertex_array_object *vao,
+ struct gl_buffer_object *obj,
+ GLuint attrib, GLbitfield legalTypesMask,
+ GLint sizeMin, GLint sizeMax,
+ GLint size, GLenum type, GLsizei stride,
+ GLboolean normalized, GLboolean integer, GLboolean doubles,
+ const GLvoid *ptr)
{
- struct gl_vertex_attrib_array *array;
- GLsizei effectiveStride;
-
/* Page 407 (page 423 of the PDF) of the OpenGL 3.0 spec says:
*
* "Client vertex arrays - all vertex array attribute pointers must
*
* The check for VBOs is handled below.
*/
- if (ctx->API == API_OPENGL_CORE
- && (ctx->Array.VAO == ctx->Array.DefaultVAO)) {
+ if (ctx->API == API_OPENGL_CORE && (vao == ctx->Array.DefaultVAO)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(no array object bound)",
func);
return;
return;
}
- if (ctx->API == API_OPENGL_CORE && ctx->Version >= 44 &&
+ if (_mesa_is_desktop_gl(ctx) && ctx->Version >= 44 &&
stride > ctx->Const.MaxVertexAttribStride) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(stride=%d > "
"GL_MAX_VERTEX_ATTRIB_STRIDE)", func, stride);
* to the ARRAY_BUFFER buffer object binding point (see section
* 2.9.6), and the pointer argument is not NULL."
*/
- if (ptr != NULL && ctx->Array.VAO->ARBsemantics &&
- !_mesa_is_bufferobj(ctx->Array.ArrayBufferObj)) {
+ if (ptr != NULL && vao != ctx->Array.DefaultVAO &&
+ !_mesa_is_bufferobj(obj)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-VBO array)", func);
return;
}
+}
- if (!update_array_format(ctx, func, ctx->Array.VAO, attrib,
- legalTypesMask, sizeMin, sizeMax,
- size, type, normalized, integer, doubles, 0)) {
- return;
- }
+
+static bool
+validate_array_and_format(struct gl_context *ctx, const char *func,
+ struct gl_vertex_array_object *vao,
+ struct gl_buffer_object *obj,
+ GLuint attrib, GLbitfield legalTypes,
+ GLint sizeMin, GLint sizeMax,
+ GLint size, GLenum type, GLsizei stride,
+ GLboolean normalized, GLboolean integer,
+ GLboolean doubles, GLenum format, const GLvoid *ptr)
+{
+ validate_array(ctx, func, vao, obj, attrib, legalTypes, sizeMin, sizeMax,
+ size, type, stride, normalized, integer, doubles, ptr);
+
+ return validate_array_format(ctx, func, vao, attrib, legalTypes, sizeMin,
+ sizeMax, size, type, normalized, integer,
+ doubles, 0, format);
+}
+
+
+/**
+ * Update state for glVertex/Color/TexCoord/...Pointer functions.
+ *
+ * \param vao the vao to update
+ * \param obj the bound buffer object
+ * \param attrib the attribute array index to update
+ * \param format Either GL_RGBA or GL_BGRA.
+ * \param sizeMax max allowable size value (may also be BGRA_OR_4)
+ * \param size components per element (1, 2, 3 or 4)
+ * \param type datatype of each component (GL_FLOAT, GL_INT, etc)
+ * \param stride stride between elements, in elements
+ * \param normalized are integer types converted to floats in [-1, 1]?
+ * \param integer integer-valued values (will not be normalized to [-1,1])
+ * \param doubles Double values not reduced to floats
+ * \param ptr the address (or offset inside VBO) of the array data
+ */
+static void
+update_array(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ struct gl_buffer_object *obj,
+ GLuint attrib, GLenum format,
+ GLint sizeMax,
+ GLint size, GLenum type, GLsizei stride,
+ GLboolean normalized, GLboolean integer, GLboolean doubles,
+ const GLvoid *ptr)
+{
+ _mesa_update_array_format(ctx, vao, attrib, size, type, format,
+ normalized, integer, doubles, 0);
/* Reset the vertex attrib binding */
- vertex_attrib_binding(ctx, ctx->Array.VAO, attrib, attrib);
+ _mesa_vertex_attrib_binding(ctx, vao, attrib, attrib);
/* The Stride and Ptr fields are not set by update_array_format() */
- array = &ctx->Array.VAO->VertexAttrib[attrib];
+ struct gl_array_attributes *array = &vao->VertexAttrib[attrib];
array->Stride = stride;
- array->Ptr = (const GLvoid *) ptr;
+ /* For updating the pointer we would need to add the vao->NewArrays flag
+ * to the VAO. But but that is done already unconditionally in
+ * _mesa_update_array_format called above.
+ */
+ assert((vao->NewArrays | ~vao->Enabled) & VERT_BIT(attrib));
+ array->Ptr = ptr;
/* Update the vertex buffer binding */
- effectiveStride = stride != 0 ? stride : array->_ElementSize;
- _mesa_bind_vertex_buffer(ctx, ctx->Array.VAO, attrib,
- ctx->Array.ArrayBufferObj, (GLintptr) ptr,
+ GLsizei effectiveStride = stride != 0 ?
+ stride : array->Format._ElementSize;
+ _mesa_bind_vertex_buffer(ctx, vao, attrib,
+ obj, (GLintptr) ptr,
effectiveStride);
}
+/* Helper function for all EXT_direct_state_access glVertexArray* functions */
+static bool
+_lookup_vao_and_vbo_dsa(struct gl_context *ctx,
+ GLuint vaobj, GLuint buffer,
+ GLintptr offset,
+ struct gl_vertex_array_object** vao,
+ struct gl_buffer_object** vbo,
+ const char* caller)
+{
+ *vao = _mesa_lookup_vao_err(ctx, vaobj, true, caller);
+ if (!(*vao))
+ return false;
+
+ if (buffer != 0) {
+ *vbo = _mesa_lookup_bufferobj(ctx, buffer);
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer, vbo, caller))
+ return false;
+
+ if (offset < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "%s(negative offset with non-0 buffer)", caller);
+ return false;
+ }
+ } else {
+ *vbo = ctx->Shared->NullBufferObj;
+ }
+
+ return true;
+}
+
+
+void GLAPIENTRY
+_mesa_VertexPointer_no_error(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_POS, GL_RGBA, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
void GLAPIENTRY
_mesa_VertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
{
GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
GLbitfield legalTypes = (ctx->API == API_OPENGLES)
? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
: (SHORT_BIT | INT_BIT | FLOAT_BIT |
UNSIGNED_INT_2_10_10_10_REV_BIT |
INT_2_10_10_10_REV_BIT);
- FLUSH_VERTICES(ctx, 0);
+ if (!validate_array_and_format(ctx, "glVertexPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_POS, legalTypes, 2, 4, size,
+ type, stride, GL_FALSE, GL_FALSE, GL_FALSE,
+ format, ptr))
+ return;
- update_array(ctx, "glVertexPointer", VERT_ATTRIB_POS,
- legalTypes, 2, 4,
- size, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_POS, format, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, ptr);
}
void GLAPIENTRY
-_mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
+_mesa_VertexArrayVertexOffsetEXT(GLuint vaobj, GLuint buffer, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
{
GET_CURRENT_CONTEXT(ctx);
- const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+
+ GLenum format = GL_RGBA;
+ GLbitfield legalTypes = (ctx->API == API_OPENGLES)
? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
- : (BYTE_BIT | SHORT_BIT | INT_BIT |
- HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ : (SHORT_BIT | INT_BIT | FLOAT_BIT |
+ DOUBLE_BIT | HALF_BIT |
UNSIGNED_INT_2_10_10_10_REV_BIT |
INT_2_10_10_10_REV_BIT);
- FLUSH_VERTICES(ctx, 0);
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayVertexOffsetEXT"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glVertexArrayVertexOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_POS, legalTypes, 2, 4, size,
+ type, stride, GL_FALSE, GL_FALSE, GL_FALSE,
+ format, (void*) offset))
+ return;
- update_array(ctx, "glNormalPointer", VERT_ATTRIB_NORMAL,
- legalTypes, 3, 3,
- 3, type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_POS, format, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, (void*) offset);
}
void GLAPIENTRY
-_mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
+_mesa_NormalPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr )
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_NORMAL, GL_RGBA, 3, 3, type, stride, GL_TRUE,
+ GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_NormalPointer(GLenum type, GLsizei stride, const GLvoid *ptr )
{
GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
- ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT)
- : (BYTE_BIT | UNSIGNED_BYTE_BIT |
- SHORT_BIT | UNSIGNED_SHORT_BIT |
- INT_BIT | UNSIGNED_INT_BIT |
+ ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+ : (BYTE_BIT | SHORT_BIT | INT_BIT |
HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
UNSIGNED_INT_2_10_10_10_REV_BIT |
INT_2_10_10_10_REV_BIT);
- const GLint sizeMin = (ctx->API == API_OPENGLES) ? 4 : 3;
- FLUSH_VERTICES(ctx, 0);
+ if (!validate_array_and_format(ctx, "glNormalPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_NORMAL, legalTypes, 3, 3, 3,
+ type, stride, GL_TRUE, GL_FALSE,
+ GL_FALSE, format, ptr))
+ return;
- update_array(ctx, "glColorPointer", VERT_ATTRIB_COLOR0,
- legalTypes, sizeMin, BGRA_OR_4,
- size, type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_NORMAL, format, 3, 3, type, stride, GL_TRUE,
+ GL_FALSE, GL_FALSE, ptr);
}
void GLAPIENTRY
-_mesa_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
+_mesa_VertexArrayNormalOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type,
+ GLsizei stride, GLintptr offset)
{
- const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT);
GET_CURRENT_CONTEXT(ctx);
- FLUSH_VERTICES(ctx, 0);
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+ ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+ : (BYTE_BIT | SHORT_BIT | INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glNormalPointer"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glNormalPointer",
+ vao, vbo,
+ VERT_ATTRIB_NORMAL, legalTypes, 3, 3, 3,
+ type, stride, GL_TRUE, GL_FALSE,
+ GL_FALSE, format, (void*) offset))
+ return;
- update_array(ctx, "glFogCoordPointer", VERT_ATTRIB_FOG,
- legalTypes, 1, 1,
- 1, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_NORMAL, format, 3, 3, type, stride, GL_TRUE,
+ GL_FALSE, GL_FALSE, (void*) offset);
}
void GLAPIENTRY
-_mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
+_mesa_ColorPointer_no_error(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *ptr)
{
- const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT |
- FLOAT_BIT | DOUBLE_BIT);
GET_CURRENT_CONTEXT(ctx);
- FLUSH_VERTICES(ctx, 0);
-
- update_array(ctx, "glIndexPointer", VERT_ATTRIB_COLOR_INDEX,
- legalTypes, 1, 1,
- 1, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR0, format, BGRA_OR_4, size,
+ type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
}
void GLAPIENTRY
-_mesa_SecondaryColorPointer(GLint size, GLenum type,
- GLsizei stride, const GLvoid *ptr)
+_mesa_ColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *ptr)
{
- const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
- SHORT_BIT | UNSIGNED_SHORT_BIT |
- INT_BIT | UNSIGNED_INT_BIT |
- HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
- UNSIGNED_INT_2_10_10_10_REV_BIT |
- INT_2_10_10_10_REV_BIT);
GET_CURRENT_CONTEXT(ctx);
+ const GLint sizeMin = (ctx->API == API_OPENGLES) ? 4 : 3;
+
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+ ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT)
+ : (BYTE_BIT | UNSIGNED_BYTE_BIT |
+ SHORT_BIT | UNSIGNED_SHORT_BIT |
+ INT_BIT | UNSIGNED_INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
- FLUSH_VERTICES(ctx, 0);
+ if (!validate_array_and_format(ctx, "glColorPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR0, legalTypes, sizeMin,
+ BGRA_OR_4, size, type, stride, GL_TRUE,
+ GL_FALSE, GL_FALSE, format, ptr))
+ return;
- update_array(ctx, "glSecondaryColorPointer", VERT_ATTRIB_COLOR1,
- legalTypes, 3, BGRA_OR_4,
- size, type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR0, format, BGRA_OR_4, size,
+ type, stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
}
void GLAPIENTRY
-_mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
- const GLvoid *ptr)
+_mesa_VertexArrayColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
{
GET_CURRENT_CONTEXT(ctx);
- GLbitfield legalTypes = (ctx->API == API_OPENGLES)
- ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
- : (SHORT_BIT | INT_BIT |
+ const GLint sizeMin = (ctx->API == API_OPENGLES) ? 4 : 3;
+
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+ ? (UNSIGNED_BYTE_BIT | HALF_BIT | FLOAT_BIT | FIXED_ES_BIT)
+ : (BYTE_BIT | UNSIGNED_BYTE_BIT |
+ SHORT_BIT | UNSIGNED_SHORT_BIT |
+ INT_BIT | UNSIGNED_INT_BIT |
HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
UNSIGNED_INT_2_10_10_10_REV_BIT |
INT_2_10_10_10_REV_BIT);
- const GLint sizeMin = (ctx->API == API_OPENGLES) ? 2 : 1;
- const GLuint unit = ctx->Array.ActiveTexture;
- FLUSH_VERTICES(ctx, 0);
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayColorOffsetEXT"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glVertexArrayColorOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_COLOR0, legalTypes, sizeMin,
+ BGRA_OR_4, size, type, stride, GL_TRUE,
+ GL_FALSE, GL_FALSE, format, (void*) offset))
+ return;
- update_array(ctx, "glTexCoordPointer", VERT_ATTRIB_TEX(unit),
- legalTypes, sizeMin, 4,
- size, type, stride, GL_FALSE, GL_FALSE, GL_FALSE,
- ptr);
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_COLOR0, format, BGRA_OR_4, size,
+ type, stride, GL_TRUE, GL_FALSE, GL_FALSE, (void*) offset);
}
void GLAPIENTRY
-_mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
+_mesa_FogCoordPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr)
{
- const GLbitfield legalTypes = UNSIGNED_BYTE_BIT;
- /* this is the same type that glEdgeFlag uses */
- const GLboolean integer = GL_FALSE;
GET_CURRENT_CONTEXT(ctx);
- FLUSH_VERTICES(ctx, 0);
-
- update_array(ctx, "glEdgeFlagPointer", VERT_ATTRIB_EDGEFLAG,
- legalTypes, 1, 1,
- 1, GL_UNSIGNED_BYTE, stride, GL_FALSE, integer, GL_FALSE, ptr);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_FOG, GL_RGBA, 1, 1, type, stride, GL_FALSE,
+ GL_FALSE, GL_FALSE, ptr);
}
void GLAPIENTRY
-_mesa_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *ptr)
+_mesa_FogCoordPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
{
- const GLbitfield legalTypes = (FLOAT_BIT | FIXED_ES_BIT);
GET_CURRENT_CONTEXT(ctx);
- FLUSH_VERTICES(ctx, 0);
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT);
- if (ctx->API != API_OPENGLES) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "glPointSizePointer(ES 1.x only)");
+ if (!validate_array_and_format(ctx, "glFogCoordPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_FOG, legalTypes, 1, 1, 1,
+ type, stride, GL_FALSE, GL_FALSE,
+ GL_FALSE, format, ptr))
return;
- }
- update_array(ctx, "glPointSizePointer", VERT_ATTRIB_POINT_SIZE,
- legalTypes, 1, 1,
- 1, type, stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_FOG, format, 1, 1, type, stride, GL_FALSE,
+ GL_FALSE, GL_FALSE, ptr);
}
-/**
+void GLAPIENTRY
+_mesa_VertexArrayFogCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type,
+ GLsizei stride, GLintptr offset)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT);
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayFogCoordOffsetEXT"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glVertexArrayFogCoordOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_FOG, legalTypes, 1, 1, 1,
+ type, stride, GL_FALSE, GL_FALSE,
+ GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_FOG, format, 1, 1, type, stride, GL_FALSE,
+ GL_FALSE, GL_FALSE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_IndexPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR_INDEX, GL_RGBA, 1, 1, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_IndexPointer(GLenum type, GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT |
+ FLOAT_BIT | DOUBLE_BIT);
+
+ if (!validate_array_and_format(ctx, "glIndexPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR_INDEX,
+ legalTypes, 1, 1, 1, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR_INDEX, format, 1, 1, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayIndexOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type,
+ GLsizei stride, GLintptr offset)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (UNSIGNED_BYTE_BIT | SHORT_BIT | INT_BIT |
+ FLOAT_BIT | DOUBLE_BIT);
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayIndexOffsetEXT"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glVertexArrayIndexOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_COLOR_INDEX,
+ legalTypes, 1, 1, 1, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_COLOR_INDEX, format, 1, 1, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_SecondaryColorPointer_no_error(GLint size, GLenum type,
+ GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type,
+ stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_SecondaryColorPointer(GLint size, GLenum type,
+ GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
+ SHORT_BIT | UNSIGNED_SHORT_BIT |
+ INT_BIT | UNSIGNED_INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
+
+ if (!validate_array_and_format(ctx, "glSecondaryColorPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR1, legalTypes, 3,
+ BGRA_OR_4, size, type, stride,
+ GL_TRUE, GL_FALSE, GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type,
+ stride, GL_TRUE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArraySecondaryColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
+ SHORT_BIT | UNSIGNED_SHORT_BIT |
+ INT_BIT | UNSIGNED_INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArraySecondaryColorOffsetEXT"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glVertexArraySecondaryColorOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_COLOR1, legalTypes, 3,
+ BGRA_OR_4, size, type, stride,
+ GL_TRUE, GL_FALSE, GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type,
+ stride, GL_TRUE, GL_FALSE, GL_FALSE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_TexCoordPointer_no_error(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ const GLuint unit = ctx->Array.ActiveTexture;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_TEX(unit), GL_RGBA, 4, size, type,
+ stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_TexCoordPointer(GLint size, GLenum type, GLsizei stride,
+ const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ const GLint sizeMin = (ctx->API == API_OPENGLES) ? 2 : 1;
+ const GLuint unit = ctx->Array.ActiveTexture;
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+ ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+ : (SHORT_BIT | INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
+
+ if (!validate_array_and_format(ctx, "glTexCoordPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_TEX(unit), legalTypes,
+ sizeMin, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_TEX(unit), format, 4, size, type,
+ stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ const GLint sizeMin = (ctx->API == API_OPENGLES) ? 2 : 1;
+ const GLuint unit = ctx->Array.ActiveTexture;
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+ ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+ : (SHORT_BIT | INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayTexCoordOffsetEXT"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glVertexArrayTexCoordOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_TEX(unit), legalTypes,
+ sizeMin, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_TEX(unit), format, 4, size, type,
+ stride, GL_FALSE, GL_FALSE, GL_FALSE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayMultiTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum texunit,
+ GLint size, GLenum type, GLsizei stride,
+ GLintptr offset)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ const GLint sizeMin = (ctx->API == API_OPENGLES) ? 2 : 1;
+ const GLuint unit = texunit - GL_TEXTURE0;
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (ctx->API == API_OPENGLES)
+ ? (BYTE_BIT | SHORT_BIT | FLOAT_BIT | FIXED_ES_BIT)
+ : (SHORT_BIT | INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayMultiTexCoordOffsetEXT"))
+ return;
+
+ if (unit >= ctx->Const.MaxCombinedTextureImageUnits) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexArrayMultiTexCoordOffsetEXT(texunit=%d)",
+ texunit);
+ return;
+ }
+
+ if (!validate_array_and_format(ctx, "glVertexArrayMultiTexCoordOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_TEX(unit), legalTypes,
+ sizeMin, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_TEX(unit), format, 4, size, type,
+ stride, GL_FALSE, GL_FALSE, GL_FALSE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_EdgeFlagPointer_no_error(GLsizei stride, const GLvoid *ptr)
+{
+ /* this is the same type that glEdgeFlag uses */
+ const GLboolean integer = GL_FALSE;
+ GET_CURRENT_CONTEXT(ctx);
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_EDGEFLAG, GL_RGBA, 1, 1, GL_UNSIGNED_BYTE,
+ stride, GL_FALSE, integer, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_EdgeFlagPointer(GLsizei stride, const GLvoid *ptr)
+{
+ /* this is the same type that glEdgeFlag uses */
+ const GLboolean integer = GL_FALSE;
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = UNSIGNED_BYTE_BIT;
+
+ if (!validate_array_and_format(ctx, "glEdgeFlagPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_EDGEFLAG, legalTypes,
+ 1, 1, 1, GL_UNSIGNED_BYTE, stride,
+ GL_FALSE, integer, GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_EDGEFLAG, format, 1, 1, GL_UNSIGNED_BYTE,
+ stride, GL_FALSE, integer, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayEdgeFlagOffsetEXT(GLuint vaobj, GLuint buffer, GLsizei stride,
+ GLintptr offset)
+{
+ /* this is the same type that glEdgeFlag uses */
+ const GLboolean integer = GL_FALSE;
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = UNSIGNED_BYTE_BIT;
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayEdgeFlagOffsetEXT"))
+ return;
+
+ if (!validate_array_and_format(ctx, "glVertexArrayEdgeFlagOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_EDGEFLAG, legalTypes,
+ 1, 1, 1, GL_UNSIGNED_BYTE, stride,
+ GL_FALSE, integer, GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_EDGEFLAG, format, 1, 1, GL_UNSIGNED_BYTE,
+ stride, GL_FALSE, integer, GL_FALSE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_PointSizePointerOES_no_error(GLenum type, GLsizei stride,
+ const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_POINT_SIZE, GL_RGBA, 1, 1, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_PointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
+ if (ctx->API != API_OPENGLES) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "glPointSizePointer(ES 1.x only)");
+ return;
+ }
+
+ const GLbitfield legalTypes = (FLOAT_BIT | FIXED_ES_BIT);
+
+ if (!validate_array_and_format(ctx, "glPointSizePointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_POINT_SIZE, legalTypes,
+ 1, 1, 1, type, stride, GL_FALSE, GL_FALSE,
+ GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_POINT_SIZE, format, 1, 1, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexAttribPointer_no_error(GLuint index, GLint size, GLenum type,
+ GLboolean normalized,
+ GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4,
+ size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+/**
* Set a generic vertex attribute array.
* Note that these arrays DO NOT alias the conventional GL vertex arrays
* (position, normal, color, fog, texcoord, etc).
GLboolean normalized,
GLsizei stride, const GLvoid *ptr)
{
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(idx)");
+ return;
+ }
+
const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
SHORT_BIT | UNSIGNED_SHORT_BIT |
INT_BIT | UNSIGNED_INT_BIT |
UNSIGNED_INT_2_10_10_10_REV_BIT |
INT_2_10_10_10_REV_BIT |
UNSIGNED_INT_10F_11F_11F_REV_BIT);
+
+ if (!validate_array_and_format(ctx, "glVertexAttribPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), legalTypes,
+ 1, BGRA_OR_4, size, type, stride,
+ normalized, GL_FALSE, GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4,
+ size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayVertexAttribOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size,
+ GLenum type, GLboolean normalized,
+ GLsizei stride, GLintptr offset)
+{
GET_CURRENT_CONTEXT(ctx);
+ GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayVertexAttribOffsetEXT"))
+ return;
if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribPointerARB(index)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glVertexArrayVertexAttribOffsetEXT(idx)");
return;
}
- update_array(ctx, "glVertexAttribPointer", VERT_ATTRIB_GENERIC(index),
- legalTypes, 1, BGRA_OR_4,
- size, type, stride, normalized, GL_FALSE, GL_FALSE, ptr);
+ const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
+ SHORT_BIT | UNSIGNED_SHORT_BIT |
+ INT_BIT | UNSIGNED_INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ FIXED_ES_BIT | FIXED_GL_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT |
+ UNSIGNED_INT_10F_11F_11F_REV_BIT);
+
+ if (!validate_array_and_format(ctx, "glVertexArrayVertexAttribOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_GENERIC(index), legalTypes,
+ 1, BGRA_OR_4, size, type, stride,
+ normalized, GL_FALSE, GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4,
+ size, type, stride, normalized, GL_FALSE, GL_FALSE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayVertexAttribLOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ GLenum format = GL_RGBA;
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayVertexAttribLOffsetEXT"))
+ return;
+
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glVertexArrayVertexAttribLOffsetEXT(idx)");
+ return;
+ }
+
+ const GLbitfield legalTypes = DOUBLE_BIT;
+
+ if (!validate_array_and_format(ctx, "glVertexArrayVertexAttribLOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_GENERIC(index), legalTypes,
+ 1, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_TRUE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_GENERIC(index), format, 4,
+ size, type, stride, GL_FALSE, GL_FALSE, GL_TRUE, (void*) offset);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexAttribIPointer_no_error(GLuint index, GLint size, GLenum type,
+ GLsizei stride, const GLvoid *ptr)
+{
+ const GLboolean normalized = GL_FALSE;
+ const GLboolean integer = GL_TRUE;
+ GET_CURRENT_CONTEXT(ctx);
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type,
+ stride, normalized, integer, GL_FALSE, ptr);
}
_mesa_VertexAttribIPointer(GLuint index, GLint size, GLenum type,
GLsizei stride, const GLvoid *ptr)
{
+ const GLboolean normalized = GL_FALSE;
+ const GLboolean integer = GL_TRUE;
+ GET_CURRENT_CONTEXT(ctx);
+
+ GLenum format = GL_RGBA;
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribIPointer(index)");
+ return;
+ }
+
const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
SHORT_BIT | UNSIGNED_SHORT_BIT |
INT_BIT | UNSIGNED_INT_BIT);
+
+ if (!validate_array_and_format(ctx, "glVertexAttribIPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), legalTypes,
+ 1, 4, size, type, stride,
+ normalized, integer, GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), format, 4, size, type,
+ stride, normalized, integer, GL_FALSE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexAttribLPointer_no_error(GLuint index, GLint size, GLenum type,
+ GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type,
+ stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr);
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayVertexAttribIOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
+{
const GLboolean normalized = GL_FALSE;
const GLboolean integer = GL_TRUE;
GET_CURRENT_CONTEXT(ctx);
+ GLenum format = GL_RGBA;
+
+ struct gl_vertex_array_object* vao;
+ struct gl_buffer_object* vbo;
+
+ if (!_lookup_vao_and_vbo_dsa(ctx, vaobj, buffer, offset,
+ &vao, &vbo,
+ "glVertexArrayVertexAttribIOffsetEXT"))
+ return;
if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribIPointer(index)");
+ _mesa_error(ctx, GL_INVALID_VALUE, "glVertexArrayVertexAttribIOffsetEXT(index)");
return;
}
- update_array(ctx, "glVertexAttribIPointer", VERT_ATTRIB_GENERIC(index),
- legalTypes, 1, 4,
- size, type, stride, normalized, integer, GL_FALSE, ptr);
+ const GLbitfield legalTypes = (BYTE_BIT | UNSIGNED_BYTE_BIT |
+ SHORT_BIT | UNSIGNED_SHORT_BIT |
+ INT_BIT | UNSIGNED_INT_BIT);
+
+ if (!validate_array_and_format(ctx, "glVertexArrayVertexAttribIOffsetEXT",
+ vao, vbo,
+ VERT_ATTRIB_GENERIC(index), legalTypes,
+ 1, 4, size, type, stride,
+ normalized, integer, GL_FALSE, format, (void*) offset))
+ return;
+
+ update_array(ctx, vao, vbo,
+ VERT_ATTRIB_GENERIC(index), format, 4, size, type,
+ stride, normalized, integer, GL_FALSE, (void*) offset);
}
+
void GLAPIENTRY
_mesa_VertexAttribLPointer(GLuint index, GLint size, GLenum type,
GLsizei stride, const GLvoid *ptr)
{
GET_CURRENT_CONTEXT(ctx);
- const GLbitfield legalTypes = (DOUBLE_BIT);
+
+ GLenum format = GL_RGBA;
if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
_mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribLPointer(index)");
return;
}
- update_array(ctx, "glVertexAttribLPointer", VERT_ATTRIB_GENERIC(index),
- legalTypes, 1, 4,
- size, type, stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr);
+ const GLbitfield legalTypes = DOUBLE_BIT;
+
+ if (!validate_array_and_format(ctx, "glVertexAttribLPointer",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), legalTypes,
+ 1, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_TRUE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), format, 4, size, type,
+ stride, GL_FALSE, GL_FALSE, GL_TRUE, ptr);
}
void
-_mesa_enable_vertex_array_attrib(struct gl_context *ctx,
- struct gl_vertex_array_object *vao,
- unsigned attrib)
+_mesa_enable_vertex_array_attribs(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ GLbitfield attrib_bits)
{
- assert(attrib < ARRAY_SIZE(vao->VertexAttrib));
+ assert((attrib_bits & ~VERT_BIT_ALL) == 0);
+ assert(!vao->SharedAndImmutable);
- if (!vao->VertexAttrib[attrib].Enabled) {
+ /* Only work on bits that are disabled */
+ attrib_bits &= ~vao->Enabled;
+ if (attrib_bits) {
/* was disabled, now being enabled */
- FLUSH_VERTICES(ctx, _NEW_ARRAY);
- vao->VertexAttrib[attrib].Enabled = GL_TRUE;
- vao->_Enabled |= VERT_BIT(attrib);
- vao->NewArrays |= VERT_BIT(attrib);
+ vao->Enabled |= attrib_bits;
+ vao->NewArrays |= attrib_bits;
+
+ /* Update the map mode if needed */
+ if (attrib_bits & (VERT_BIT_POS|VERT_BIT_GENERIC0))
+ update_attribute_map_mode(ctx, vao);
}
}
}
+void GLAPIENTRY
+_mesa_EnableVertexAttribArray_no_error(GLuint index)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ _mesa_enable_vertex_array_attrib(ctx, ctx->Array.VAO,
+ VERT_ATTRIB_GENERIC(index));
+}
+
+
void GLAPIENTRY
_mesa_EnableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
* [compatibility profile: zero or] the name of an existing vertex
* array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glEnableVertexArrayAttrib");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glEnableVertexArrayAttrib");
if (!vao)
return;
enable_vertex_array_attrib(ctx, vao, index, "glEnableVertexArrayAttrib");
}
-
-static void
-disable_vertex_array_attrib(struct gl_context *ctx,
- struct gl_vertex_array_object *vao,
- GLuint index,
- const char *func)
+void GLAPIENTRY
+_mesa_EnableVertexArrayAttribEXT(GLuint vaobj, GLuint index)
{
- if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
- _mesa_error(ctx, GL_INVALID_VALUE, "%s(index)", func);
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object* vao = _mesa_lookup_vao_err(ctx, vaobj,
+ true,
+ "glEnableVertexArrayAttribEXT");
+ if (!vao)
return;
- }
- assert(VERT_ATTRIB_GENERIC(index) < ARRAY_SIZE(vao->VertexAttrib));
+ enable_vertex_array_attrib(ctx, vao, index, "glEnableVertexArrayAttribEXT");
+}
+
+
+void GLAPIENTRY
+_mesa_EnableVertexArrayAttrib_no_error(GLuint vaobj, GLuint index)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj);
+ _mesa_enable_vertex_array_attrib(ctx, vao, VERT_ATTRIB_GENERIC(index));
+}
+
- if (vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled) {
+void
+_mesa_disable_vertex_array_attribs(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ GLbitfield attrib_bits)
+{
+ assert((attrib_bits & ~VERT_BIT_ALL) == 0);
+ assert(!vao->SharedAndImmutable);
+
+ /* Only work on bits that are enabled */
+ attrib_bits &= vao->Enabled;
+ if (attrib_bits) {
/* was enabled, now being disabled */
- FLUSH_VERTICES(ctx, _NEW_ARRAY);
- vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Enabled = GL_FALSE;
- vao->_Enabled &= ~VERT_BIT_GENERIC(index);
- vao->NewArrays |= VERT_BIT_GENERIC(index);
+ vao->Enabled &= ~attrib_bits;
+ vao->NewArrays |= attrib_bits;
+
+ /* Update the map mode if needed */
+ if (attrib_bits & (VERT_BIT_POS|VERT_BIT_GENERIC0))
+ update_attribute_map_mode(ctx, vao);
}
}
_mesa_DisableVertexAttribArray(GLuint index)
{
GET_CURRENT_CONTEXT(ctx);
- disable_vertex_array_attrib(ctx, ctx->Array.VAO, index,
- "glDisableVertexAttribArray");
+
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glDisableVertexAttribArray(index)");
+ return;
+ }
+
+ const gl_vert_attrib attrib = VERT_ATTRIB_GENERIC(index);
+ _mesa_disable_vertex_array_attrib(ctx, ctx->Array.VAO, attrib);
+}
+
+
+void GLAPIENTRY
+_mesa_DisableVertexAttribArray_no_error(GLuint index)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ const gl_vert_attrib attrib = VERT_ATTRIB_GENERIC(index);
+ _mesa_disable_vertex_array_attrib(ctx, ctx->Array.VAO, attrib);
}
* [compatibility profile: zero or] the name of an existing vertex
* array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glDisableVertexArrayAttrib");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glDisableVertexArrayAttrib");
if (!vao)
return;
- disable_vertex_array_attrib(ctx, vao, index, "glDisableVertexArrayAttrib");
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glDisableVertexArrayAttrib(index)");
+ return;
+ }
+
+ const gl_vert_attrib attrib = VERT_ATTRIB_GENERIC(index);
+ _mesa_disable_vertex_array_attrib(ctx, vao, attrib);
+}
+
+void GLAPIENTRY
+_mesa_DisableVertexArrayAttribEXT(GLuint vaobj, GLuint index)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object* vao = _mesa_lookup_vao_err(ctx, vaobj,
+ true,
+ "glEnableVertexArrayAttribEXT");
+ if (!vao)
+ return;
+
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glDisableVertexArrayAttrib(index)");
+ return;
+ }
+
+ const gl_vert_attrib attrib = VERT_ATTRIB_GENERIC(index);
+ _mesa_disable_vertex_array_attrib(ctx, vao, attrib);
+}
+
+
+void GLAPIENTRY
+_mesa_DisableVertexArrayAttrib_no_error(GLuint vaobj, GLuint index)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj);
+ const gl_vert_attrib attrib = VERT_ATTRIB_GENERIC(index);
+ _mesa_disable_vertex_array_attrib(ctx, vao, attrib);
}
GLuint index, GLenum pname,
const char *caller)
{
- const struct gl_vertex_attrib_array *array;
+ const struct gl_array_attributes *array;
if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(index=%u)", caller, index);
switch (pname) {
case GL_VERTEX_ATTRIB_ARRAY_ENABLED_ARB:
- return array->Enabled;
+ return !!(vao->Enabled & VERT_BIT_GENERIC(index));
case GL_VERTEX_ATTRIB_ARRAY_SIZE_ARB:
- return (array->Format == GL_BGRA) ? GL_BGRA : array->Size;
+ return (array->Format.Format == GL_BGRA) ? GL_BGRA : array->Format.Size;
case GL_VERTEX_ATTRIB_ARRAY_STRIDE_ARB:
return array->Stride;
case GL_VERTEX_ATTRIB_ARRAY_TYPE_ARB:
- return array->Type;
+ return array->Format.Type;
case GL_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB:
- return array->Normalized;
+ return array->Format.Normalized;
case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB:
- return vao->VertexBinding[array->VertexBinding].BufferObj->Name;
+ return vao->BufferBinding[array->BufferBindingIndex].BufferObj->Name;
case GL_VERTEX_ATTRIB_ARRAY_INTEGER:
if ((_mesa_is_desktop_gl(ctx)
&& (ctx->Version >= 30 || ctx->Extensions.EXT_gpu_shader4))
|| _mesa_is_gles3(ctx)) {
- return array->Integer;
+ return array->Format.Integer;
}
goto error;
case GL_VERTEX_ATTRIB_ARRAY_LONG:
if (_mesa_is_desktop_gl(ctx)) {
- return array->Doubles;
+ return array->Format.Doubles;
}
goto error;
case GL_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB:
if ((_mesa_is_desktop_gl(ctx) && ctx->Extensions.ARB_instanced_arrays)
|| _mesa_is_gles3(ctx)) {
- return vao->VertexBinding[array->VertexBinding].InstanceDivisor;
+ return vao->BufferBinding[array->BufferBindingIndex].InstanceDivisor;
}
goto error;
case GL_VERTEX_ATTRIB_BINDING:
if (_mesa_is_desktop_gl(ctx) || _mesa_is_gles31(ctx)) {
- return array->VertexBinding - VERT_ATTRIB_GENERIC0;
+ return array->BufferBindingIndex - VERT_ATTRIB_GENERIC0;
}
goto error;
case GL_VERTEX_ATTRIB_RELATIVE_OFFSET:
}
}
+void GLAPIENTRY
+_mesa_GetVertexAttribLui64vARB(GLuint index, GLenum pname, GLuint64EXT *params)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ if (pname == GL_CURRENT_VERTEX_ATTRIB_ARB) {
+ const GLuint64 *v =
+ (const GLuint64 *)get_current_attrib(ctx, index,
+ "glGetVertexAttribLui64vARB");
+ if (v != NULL) {
+ params[0] = v[0];
+ params[1] = v[1];
+ params[2] = v[2];
+ params[3] = v[3];
+ }
+ }
+ else {
+ params[0] = (GLuint64) get_vertex_array_attrib(ctx, ctx->Array.VAO,
+ index, pname,
+ "glGetVertexAttribLui64vARB");
+ }
+}
+
/** GL 3.0 */
void GLAPIENTRY
* [compatibility profile: zero or] the name of an existing
* vertex array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glGetVertexArrayIndexediv");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glGetVertexArrayIndexediv");
if (!vao)
return;
*/
switch (pname) {
case GL_VERTEX_BINDING_OFFSET:
- params[0] = vao->VertexBinding[VERT_ATTRIB_GENERIC(index)].Offset;
+ params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset;
break;
case GL_VERTEX_BINDING_STRIDE:
- params[0] = vao->VertexBinding[VERT_ATTRIB_GENERIC(index)].Stride;
+ params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Stride;
break;
case GL_VERTEX_BINDING_DIVISOR:
- params[0] = vao->VertexBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor;
+ params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].InstanceDivisor;
break;
case GL_VERTEX_BINDING_BUFFER:
- params[0] = vao->VertexBinding[VERT_ATTRIB_GENERIC(index)].BufferObj->Name;
+ params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].BufferObj->Name;
break;
default:
params[0] = get_vertex_array_attrib(ctx, vao, index, pname,
* [compatibility profile: zero or] the name of an existing
* vertex array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glGetVertexArrayIndexed64iv");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glGetVertexArrayIndexed64iv");
if (!vao)
return;
return;
}
- params[0] = vao->VertexBinding[VERT_ATTRIB_GENERIC(index)].Offset;
+ params[0] = vao->BufferBinding[VERT_ATTRIB_GENERIC(index)].Offset;
}
}
+void GLAPIENTRY
+_mesa_MultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type,
+ GLsizei stride, const GLvoid *ptr)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ const GLint sizeMin = 1;
+ const GLuint unit = texunit - GL_TEXTURE0;
+
+ GLenum format = GL_RGBA;
+ const GLbitfield legalTypes = (SHORT_BIT | INT_BIT |
+ HALF_BIT | FLOAT_BIT | DOUBLE_BIT |
+ UNSIGNED_INT_2_10_10_10_REV_BIT |
+ INT_2_10_10_10_REV_BIT);
+
+ if (!validate_array_and_format(ctx, "glMultiTexCoordPointerEXT",
+ ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_TEX(unit), legalTypes,
+ sizeMin, 4, size, type, stride,
+ GL_FALSE, GL_FALSE, GL_FALSE, format, ptr))
+ return;
+
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_TEX(unit), format, 4, size, type,
+ stride, GL_FALSE, GL_FALSE, GL_FALSE, ptr);
+}
+
+
void GLAPIENTRY
_mesa_EdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *ptr)
{
GLint defstride; /* default stride */
GLint c, f;
- FLUSH_VERTICES(ctx, 0);
-
f = sizeof(GLfloat);
c = f * ((4 * sizeof(GLubyte) + (f - 1)) / f);
{
GET_CURRENT_CONTEXT(ctx);
- FLUSH_VERTICES(ctx, 0);
-
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glLockArrays %d %d\n", first, count);
ctx->Array.LockFirst = first;
ctx->Array.LockCount = count;
-
- ctx->NewState |= _NEW_ARRAY;
}
{
GET_CURRENT_CONTEXT(ctx);
- FLUSH_VERTICES(ctx, 0);
-
if (MESA_VERBOSE & VERBOSE_API)
_mesa_debug(ctx, "glUnlockArrays\n");
ctx->Array.LockFirst = 0;
ctx->Array.LockCount = 0;
- ctx->NewState |= _NEW_ARRAY;
}
-/* GL_EXT_multi_draw_arrays */
-void GLAPIENTRY
-_mesa_MultiDrawArrays( GLenum mode, const GLint *first,
- const GLsizei *count, GLsizei primcount )
+static void
+primitive_restart_index(struct gl_context *ctx, GLuint index)
{
- GET_CURRENT_CONTEXT(ctx);
- GLint i;
+ ctx->Array.RestartIndex = index;
+}
- FLUSH_VERTICES(ctx, 0);
- for (i = 0; i < primcount; i++) {
- if (count[i] > 0) {
- CALL_DrawArrays(ctx->CurrentDispatch, (mode, first[i], count[i]));
- }
- }
+/**
+ * GL_NV_primitive_restart and GL 3.1
+ */
+void GLAPIENTRY
+_mesa_PrimitiveRestartIndex_no_error(GLuint index)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ primitive_restart_index(ctx, index);
}
-/* GL_IBM_multimode_draw_arrays */
void GLAPIENTRY
-_mesa_MultiModeDrawArraysIBM( const GLenum * mode, const GLint * first,
- const GLsizei * count,
- GLsizei primcount, GLint modestride )
+_mesa_PrimitiveRestartIndex(GLuint index)
{
GET_CURRENT_CONTEXT(ctx);
- GLint i;
- FLUSH_VERTICES(ctx, 0);
-
- for ( i = 0 ; i < primcount ; i++ ) {
- if ( count[i] > 0 ) {
- GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
- CALL_DrawArrays(ctx->CurrentDispatch, ( m, first[i], count[i] ));
- }
+ if (!ctx->Extensions.NV_primitive_restart && ctx->Version < 31) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartIndexNV()");
+ return;
}
+
+ primitive_restart_index(ctx, index);
}
-/* GL_IBM_multimode_draw_arrays */
void GLAPIENTRY
-_mesa_MultiModeDrawElementsIBM( const GLenum * mode, const GLsizei * count,
- GLenum type, const GLvoid * const * indices,
- GLsizei primcount, GLint modestride )
+_mesa_VertexAttribDivisor_no_error(GLuint index, GLuint divisor)
{
GET_CURRENT_CONTEXT(ctx);
- GLint i;
- FLUSH_VERTICES(ctx, 0);
+ const gl_vert_attrib genericIndex = VERT_ATTRIB_GENERIC(index);
+ struct gl_vertex_array_object * const vao = ctx->Array.VAO;
- /* XXX not sure about ARB_vertex_buffer_object handling here */
+ assert(genericIndex < ARRAY_SIZE(vao->VertexAttrib));
- for ( i = 0 ; i < primcount ; i++ ) {
- if ( count[i] > 0 ) {
- GLenum m = *((GLenum *) ((GLubyte *) mode + i * modestride));
- CALL_DrawElements(ctx->CurrentDispatch, ( m, count[i], type,
- indices[i] ));
- }
- }
+ /* The ARB_vertex_attrib_binding spec says:
+ *
+ * "The command
+ *
+ * void VertexAttribDivisor(uint index, uint divisor);
+ *
+ * is equivalent to (assuming no errors are generated):
+ *
+ * VertexAttribBinding(index, index);
+ * VertexBindingDivisor(index, divisor);"
+ */
+ _mesa_vertex_attrib_binding(ctx, vao, genericIndex, genericIndex);
+ vertex_binding_divisor(ctx, vao, genericIndex, divisor);
}
/**
- * GL_NV_primitive_restart and GL 3.1
+ * See GL_ARB_instanced_arrays.
+ * Note that the instance divisor only applies to generic arrays, not
+ * the legacy vertex arrays.
*/
void GLAPIENTRY
-_mesa_PrimitiveRestartIndex(GLuint index)
+_mesa_VertexAttribDivisor(GLuint index, GLuint divisor)
{
GET_CURRENT_CONTEXT(ctx);
- if (!ctx->Extensions.NV_primitive_restart && ctx->Version < 31) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glPrimitiveRestartIndexNV()");
+ const gl_vert_attrib genericIndex = VERT_ATTRIB_GENERIC(index);
+ struct gl_vertex_array_object * const vao = ctx->Array.VAO;
+
+ if (!ctx->Extensions.ARB_instanced_arrays) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexAttribDivisor()");
return;
}
- if (ctx->Array.RestartIndex != index) {
- FLUSH_VERTICES(ctx, _NEW_TRANSFORM);
- ctx->Array.RestartIndex = index;
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glVertexAttribDivisor(index = %u)", index);
+ return;
}
+
+ assert(genericIndex < ARRAY_SIZE(vao->VertexAttrib));
+
+ /* The ARB_vertex_attrib_binding spec says:
+ *
+ * "The command
+ *
+ * void VertexAttribDivisor(uint index, uint divisor);
+ *
+ * is equivalent to (assuming no errors are generated):
+ *
+ * VertexAttribBinding(index, index);
+ * VertexBindingDivisor(index, divisor);"
+ */
+ _mesa_vertex_attrib_binding(ctx, vao, genericIndex, genericIndex);
+ vertex_binding_divisor(ctx, vao, genericIndex, divisor);
}
-/**
- * See GL_ARB_instanced_arrays.
- * Note that the instance divisor only applies to generic arrays, not
- * the legacy vertex arrays.
- */
void GLAPIENTRY
-_mesa_VertexAttribDivisor(GLuint index, GLuint divisor)
+_mesa_VertexArrayVertexAttribDivisorEXT(GLuint vaobj, GLuint index, GLuint divisor)
{
GET_CURRENT_CONTEXT(ctx);
- const GLuint genericIndex = VERT_ATTRIB_GENERIC(index);
- struct gl_vertex_array_object * const vao = ctx->Array.VAO;
+ const gl_vert_attrib genericIndex = VERT_ATTRIB_GENERIC(index);
+ struct gl_vertex_array_object * vao;
+ /* The ARB_instanced_arrays spec says:
+ *
+ * "The vertex array object named by vaobj must
+ * be generated by GenVertexArrays (and not since deleted);
+ * otherwise an INVALID_OPERATION error is generated."
+ */
+ vao = _mesa_lookup_vao_err(ctx, vaobj,
+ false,
+ "glVertexArrayVertexAttribDivisorEXT");
+ if (!vao)
+ return;
if (!ctx->Extensions.ARB_instanced_arrays) {
- _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexAttribDivisor()");
+ _mesa_error(ctx, GL_INVALID_OPERATION, "glVertexArrayVertexAttribDivisorEXT()");
return;
}
if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
- _mesa_error(ctx, GL_INVALID_VALUE, "glVertexAttribDivisor(index = %u)",
- index);
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "glVertexArrayVertexAttribDivisorEXT(index = %u)", index);
return;
}
* VertexAttribBinding(index, index);
* VertexBindingDivisor(index, divisor);"
*/
- vertex_attrib_binding(ctx, vao, genericIndex, genericIndex);
+ _mesa_vertex_attrib_binding(ctx, vao, genericIndex, genericIndex);
vertex_binding_divisor(ctx, vao, genericIndex, divisor);
}
-unsigned
-_mesa_primitive_restart_index(const struct gl_context *ctx, GLenum ib_type)
+
+static ALWAYS_INLINE void
+vertex_array_vertex_buffer(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ GLuint bindingIndex, GLuint buffer, GLintptr offset,
+ GLsizei stride, bool no_error, const char *func)
{
- /* From the OpenGL 4.3 core specification, page 302:
- * "If both PRIMITIVE_RESTART and PRIMITIVE_RESTART_FIXED_INDEX are
- * enabled, the index value determined by PRIMITIVE_RESTART_FIXED_INDEX
- * is used."
- */
- if (ctx->Array.PrimitiveRestartFixedIndex) {
- switch (ib_type) {
- case GL_UNSIGNED_BYTE:
- return 0xff;
- case GL_UNSIGNED_SHORT:
- return 0xffff;
- case GL_UNSIGNED_INT:
- return 0xffffffff;
- default:
- assert(!"_mesa_primitive_restart_index: Invalid index buffer type.");
+ struct gl_buffer_object *vbo;
+ if (buffer ==
+ vao->BufferBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj->Name) {
+ vbo = vao->BufferBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj;
+ } else if (buffer != 0) {
+ vbo = _mesa_lookup_bufferobj(ctx, buffer);
+
+ if (!no_error && !vbo && _mesa_is_gles31(ctx)) {
+ _mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-gen name)", func);
+ return;
}
+ /* From the GL_ARB_vertex_attrib_array spec:
+ *
+ * "[Core profile only:]
+ * An INVALID_OPERATION error is generated if buffer is not zero or a
+ * name returned from a previous call to GenBuffers, or if such a name
+ * has since been deleted with DeleteBuffers.
+ *
+ * Otherwise, we fall back to the same compat profile behavior as other
+ * object references (automatically gen it).
+ */
+ if (!_mesa_handle_bind_buffer_gen(ctx, buffer, &vbo, func))
+ return;
+ } else {
+ /* The ARB_vertex_attrib_binding spec says:
+ *
+ * "If <buffer> is zero, any buffer object attached to this
+ * bindpoint is detached."
+ */
+ vbo = ctx->Shared->NullBufferObj;
}
- return ctx->Array.RestartIndex;
+ _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex),
+ vbo, offset, stride);
}
* GL_ARB_vertex_attrib_binding
*/
static void
-vertex_array_vertex_buffer(struct gl_context *ctx,
- struct gl_vertex_array_object *vao,
- GLuint bindingIndex, GLuint buffer, GLintptr offset,
- GLsizei stride, const char *func)
+vertex_array_vertex_buffer_err(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ GLuint bindingIndex, GLuint buffer,
+ GLintptr offset, GLsizei stride,
+ const char *func)
{
- struct gl_buffer_object *vbo;
-
ASSERT_OUTSIDE_BEGIN_END(ctx);
/* The ARB_vertex_attrib_binding spec says:
return;
}
- if (((ctx->API == API_OPENGL_CORE && ctx->Version >= 44) || _mesa_is_gles31(ctx)) &&
+ if (((_mesa_is_desktop_gl(ctx) && ctx->Version >= 44) || _mesa_is_gles31(ctx)) &&
stride > ctx->Const.MaxVertexAttribStride) {
_mesa_error(ctx, GL_INVALID_VALUE, "%s(stride=%d > "
"GL_MAX_VERTEX_ATTRIB_STRIDE)", func, stride);
return;
}
- if (buffer ==
- vao->VertexBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj->Name) {
- vbo = vao->VertexBinding[VERT_ATTRIB_GENERIC(bindingIndex)].BufferObj;
- } else if (buffer != 0) {
- vbo = _mesa_lookup_bufferobj(ctx, buffer);
+ vertex_array_vertex_buffer(ctx, vao, bindingIndex, buffer, offset,
+ stride, false, func);
+}
- /* From the GL_ARB_vertex_attrib_array spec:
- *
- * "[Core profile only:]
- * An INVALID_OPERATION error is generated if buffer is not zero or a
- * name returned from a previous call to GenBuffers, or if such a name
- * has since been deleted with DeleteBuffers.
- *
- * Otherwise, we fall back to the same compat profile behavior as other
- * object references (automatically gen it).
- */
- if (!_mesa_handle_bind_buffer_gen(ctx, buffer, &vbo, func))
- return;
- } else {
- /* The ARB_vertex_attrib_binding spec says:
- *
- * "If <buffer> is zero, any buffer object attached to this
- * bindpoint is detached."
- */
- vbo = ctx->Shared->NullBufferObj;
- }
- _mesa_bind_vertex_buffer(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex),
- vbo, offset, stride);
+void GLAPIENTRY
+_mesa_BindVertexBuffer_no_error(GLuint bindingIndex, GLuint buffer,
+ GLintptr offset, GLsizei stride)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ vertex_array_vertex_buffer(ctx, ctx->Array.VAO, bindingIndex,
+ buffer, offset, stride, true,
+ "glBindVertexBuffer");
}
return;
}
- vertex_array_vertex_buffer(ctx, ctx->Array.VAO, bindingIndex,
- buffer, offset, stride, "glBindVertexBuffer");
+ vertex_array_vertex_buffer_err(ctx, ctx->Array.VAO, bindingIndex,
+ buffer, offset, stride,
+ "glBindVertexBuffer");
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayVertexBuffer_no_error(GLuint vaobj, GLuint bindingIndex,
+ GLuint buffer, GLintptr offset,
+ GLsizei stride)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj);
+ vertex_array_vertex_buffer(ctx, vao, bindingIndex, buffer, offset,
+ stride, true, "glVertexArrayVertexBuffer");
}
* if <vaobj> is not [compatibility profile: zero or] the name of an
* existing vertex array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayVertexBuffer");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glVertexArrayVertexBuffer");
if (!vao)
return;
- vertex_array_vertex_buffer(ctx, vao, bindingIndex,
- buffer, offset, stride,
- "glVertexArrayVertexBuffer");
+ vertex_array_vertex_buffer_err(ctx, vao, bindingIndex, buffer, offset,
+ stride, "glVertexArrayVertexBuffer");
}
-static void
+void GLAPIENTRY
+_mesa_VertexArrayBindVertexBufferEXT(GLuint vaobj, GLuint bindingIndex, GLuint buffer,
+ GLintptr offset, GLsizei stride)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object *vao;
+ vao = _mesa_lookup_vao_err(ctx, vaobj, true, "glVertexArrayBindVertexBufferEXT");
+ if (!vao)
+ return;
+
+ vertex_array_vertex_buffer_err(ctx, vao, bindingIndex, buffer, offset,
+ stride, "glVertexArrayBindVertexBufferEXT");
+}
+
+
+static ALWAYS_INLINE void
vertex_array_vertex_buffers(struct gl_context *ctx,
struct gl_vertex_array_object *vao,
GLuint first, GLsizei count, const GLuint *buffers,
const GLintptr *offsets, const GLsizei *strides,
- const char *func)
+ bool no_error, const char *func)
{
- GLuint i;
-
- ASSERT_OUTSIDE_BEGIN_END(ctx);
-
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_OPERATION error is generated if <first> + <count>
- * is greater than the value of MAX_VERTEX_ATTRIB_BINDINGS."
- */
- if (first + count > ctx->Const.MaxVertexAttribBindings) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "%s(first=%u + count=%d > the value of "
- "GL_MAX_VERTEX_ATTRIB_BINDINGS=%u)",
- func, first, count, ctx->Const.MaxVertexAttribBindings);
- return;
- }
+ GLint i;
if (!buffers) {
/**
* their parameters are valid and no other error occurs."
*/
- _mesa_begin_bufferobj_lookups(ctx);
+ _mesa_HashLockMutex(ctx->Shared->BufferObjects);
for (i = 0; i < count; i++) {
struct gl_buffer_object *vbo;
- /* The ARB_multi_bind spec says:
- *
- * "An INVALID_VALUE error is generated if any value in
- * <offsets> or <strides> is negative (per binding)."
- */
- if (offsets[i] < 0) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "%s(offsets[%u]=%" PRId64 " < 0)",
- func, i, (int64_t) offsets[i]);
- continue;
- }
+ if (!no_error) {
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_VALUE error is generated if any value in
+ * <offsets> or <strides> is negative (per binding)."
+ */
+ if (offsets[i] < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "%s(offsets[%u]=%" PRId64 " < 0)",
+ func, i, (int64_t) offsets[i]);
+ continue;
+ }
- if (strides[i] < 0) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "%s(strides[%u]=%d < 0)",
- func, i, strides[i]);
- continue;
- }
+ if (strides[i] < 0) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "%s(strides[%u]=%d < 0)",
+ func, i, strides[i]);
+ continue;
+ }
- if (ctx->API == API_OPENGL_CORE && ctx->Version >= 44 &&
- strides[i] > ctx->Const.MaxVertexAttribStride) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "%s(strides[%u]=%d > "
- "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, i, strides[i]);
- continue;
+ if (_mesa_is_desktop_gl(ctx) && ctx->Version >= 44 &&
+ strides[i] > ctx->Const.MaxVertexAttribStride) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "%s(strides[%u]=%d > "
+ "GL_MAX_VERTEX_ATTRIB_STRIDE)", func, i, strides[i]);
+ continue;
+ }
}
if (buffers[i]) {
struct gl_vertex_buffer_binding *binding =
- &vao->VertexBinding[VERT_ATTRIB_GENERIC(first + i)];
+ &vao->BufferBinding[VERT_ATTRIB_GENERIC(first + i)];
if (buffers[i] == binding->BufferObj->Name)
vbo = binding->BufferObj;
vbo, offsets[i], strides[i]);
}
- _mesa_end_bufferobj_lookups(ctx);
+ _mesa_HashUnlockMutex(ctx->Shared->BufferObjects);
+}
+
+
+static void
+vertex_array_vertex_buffers_err(struct gl_context *ctx,
+ struct gl_vertex_array_object *vao,
+ GLuint first, GLsizei count,
+ const GLuint *buffers, const GLintptr *offsets,
+ const GLsizei *strides, const char *func)
+{
+ ASSERT_OUTSIDE_BEGIN_END(ctx);
+
+ /* The ARB_multi_bind spec says:
+ *
+ * "An INVALID_OPERATION error is generated if <first> + <count>
+ * is greater than the value of MAX_VERTEX_ATTRIB_BINDINGS."
+ */
+ if (first + count > ctx->Const.MaxVertexAttribBindings) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(first=%u + count=%d > the value of "
+ "GL_MAX_VERTEX_ATTRIB_BINDINGS=%u)",
+ func, first, count, ctx->Const.MaxVertexAttribBindings);
+ return;
+ }
+
+ vertex_array_vertex_buffers(ctx, vao, first, count, buffers, offsets,
+ strides, false, func);
+}
+
+
+void GLAPIENTRY
+_mesa_BindVertexBuffers_no_error(GLuint first, GLsizei count,
+ const GLuint *buffers, const GLintptr *offsets,
+ const GLsizei *strides)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ vertex_array_vertex_buffers(ctx, ctx->Array.VAO, first, count,
+ buffers, offsets, strides, true,
+ "glBindVertexBuffers");
}
return;
}
- vertex_array_vertex_buffers(ctx, ctx->Array.VAO, first, count,
- buffers, offsets, strides,
- "glBindVertexBuffers");
+ vertex_array_vertex_buffers_err(ctx, ctx->Array.VAO, first, count,
+ buffers, offsets, strides,
+ "glBindVertexBuffers");
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayVertexBuffers_no_error(GLuint vaobj, GLuint first,
+ GLsizei count, const GLuint *buffers,
+ const GLintptr *offsets,
+ const GLsizei *strides)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj);
+ vertex_array_vertex_buffers(ctx, vao, first, count,
+ buffers, offsets, strides, true,
+ "glVertexArrayVertexBuffers");
}
* if <vaobj> is not [compatibility profile: zero or] the name of an
* existing vertex array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayVertexBuffers");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glVertexArrayVertexBuffers");
if (!vao)
return;
- vertex_array_vertex_buffers(ctx, vao, first, count,
- buffers, offsets, strides,
- "glVertexArrayVertexBuffers");
+ vertex_array_vertex_buffers_err(ctx, vao, first, count,
+ buffers, offsets, strides,
+ "glVertexArrayVertexBuffers");
}
vertex_attrib_format(GLuint attribIndex, GLint size, GLenum type,
GLboolean normalized, GLboolean integer,
GLboolean doubles, GLbitfield legalTypes,
- GLsizei maxSize, GLuint relativeOffset,
+ GLsizei sizeMax, GLuint relativeOffset,
const char *func)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- /* The ARB_vertex_attrib_binding spec says:
- *
- * "An INVALID_OPERATION error is generated under any of the following
- * conditions:
- * - if no vertex array object is currently bound (see section 2.10);
- * - ..."
- *
- * This error condition only applies to VertexAttribFormat and
- * VertexAttribIFormat in the extension spec, but we assume that this
- * is an oversight. In the OpenGL 4.3 (Core Profile) spec, it applies
- * to all three functions.
- */
- if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) &&
- ctx->Array.VAO == ctx->Array.DefaultVAO) {
- _mesa_error(ctx, GL_INVALID_OPERATION,
- "%s(No array object bound)", func);
- return;
- }
+ GLenum format = get_array_format(ctx, sizeMax, &size);
+
+ if (!_mesa_is_no_error_enabled(ctx)) {
+ /* The ARB_vertex_attrib_binding spec says:
+ *
+ * "An INVALID_OPERATION error is generated under any of the
+ * following conditions:
+ * - if no vertex array object is currently bound (see section
+ * 2.10);
+ * - ..."
+ *
+ * This error condition only applies to VertexAttribFormat and
+ * VertexAttribIFormat in the extension spec, but we assume that this
+ * is an oversight. In the OpenGL 4.3 (Core Profile) spec, it applies
+ * to all three functions.
+ */
+ if ((ctx->API == API_OPENGL_CORE || _mesa_is_gles31(ctx)) &&
+ ctx->Array.VAO == ctx->Array.DefaultVAO) {
+ _mesa_error(ctx, GL_INVALID_OPERATION,
+ "%s(No array object bound)", func);
+ return;
+ }
- /* The ARB_vertex_attrib_binding spec says:
- *
- * "The error INVALID_VALUE is generated if index is greater than or equal
- * to the value of MAX_VERTEX_ATTRIBS."
- */
- if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "%s(attribindex=%u > "
- "GL_MAX_VERTEX_ATTRIBS)",
- func, attribIndex);
- return;
- }
+ /* The ARB_vertex_attrib_binding spec says:
+ *
+ * "The error INVALID_VALUE is generated if index is greater than or
+ * equal to the value of MAX_VERTEX_ATTRIBS."
+ */
+ if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "%s(attribindex=%u > "
+ "GL_MAX_VERTEX_ATTRIBS)",
+ func, attribIndex);
+ return;
+ }
- FLUSH_VERTICES(ctx, 0);
+ if (!validate_array_format(ctx, func, ctx->Array.VAO,
+ VERT_ATTRIB_GENERIC(attribIndex),
+ legalTypes, 1, sizeMax, size, type,
+ normalized, integer, doubles, relativeOffset,
+ format)) {
+ return;
+ }
+ }
- update_array_format(ctx, func, ctx->Array.VAO,
- VERT_ATTRIB_GENERIC(attribIndex),
- legalTypes, 1, maxSize, size, type,
- normalized, integer, doubles, relativeOffset);
+ _mesa_update_array_format(ctx, ctx->Array.VAO,
+ VERT_ATTRIB_GENERIC(attribIndex), size, type,
+ format, normalized, integer, doubles,
+ relativeOffset);
}
static void
-vertex_array_attrib_format(GLuint vaobj, GLuint attribIndex, GLint size,
- GLenum type, GLboolean normalized,
+vertex_array_attrib_format(GLuint vaobj, bool isExtDsa, GLuint attribIndex,
+ GLint size, GLenum type, GLboolean normalized,
GLboolean integer, GLboolean doubles,
- GLbitfield legalTypes, GLsizei maxSize,
+ GLbitfield legalTypes, GLsizei sizeMax,
GLuint relativeOffset, const char *func)
{
GET_CURRENT_CONTEXT(ctx);
ASSERT_OUTSIDE_BEGIN_END(ctx);
- /* The ARB_direct_state_access spec says:
- *
- * "An INVALID_OPERATION error is generated by VertexArrayAttrib*Format
- * if <vaobj> is not [compatibility profile: zero or] the name of an
- * existing vertex array object."
- */
- vao = _mesa_lookup_vao_err(ctx, vaobj, func);
- if (!vao)
- return;
+ GLenum format = get_array_format(ctx, sizeMax, &size);
- /* The ARB_vertex_attrib_binding spec says:
- *
- * "The error INVALID_VALUE is generated if index is greater than or equal
- * to the value of MAX_VERTEX_ATTRIBS."
- */
- if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
- _mesa_error(ctx, GL_INVALID_VALUE,
- "%s(attribindex=%u > GL_MAX_VERTEX_ATTRIBS)",
- func, attribIndex);
- return;
- }
+ if (_mesa_is_no_error_enabled(ctx)) {
+ vao = _mesa_lookup_vao(ctx, vaobj);
+ if (!vao)
+ return;
+ } else {
+ vao = _mesa_lookup_vao_err(ctx, vaobj, isExtDsa, func);
+ if (!vao)
+ return;
+
+ /* The ARB_vertex_attrib_binding spec says:
+ *
+ * "The error INVALID_VALUE is generated if index is greater than or
+ * equal to the value of MAX_VERTEX_ATTRIBS."
+ */
+ if (attribIndex >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE,
+ "%s(attribindex=%u > GL_MAX_VERTEX_ATTRIBS)",
+ func, attribIndex);
+ return;
+ }
- FLUSH_VERTICES(ctx, 0);
+ if (!validate_array_format(ctx, func, vao,
+ VERT_ATTRIB_GENERIC(attribIndex),
+ legalTypes, 1, sizeMax, size, type,
+ normalized, integer, doubles, relativeOffset,
+ format)) {
+ return;
+ }
+ }
- update_array_format(ctx, func, vao,
- VERT_ATTRIB_GENERIC(attribIndex),
- legalTypes, 1, maxSize, size, type, normalized,
- integer, doubles, relativeOffset);
+ _mesa_update_array_format(ctx, vao, VERT_ATTRIB_GENERIC(attribIndex), size,
+ type, format, normalized, integer, doubles,
+ relativeOffset);
}
GLenum type, GLboolean normalized,
GLuint relativeOffset)
{
- vertex_array_attrib_format(vaobj, attribIndex, size, type, normalized,
+ vertex_array_attrib_format(vaobj, false, attribIndex, size, type, normalized,
GL_FALSE, GL_FALSE, ATTRIB_FORMAT_TYPES_MASK,
BGRA_OR_4, relativeOffset,
"glVertexArrayAttribFormat");
}
+void GLAPIENTRY
+_mesa_VertexArrayVertexAttribFormatEXT(GLuint vaobj, GLuint attribIndex, GLint size,
+ GLenum type, GLboolean normalized,
+ GLuint relativeOffset)
+{
+ vertex_array_attrib_format(vaobj, true, attribIndex, size, type, normalized,
+ GL_FALSE, GL_FALSE, ATTRIB_FORMAT_TYPES_MASK,
+ BGRA_OR_4, relativeOffset,
+ "glVertexArrayVertexAttribFormatEXT");
+}
+
+
void GLAPIENTRY
_mesa_VertexArrayAttribIFormat(GLuint vaobj, GLuint attribIndex,
GLint size, GLenum type,
GLuint relativeOffset)
{
- vertex_array_attrib_format(vaobj, attribIndex, size, type, GL_FALSE,
+ vertex_array_attrib_format(vaobj, false, attribIndex, size, type, GL_FALSE,
GL_TRUE, GL_FALSE, ATTRIB_IFORMAT_TYPES_MASK,
4, relativeOffset,
"glVertexArrayAttribIFormat");
}
+void GLAPIENTRY
+_mesa_VertexArrayVertexAttribIFormatEXT(GLuint vaobj, GLuint attribIndex,
+ GLint size, GLenum type,
+ GLuint relativeOffset)
+{
+ vertex_array_attrib_format(vaobj, true, attribIndex, size, type, GL_FALSE,
+ GL_TRUE, GL_FALSE, ATTRIB_IFORMAT_TYPES_MASK,
+ 4, relativeOffset,
+ "glVertexArrayVertexAttribIFormatEXT");
+}
+
+
void GLAPIENTRY
_mesa_VertexArrayAttribLFormat(GLuint vaobj, GLuint attribIndex,
GLint size, GLenum type,
GLuint relativeOffset)
{
- vertex_array_attrib_format(vaobj, attribIndex, size, type, GL_FALSE,
+ vertex_array_attrib_format(vaobj, false, attribIndex, size, type, GL_FALSE,
GL_FALSE, GL_TRUE, ATTRIB_LFORMAT_TYPES_MASK,
4, relativeOffset,
"glVertexArrayAttribLFormat");
}
+void GLAPIENTRY
+_mesa_VertexArrayVertexAttribLFormatEXT(GLuint vaobj, GLuint attribIndex,
+ GLint size, GLenum type,
+ GLuint relativeOffset)
+{
+ vertex_array_attrib_format(vaobj, true, attribIndex, size, type, GL_FALSE,
+ GL_FALSE, GL_TRUE, ATTRIB_LFORMAT_TYPES_MASK,
+ 4, relativeOffset,
+ "glVertexArrayVertexAttribLFormatEXT");
+}
+
+
static void
vertex_array_attrib_binding(struct gl_context *ctx,
struct gl_vertex_array_object *vao,
assert(VERT_ATTRIB_GENERIC(attribIndex) < ARRAY_SIZE(vao->VertexAttrib));
- vertex_attrib_binding(ctx, vao,
- VERT_ATTRIB_GENERIC(attribIndex),
- VERT_ATTRIB_GENERIC(bindingIndex));
+ _mesa_vertex_attrib_binding(ctx, vao,
+ VERT_ATTRIB_GENERIC(attribIndex),
+ VERT_ATTRIB_GENERIC(bindingIndex));
+}
+
+
+void GLAPIENTRY
+_mesa_VertexAttribBinding_no_error(GLuint attribIndex, GLuint bindingIndex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ _mesa_vertex_attrib_binding(ctx, ctx->Array.VAO,
+ VERT_ATTRIB_GENERIC(attribIndex),
+ VERT_ATTRIB_GENERIC(bindingIndex));
}
}
+void GLAPIENTRY
+_mesa_VertexArrayAttribBinding_no_error(GLuint vaobj, GLuint attribIndex,
+ GLuint bindingIndex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj);
+ _mesa_vertex_attrib_binding(ctx, vao,
+ VERT_ATTRIB_GENERIC(attribIndex),
+ VERT_ATTRIB_GENERIC(bindingIndex));
+}
+
+
void GLAPIENTRY
_mesa_VertexArrayAttribBinding(GLuint vaobj, GLuint attribIndex, GLuint bindingIndex)
{
* if <vaobj> is not [compatibility profile: zero or] the name of an
* existing vertex array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayAttribBinding");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glVertexArrayAttribBinding");
if (!vao)
return;
}
+void GLAPIENTRY
+_mesa_VertexArrayVertexAttribBindingEXT(GLuint vaobj, GLuint attribIndex, GLuint bindingIndex)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object *vao;
+ vao = _mesa_lookup_vao_err(ctx, vaobj, true, "glVertexArrayVertexAttribBindingEXT");
+ if (!vao)
+ return;
+
+ vertex_array_attrib_binding(ctx, vao, attribIndex, bindingIndex,
+ "glVertexArrayVertexAttribBindingEXT");
+}
+
+
static void
vertex_array_binding_divisor(struct gl_context *ctx,
struct gl_vertex_array_object *vao,
}
+void GLAPIENTRY
+_mesa_VertexBindingDivisor_no_error(GLuint bindingIndex, GLuint divisor)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ vertex_binding_divisor(ctx, ctx->Array.VAO,
+ VERT_ATTRIB_GENERIC(bindingIndex), divisor);
+}
+
+
void GLAPIENTRY
_mesa_VertexBindingDivisor(GLuint bindingIndex, GLuint divisor)
{
}
+void GLAPIENTRY
+_mesa_VertexArrayBindingDivisor_no_error(GLuint vaobj, GLuint bindingIndex,
+ GLuint divisor)
+{
+ GET_CURRENT_CONTEXT(ctx);
+
+ struct gl_vertex_array_object *vao = _mesa_lookup_vao(ctx, vaobj);
+ vertex_binding_divisor(ctx, vao, VERT_ATTRIB_GENERIC(bindingIndex), divisor);
+}
+
+
void GLAPIENTRY
_mesa_VertexArrayBindingDivisor(GLuint vaobj, GLuint bindingIndex,
GLuint divisor)
* if <vaobj> is not [compatibility profile: zero or] the name of an
* existing vertex array object."
*/
- vao = _mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayBindingDivisor");
+ vao = _mesa_lookup_vao_err(ctx, vaobj, false, "glVertexArrayBindingDivisor");
if (!vao)
return;
}
-/**
- * Copy one client vertex array to another.
- */
-void
-_mesa_copy_client_array(struct gl_context *ctx,
- struct gl_client_array *dst,
- struct gl_client_array *src)
-{
- dst->Size = src->Size;
- dst->Type = src->Type;
- dst->Format = src->Format;
- dst->Stride = src->Stride;
- dst->StrideB = src->StrideB;
- dst->Ptr = src->Ptr;
- dst->Enabled = src->Enabled;
- dst->Normalized = src->Normalized;
- dst->Integer = src->Integer;
- dst->Doubles = src->Doubles;
- dst->InstanceDivisor = src->InstanceDivisor;
- dst->_ElementSize = src->_ElementSize;
- _mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);
+void GLAPIENTRY
+_mesa_VertexArrayVertexBindingDivisorEXT(GLuint vaobj, GLuint bindingIndex,
+ GLuint divisor)
+{
+ struct gl_vertex_array_object *vao;
+ GET_CURRENT_CONTEXT(ctx);
+
+ /* The ARB_direct_state_access specification says:
+ *
+ * "An INVALID_OPERATION error is generated by VertexArrayBindingDivisor
+ * if <vaobj> is not [compatibility profile: zero or] the name of an
+ * existing vertex array object."
+ */
+ vao = _mesa_lookup_vao_err(ctx, vaobj, true, "glVertexArrayVertexBindingDivisorEXT");
+ if (!vao)
+ return;
+
+ vertex_array_binding_divisor(ctx, vao, bindingIndex, divisor,
+ "glVertexArrayVertexBindingDivisorEXT");
}
+
void
_mesa_copy_vertex_attrib_array(struct gl_context *ctx,
- struct gl_vertex_attrib_array *dst,
- const struct gl_vertex_attrib_array *src)
+ struct gl_array_attributes *dst,
+ const struct gl_array_attributes *src)
{
- dst->Size = src->Size;
- dst->Type = src->Type;
- dst->Format = src->Format;
- dst->VertexBinding = src->VertexBinding;
+ dst->Ptr = src->Ptr;
dst->RelativeOffset = src->RelativeOffset;
dst->Format = src->Format;
- dst->Integer = src->Integer;
- dst->Doubles = src->Doubles;
- dst->Normalized = src->Normalized;
- dst->Ptr = src->Ptr;
- dst->Enabled = src->Enabled;
- dst->_ElementSize = src->_ElementSize;
+ dst->Stride = src->Stride;
+ dst->BufferBindingIndex = src->BufferBindingIndex;
+ dst->_EffBufferBindingIndex = src->_EffBufferBindingIndex;
+ dst->_EffRelativeOffset = src->_EffRelativeOffset;
}
void
dst->Stride = src->Stride;
dst->InstanceDivisor = src->InstanceDivisor;
dst->_BoundArrays = src->_BoundArrays;
+ dst->_EffBoundArrays = src->_EffBoundArrays;
+ dst->_EffOffset = src->_EffOffset;
_mesa_reference_buffer_object(ctx, &dst->BufferObj, src->BufferObj);
}
-/**
- * Print vertex array's fields.
- */
-static void
-print_array(const char *name, GLint index, const struct gl_client_array *array)
-{
- if (index >= 0)
- fprintf(stderr, " %s[%d]: ", name, index);
- else
- fprintf(stderr, " %s: ", name);
- fprintf(stderr, "Ptr=%p, Type=%s, Size=%d, ElemSize=%u, Stride=%d, Buffer=%u(Size %lu)\n",
- array->Ptr, _mesa_enum_to_string(array->Type), array->Size,
- array->_ElementSize, array->StrideB, array->BufferObj->Name,
- (unsigned long) array->BufferObj->Size);
-}
-
-
/**
* Print current vertex object/array info. For debug.
*/
void
_mesa_print_arrays(struct gl_context *ctx)
{
- struct gl_vertex_array_object *vao = ctx->Array.VAO;
- GLuint i;
+ const struct gl_vertex_array_object *vao = ctx->Array.VAO;
- printf("Array Object %u\n", vao->Name);
- if (vao->_VertexAttrib[VERT_ATTRIB_POS].Enabled)
- print_array("Vertex", -1, &vao->_VertexAttrib[VERT_ATTRIB_POS]);
- if (vao->_VertexAttrib[VERT_ATTRIB_NORMAL].Enabled)
- print_array("Normal", -1, &vao->_VertexAttrib[VERT_ATTRIB_NORMAL]);
- if (vao->_VertexAttrib[VERT_ATTRIB_COLOR0].Enabled)
- print_array("Color", -1, &vao->_VertexAttrib[VERT_ATTRIB_COLOR0]);
- for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++)
- if (vao->_VertexAttrib[VERT_ATTRIB_TEX(i)].Enabled)
- print_array("TexCoord", i, &vao->_VertexAttrib[VERT_ATTRIB_TEX(i)]);
- for (i = 0; i < VERT_ATTRIB_GENERIC_MAX; i++)
- if (vao->_VertexAttrib[VERT_ATTRIB_GENERIC(i)].Enabled)
- print_array("Attrib", i, &vao->_VertexAttrib[VERT_ATTRIB_GENERIC(i)]);
+ fprintf(stderr, "Array Object %u\n", vao->Name);
+
+ GLbitfield mask = vao->Enabled;
+ while (mask) {
+ const gl_vert_attrib i = u_bit_scan(&mask);
+ const struct gl_array_attributes *array = &vao->VertexAttrib[i];
+
+ const struct gl_vertex_buffer_binding *binding =
+ &vao->BufferBinding[array->BufferBindingIndex];
+ const struct gl_buffer_object *bo = binding->BufferObj;
+
+ fprintf(stderr, " %s: Ptr=%p, Type=%s, Size=%d, ElemSize=%u, "
+ "Stride=%d, Buffer=%u(Size %lu)\n",
+ gl_vert_attrib_name((gl_vert_attrib)i),
+ array->Ptr, _mesa_enum_to_string(array->Format.Type),
+ array->Format.Size,
+ array->Format._ElementSize, binding->Stride, bo->Name,
+ (unsigned long) bo->Size);
+ }
}
{
ctx->Array.DefaultVAO = _mesa_new_vao(ctx, 0);
_mesa_reference_vao(ctx, &ctx->Array.VAO, ctx->Array.DefaultVAO);
+ ctx->Array._EmptyVAO = _mesa_new_vao(ctx, ~0u);
+ _mesa_reference_vao(ctx, &ctx->Array._DrawVAO, ctx->Array._EmptyVAO);
ctx->Array.ActiveTexture = 0; /* GL_ARB_multitexture */
ctx->Array.Objects = _mesa_NewHashTable();
_mesa_HashDeleteAll(ctx->Array.Objects, delete_arrayobj_cb, ctx);
_mesa_DeleteHashTable(ctx->Array.Objects);
}
+
+void GLAPIENTRY
+_mesa_GetVertexArrayIntegervEXT(GLuint vaobj, GLenum pname, GLint *param)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object* vao;
+ void* ptr;
+
+ vao = _mesa_lookup_vao_err(ctx, vaobj, true,
+ "glGetVertexArrayIntegervEXT");
+ if (!vao)
+ return;
+
+ /* The EXT_direct_state_access spec says:
+ *
+ * "For GetVertexArrayIntegervEXT, pname must be one of the "Get value" tokens
+ * in tables 6.6, 6.7, 6.8, and 6.9 that use GetIntegerv, IsEnabled, or
+ * GetPointerv for their "Get command" (so excluding the VERTEX_ATTRIB_*
+ * tokens)."
+ */
+ switch (pname) {
+ /* Tokens using GetIntegerv */
+ case GL_CLIENT_ACTIVE_TEXTURE:
+ *param = GL_TEXTURE0_ARB + ctx->Array.ActiveTexture;
+ break;
+ case GL_VERTEX_ARRAY_SIZE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_POS].Format.Size;
+ break;
+ case GL_VERTEX_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_POS].Format.Type;
+ break;
+ case GL_VERTEX_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_POS].Stride;
+ break;
+ case GL_VERTEX_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_POS].BufferObj->Name;
+ break;
+ case GL_COLOR_ARRAY_SIZE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR0].Format.Size;
+ break;
+ case GL_COLOR_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR0].Format.Type;
+ break;
+ case GL_COLOR_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR0].Stride;
+ break;
+ case GL_COLOR_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_COLOR0].BufferObj->Name;
+ break;
+ case GL_EDGE_FLAG_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_EDGEFLAG].Stride;
+ break;
+ case GL_EDGE_FLAG_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_EDGEFLAG].BufferObj->Name;
+ break;
+ case GL_INDEX_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Format.Type;
+ break;
+ case GL_INDEX_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR_INDEX].Stride;
+ break;
+ case GL_INDEX_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_COLOR_INDEX].BufferObj->Name;
+ break;
+ case GL_NORMAL_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_NORMAL].Format.Type;
+ break;
+ case GL_NORMAL_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_NORMAL].Stride;
+ break;
+ case GL_NORMAL_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_NORMAL].BufferObj->Name;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_SIZE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].Format.Size;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].Format.Type;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].Stride;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_TEX(ctx->Array.ActiveTexture)].BufferObj->Name;
+ break;
+ case GL_FOG_COORD_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_FOG].Format.Type;
+ break;
+ case GL_FOG_COORD_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_FOG].Stride;
+ break;
+ case GL_FOG_COORD_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_FOG].BufferObj->Name;
+ break;
+ case GL_SECONDARY_COLOR_ARRAY_SIZE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR1].Format.Size;
+ break;
+ case GL_SECONDARY_COLOR_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR1].Format.Type;
+ break;
+ case GL_SECONDARY_COLOR_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_COLOR1].Stride;
+ break;
+ case GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_COLOR1].BufferObj->Name;
+ break;
+
+ /* Tokens using IsEnabled */
+ case GL_VERTEX_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_POS);
+ break;
+ case GL_COLOR_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_COLOR0);
+ break;
+ case GL_EDGE_FLAG_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_EDGEFLAG);
+ break;
+ case GL_INDEX_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_COLOR_INDEX);
+ break;
+ case GL_NORMAL_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_NORMAL);
+ break;
+ case GL_TEXTURE_COORD_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_TEX(ctx->Array.ActiveTexture));
+ break;
+ case GL_FOG_COORD_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_FOG);
+ break;
+ case GL_SECONDARY_COLOR_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_COLOR1);
+ break;
+
+ /* Tokens using GetPointerv */
+ case GL_VERTEX_ARRAY_POINTER:
+ case GL_COLOR_ARRAY_POINTER:
+ case GL_EDGE_FLAG_ARRAY_POINTER:
+ case GL_INDEX_ARRAY_POINTER:
+ case GL_NORMAL_ARRAY_POINTER:
+ case GL_TEXTURE_COORD_ARRAY_POINTER:
+ case GL_FOG_COORD_ARRAY_POINTER:
+ case GL_SECONDARY_COLOR_ARRAY_POINTER:
+ _get_vao_pointerv(pname, vao, &ptr, "glGetVertexArrayIntegervEXT");
+ *param = (int) ((intptr_t) ptr & 0xFFFFFFFF);
+ break;
+
+ default:
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexArrayIntegervEXT(pname)");
+ }
+}
+
+void GLAPIENTRY
+_mesa_GetVertexArrayPointervEXT(GLuint vaobj, GLenum pname, GLvoid** param)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object* vao;
+
+ vao = _mesa_lookup_vao_err(ctx, vaobj, true,
+ "glGetVertexArrayPointervEXT");
+ if (!vao)
+ return;
+
+ /* The EXT_direct_state_access spec says:
+ *
+ * "For GetVertexArrayPointervEXT, pname must be a *_ARRAY_POINTER token from
+ * tables 6.6, 6.7, and 6.8 excluding VERTEX_ATTRIB_ARRAY_POINT."
+ */
+ switch (pname) {
+ case GL_VERTEX_ARRAY_POINTER:
+ case GL_COLOR_ARRAY_POINTER:
+ case GL_EDGE_FLAG_ARRAY_POINTER:
+ case GL_INDEX_ARRAY_POINTER:
+ case GL_NORMAL_ARRAY_POINTER:
+ case GL_TEXTURE_COORD_ARRAY_POINTER:
+ case GL_FOG_COORD_ARRAY_POINTER:
+ case GL_SECONDARY_COLOR_ARRAY_POINTER:
+ break;
+
+ default:
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexArrayPointervEXT(pname)");
+ return;
+ }
+
+ /* pname has been validated, we can now use the helper function */
+ _get_vao_pointerv(pname, vao, param, "glGetVertexArrayPointervEXT");
+}
+
+void GLAPIENTRY
+_mesa_GetVertexArrayIntegeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object* vao;
+
+ vao = _mesa_lookup_vao_err(ctx, vaobj, true,
+ "glGetVertexArrayIntegeri_vEXT");
+ if (!vao)
+ return;
+
+
+ /* The EXT_direct_state_access spec says:
+ *
+ * "For GetVertexArrayIntegeri_vEXT, pname must be one of the
+ * "Get value" tokens in tables 6.8 and 6.9 that use GetVertexAttribiv
+ * or GetVertexAttribPointerv (so allowing only the VERTEX_ATTRIB_*
+ * tokens) or a token of the form TEXTURE_COORD_ARRAY (the enable) or
+ * TEXTURE_COORD_ARRAY_*; index identifies the vertex attribute
+ * array to query or texture coordinate set index respectively."
+ */
+
+ switch (pname) {
+ case GL_TEXTURE_COORD_ARRAY:
+ *param = !!(vao->Enabled & VERT_BIT_TEX(index));
+ break;
+ case GL_TEXTURE_COORD_ARRAY_SIZE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_TEX(index)].Format.Size;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_TYPE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_TEX(index)].Format.Type;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_STRIDE:
+ *param = vao->VertexAttrib[VERT_ATTRIB_TEX(index)].Stride;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:
+ *param = vao->BufferBinding[VERT_ATTRIB_TEX(index)].BufferObj->Name;
+ break;
+ default:
+ *param = get_vertex_array_attrib(ctx, vao, index, pname, "glGetVertexArrayIntegeri_vEXT");
+ }
+}
+
+void GLAPIENTRY
+_mesa_GetVertexArrayPointeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, GLvoid** param)
+{
+ GET_CURRENT_CONTEXT(ctx);
+ struct gl_vertex_array_object* vao;
+
+ vao = _mesa_lookup_vao_err(ctx, vaobj, true,
+ "glGetVertexArrayPointeri_vEXT");
+ if (!vao)
+ return;
+
+ if (index >= ctx->Const.Program[MESA_SHADER_VERTEX].MaxAttribs) {
+ _mesa_error(ctx, GL_INVALID_VALUE, "glGetVertexArrayPointeri_vEXT(index)");
+ return;
+ }
+
+ /* The EXT_direct_state_access spec says:
+ *
+ * "For GetVertexArrayPointeri_vEXT, pname must be VERTEX_ATTRIB_ARRAY_POINTER
+ * or TEXTURE_COORD_ARRAY_POINTER with the index parameter indicating the vertex
+ * attribute or texture coordindate set index."
+ */
+ switch(pname) {
+ case GL_VERTEX_ATTRIB_ARRAY_POINTER:
+ *param = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_GENERIC(index)].Ptr;
+ break;
+ case GL_TEXTURE_COORD_ARRAY_POINTER:
+ *param = (GLvoid *) vao->VertexAttrib[VERT_ATTRIB_TEX(index)].Ptr;
+ break;
+ default:
+ _mesa_error(ctx, GL_INVALID_ENUM, "glGetVertexArrayPointeri_vEXT(pname)");
+ }
+}