#include "context.h"
#include "enable.h"
#include "enums.h"
+#include "glformats.h"
#include "hash.h"
#include "image.h"
#include "macros.h"
if (ctx->API != API_OPENGL_COMPAT)
return;
/* The generic0 attribute superseeds the position attribute */
- const GLbitfield enabled = vao->_Enabled;
+ const GLbitfield enabled = vao->Enabled;
if (enabled & VERT_BIT_GENERIC0)
vao->_AttributeMapMode = ATTRIBUTE_MAP_MODE_GENERIC0;
else if (enabled & VERT_BIT_POS)
array->BufferBindingIndex = bindingIndex;
- vao->NewArrays |= vao->_Enabled & array_bit;
- if (vao == ctx->Array.VAO)
- ctx->NewState |= _NEW_ARRAY;
+ vao->NewArrays |= vao->Enabled & array_bit;
}
}
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 |= vao->_Enabled & binding->_BoundArrays;
- if (vao == ctx->Array.VAO)
- ctx->NewState |= _NEW_ARRAY;
+ vao->NewArrays |= vao->Enabled & binding->_BoundArrays;
}
}
if (binding->InstanceDivisor != divisor) {
binding->InstanceDivisor = divisor;
- vao->NewArrays |= vao->_Enabled & binding->_BoundArrays;
- if (vao == ctx->Array.VAO)
- ctx->NewState |= _NEW_ARRAY;
+ vao->NewArrays |= vao->Enabled & binding->_BoundArrays;
}
}
+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));
+}
+
+
/**
* Examine the API profile and extensions to determine which types are legal
* for vertex arrays. This is called once from update_array_format().
GLuint relativeOffset)
{
struct gl_array_attributes *const array = &vao->VertexAttrib[attrib];
- GLint elementSize;
assert(!vao->SharedAndImmutable);
assert(size <= 4);
- 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 |= vao->_Enabled & VERT_BIT(attrib);
- if (vao == ctx->Array.VAO)
- ctx->NewState |= _NEW_ARRAY;
+ vao->NewArrays |= vao->Enabled & VERT_BIT(attrib);
}
/**
* 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
*/
static void
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_array_object *vao = ctx->Array.VAO;
-
/* Page 407 (page 423 of the PDF) of the OpenGL 3.0 spec says:
*
* "Client vertex arrays - all vertex array attribute pointers must
* 2.9.6), and the pointer argument is not NULL."
*/
if (ptr != NULL && vao != ctx->Array.DefaultVAO &&
- !_mesa_is_bufferobj(ctx->Array.ArrayBufferObj)) {
+ !_mesa_is_bufferobj(obj)) {
_mesa_error(ctx, GL_INVALID_OPERATION, "%s(non-VBO array)", func);
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,
- struct gl_vertex_array_object *vao)
+ GLboolean doubles, GLenum format, const GLvoid *ptr)
{
- validate_array(ctx, func, attrib, legalTypes, sizeMin, sizeMax, size,
- type, stride, normalized, integer, doubles, 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,
/**
* 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)
*/
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)
{
- struct gl_vertex_array_object *vao = ctx->Array.VAO;
-
_mesa_update_array_format(ctx, vao, attrib, size, type, format,
normalized, integer, doubles, 0);
* 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));
+ assert((vao->NewArrays | ~vao->Enabled) & VERT_BIT(attrib));
array->Ptr = ptr;
/* Update the vertex buffer binding */
- GLsizei effectiveStride = stride != 0 ? stride : array->_ElementSize;
+ GLsizei effectiveStride = stride != 0 ?
+ stride : array->Format._ElementSize;
_mesa_bind_vertex_buffer(ctx, vao, attrib,
- ctx->Array.ArrayBufferObj, (GLintptr) ptr,
+ obj, (GLintptr) ptr,
effectiveStride);
}
{
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_POS, GL_RGBA, 4, size, type, stride,
+ 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);
}
UNSIGNED_INT_2_10_10_10_REV_BIT |
INT_2_10_10_10_REV_BIT);
- if (!validate_array_and_format(ctx, "glVertexPointer", VERT_ATTRIB_POS,
- legalTypes, 2, 4, size, type, stride,
- GL_FALSE, GL_FALSE, GL_FALSE, format,
- ptr, ctx->Array.VAO))
+ 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, VERT_ATTRIB_POS, format, 4, size, type, stride,
+ 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_VertexArrayVertexOffsetEXT(GLuint vaobj, GLuint buffer, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_NormalPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr )
{
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_NORMAL, GL_RGBA, 3, 3, type, stride, GL_TRUE,
+ 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);
}
INT_2_10_10_10_REV_BIT);
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, ctx->Array.VAO))
+ GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_NORMAL, format, 3, 3, type, stride, GL_TRUE,
+ 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_VertexArrayNormalOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type,
+ GLsizei stride, GLintptr offset)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_ColorPointer_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, VERT_ATTRIB_COLOR0, format, 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);
}
INT_2_10_10_10_REV_BIT);
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,
- ctx->Array.VAO))
+ GL_FALSE, GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_COLOR0, format, 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_VertexArrayColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size,
+ GLenum type, GLsizei stride, GLintptr offset)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_FogCoordPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr)
{
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_FOG, GL_RGBA, 1, 1, type, stride, GL_FALSE,
+ 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);
}
const GLbitfield legalTypes = (HALF_BIT | FLOAT_BIT | DOUBLE_BIT);
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, ctx->Array.VAO))
+ GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_FOG, format, 1, 1, type, stride, GL_FALSE,
+ 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)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_IndexPointer_no_error(GLenum type, GLsizei stride, const GLvoid *ptr)
{
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_COLOR_INDEX, GL_RGBA, 1, 1, type, stride,
+ 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);
}
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, ctx->Array.VAO))
+ GL_FALSE, GL_FALSE, GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_COLOR_INDEX, format, 1, 1, type, stride,
+ 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)
+{
+
+}
+
+
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, VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type,
+ 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);
}
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,
- ctx->Array.VAO))
+ GL_TRUE, GL_FALSE, GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_COLOR1, format, BGRA_OR_4, size, type,
+ 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)
+{
+
+}
+
+
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, VERT_ATTRIB_TEX(unit), GL_RGBA, 4, size, type,
+ 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);
}
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,
- ctx->Array.VAO))
+ GL_FALSE, GL_FALSE, GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_TEX(unit), format, 4, size, type,
+ 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)
+{
+
+}
+
+
+void GLAPIENTRY
+_mesa_VertexArrayMultiTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum texunit,
+ GLint size, GLenum type, GLsizei stride,
+ GLintptr offset)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_EdgeFlagPointer_no_error(GLsizei stride, const GLvoid *ptr)
{
const GLboolean integer = GL_FALSE;
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_EDGEFLAG, GL_RGBA, 1, 1, GL_UNSIGNED_BYTE,
+ 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);
}
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,
- ctx->Array.VAO))
+ GL_FALSE, integer, GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_EDGEFLAG, format, 1, 1, GL_UNSIGNED_BYTE,
+ 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)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_PointSizePointerOES_no_error(GLenum type, GLsizei stride,
const GLvoid *ptr)
{
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_POINT_SIZE, GL_RGBA, 1, 1, type, stride,
+ 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);
}
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, ctx->Array.VAO))
+ GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_POINT_SIZE, format, 1, 1, type, stride,
+ 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);
}
GET_CURRENT_CONTEXT(ctx);
GLenum format = get_array_format(ctx, BGRA_OR_4, &size);
- update_array(ctx, VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4,
+ 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);
}
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, ctx->Array.VAO))
+ normalized, GL_FALSE, GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_GENERIC(index), format, BGRA_OR_4,
+ 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)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_VertexAttribIPointer_no_error(GLuint index, GLint size, GLenum type,
GLsizei stride, const GLvoid *ptr)
const GLboolean integer = GL_TRUE;
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type,
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type,
stride, normalized, integer, GL_FALSE, ptr);
}
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, ctx->Array.VAO))
+ normalized, integer, GL_FALSE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_GENERIC(index), format, 4, size, type,
+ update_array(ctx, ctx->Array.VAO, ctx->Array.ArrayBufferObj,
+ VERT_ATTRIB_GENERIC(index), format, 4, size, type,
stride, normalized, integer, GL_FALSE, ptr);
}
{
GET_CURRENT_CONTEXT(ctx);
- update_array(ctx, VERT_ATTRIB_GENERIC(index), GL_RGBA, 4, size, type,
+ 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)
+{
+
+}
+
+
void GLAPIENTRY
_mesa_VertexAttribLPointer(GLuint index, GLint size, GLenum type,
GLsizei stride, const GLvoid *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, ctx->Array.VAO))
+ GL_FALSE, GL_FALSE, GL_TRUE, format, ptr))
return;
- update_array(ctx, VERT_ATTRIB_GENERIC(index), format, 4, size, type,
+ 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,
- gl_vert_attrib 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 */
- vao->VertexAttrib[attrib].Enabled = GL_TRUE;
- const GLbitfield array_bit = VERT_BIT(attrib);
- vao->_Enabled |= array_bit;
- vao->NewArrays |= array_bit;
-
- if (vao == ctx->Array.VAO)
- ctx->NewState |= _NEW_ARRAY;
+ vao->Enabled |= attrib_bits;
+ vao->NewArrays |= attrib_bits;
/* Update the map mode if needed */
- if (array_bit & (VERT_BIT_POS|VERT_BIT_GENERIC0))
+ if (attrib_bits & (VERT_BIT_POS|VERT_BIT_GENERIC0))
update_attribute_map_mode(ctx, vao);
}
}
void
-_mesa_disable_vertex_array_attrib(struct gl_context *ctx,
- struct gl_vertex_array_object *vao,
- gl_vert_attrib attrib)
+_mesa_disable_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 enabled */
+ attrib_bits &= vao->Enabled;
+ if (attrib_bits) {
/* was enabled, now being disabled */
- vao->VertexAttrib[attrib].Enabled = GL_FALSE;
- const GLbitfield array_bit = VERT_BIT(attrib);
- vao->_Enabled &= ~array_bit;
- vao->NewArrays |= array_bit;
-
- if (vao == ctx->Array.VAO)
- ctx->NewState |= _NEW_ARRAY;
+ vao->Enabled &= ~attrib_bits;
+ vao->NewArrays |= attrib_bits;
/* Update the map mode if needed */
- if (array_bit & (VERT_BIT_POS|VERT_BIT_GENERIC0))
+ if (attrib_bits & (VERT_BIT_POS|VERT_BIT_GENERIC0))
update_attribute_map_mode(ctx, vao);
}
}
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->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:
}
+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)
{
ctx->Array.LockFirst = first;
ctx->Array.LockCount = count;
-
- ctx->NewState |= _NEW_ARRAY;
}
ctx->Array.LockFirst = 0;
ctx->Array.LockCount = 0;
- ctx->NewState |= _NEW_ARRAY;
}
struct gl_array_attributes *dst,
const struct gl_array_attributes *src)
{
- dst->Size = src->Size;
- dst->Type = src->Type;
- dst->Format = src->Format;
- dst->BufferBindingIndex = src->BufferBindingIndex;
+ 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;
}
fprintf(stderr, "Array Object %u\n", vao->Name);
- gl_vert_attrib i;
- for (i = 0; i < VERT_ATTRIB_MAX; ++i) {
+ GLbitfield mask = vao->Enabled;
+ while (mask) {
+ const gl_vert_attrib i = u_bit_scan(&mask);
const struct gl_array_attributes *array = &vao->VertexAttrib[i];
- if (!array->Enabled)
- continue;
const struct gl_vertex_buffer_binding *binding =
&vao->BufferBinding[array->BufferBindingIndex];
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->Type), array->Size,
- array->_ElementSize, binding->Stride, bo->Name,
+ array->Ptr, _mesa_enum_to_string(array->Format.Type),
+ array->Format.Size,
+ array->Format._ElementSize, binding->Stride, bo->Name,
(unsigned long) bo->Size);
}
}
projects / mesa.git / blobdiff