X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fmesa%2Fmain%2Farrayobj.c;h=82589645aa16675f76a15d7b6fceb78769b7bf20;hb=c89802aeeaee35e06c98a41dd630a60e8e7e4123;hp=78f56ab00b7a682d129f446e43202eccc76ee169;hpb=9520f483b8f1e45fa474674b415554988de5d8d3;p=mesa.git diff --git a/src/mesa/main/arrayobj.c b/src/mesa/main/arrayobj.c index 78f56ab00b7..82589645aa1 100644 --- a/src/mesa/main/arrayobj.c +++ b/src/mesa/main/arrayobj.c @@ -1,6 +1,5 @@ /* * Mesa 3-D graphics library - * Version: 7.6 * * Copyright (C) 1999-2008 Brian Paul All Rights Reserved. * (C) Copyright IBM Corporation 2006 @@ -19,16 +18,19 @@ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL - * BRIAN PAUL OR IBM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, - * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF - * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. + * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR + * OTHER DEALINGS IN THE SOFTWARE. */ /** * \file arrayobj.c - * Functions for the GL_APPLE_vertex_array_object extension. + * + * Implementation of Vertex Array Objects (VAOs), from OpenGL 3.1+, + * the GL_ARB_vertex_array_object extension, or the older + * GL_APPLE_vertex_array_object extension. * * \todo * The code in this file borrows a lot from bufferobj.c. There's a certain @@ -44,213 +46,269 @@ #include "image.h" #include "imports.h" #include "context.h" -#include "mfeatures.h" -#if FEATURE_ARB_vertex_buffer_object #include "bufferobj.h" -#endif #include "arrayobj.h" #include "macros.h" #include "mtypes.h" #include "varray.h" #include "main/dispatch.h" +#include "util/bitscan.h" /** * Look up the array object for the given ID. - * + * * \returns * Either a pointer to the array object with the specified ID or \c NULL for * a non-existent ID. The spec defines ID 0 as being technically * non-existent. */ -static inline struct gl_array_object * -lookup_arrayobj(struct gl_context *ctx, GLuint id) +struct gl_vertex_array_object * +_mesa_lookup_vao(struct gl_context *ctx, GLuint id) { if (id == 0) return NULL; else - return (struct gl_array_object *) + return (struct gl_vertex_array_object *) _mesa_HashLookup(ctx->Array.Objects, id); } /** - * For all the vertex arrays in the array object, unbind any pointers + * Looks up the array object for the given ID. + * + * Unlike _mesa_lookup_vao, this function generates a GL_INVALID_OPERATION + * error if the array object does not exist. It also returns the default + * array object when ctx is a compatibility profile context and id is zero. + */ +struct gl_vertex_array_object * +_mesa_lookup_vao_err(struct gl_context *ctx, GLuint id, const char *caller) +{ + /* The ARB_direct_state_access specification says: + * + * " is [compatibility profile: + * zero, indicating the default vertex array object, or] + * the name of the vertex array object." + */ + if (id == 0) { + if (ctx->API == API_OPENGL_CORE) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "%s(zero is not valid vaobj name in a core profile " + "context)", caller); + return NULL; + } + + return ctx->Array.DefaultVAO; + } else { + struct gl_vertex_array_object *vao; + + if (ctx->Array.LastLookedUpVAO && + ctx->Array.LastLookedUpVAO->Name == id) { + vao = ctx->Array.LastLookedUpVAO; + } else { + vao = (struct gl_vertex_array_object *) + _mesa_HashLookup(ctx->Array.Objects, id); + + /* The ARB_direct_state_access specification says: + * + * "An INVALID_OPERATION error is generated if is not + * [compatibility profile: zero or] the name of an existing + * vertex array object." + */ + if (!vao || !vao->EverBound) { + _mesa_error(ctx, GL_INVALID_OPERATION, + "%s(non-existent vaobj=%u)", caller, id); + return NULL; + } + + _mesa_reference_vao(ctx, &ctx->Array.LastLookedUpVAO, vao); + } + + return vao; + } +} + + +/** + * For all the vertex binding points in the array object, unbind any pointers * to any buffer objects (VBOs). * This is done just prior to array object destruction. */ static void -unbind_array_object_vbos(struct gl_context *ctx, struct gl_array_object *obj) +unbind_array_object_vbos(struct gl_context *ctx, struct gl_vertex_array_object *obj) { GLuint i; - _mesa_reference_buffer_object(ctx, &obj->Vertex.BufferObj, NULL); - _mesa_reference_buffer_object(ctx, &obj->Weight.BufferObj, NULL); - _mesa_reference_buffer_object(ctx, &obj->Normal.BufferObj, NULL); - _mesa_reference_buffer_object(ctx, &obj->Color.BufferObj, NULL); - _mesa_reference_buffer_object(ctx, &obj->SecondaryColor.BufferObj, NULL); - _mesa_reference_buffer_object(ctx, &obj->FogCoord.BufferObj, NULL); - _mesa_reference_buffer_object(ctx, &obj->Index.BufferObj, NULL); - _mesa_reference_buffer_object(ctx, &obj->EdgeFlag.BufferObj, NULL); - - for (i = 0; i < Elements(obj->TexCoord); i++) - _mesa_reference_buffer_object(ctx, &obj->TexCoord[i].BufferObj, NULL); - - for (i = 0; i < Elements(obj->VertexAttrib); i++) - _mesa_reference_buffer_object(ctx, &obj->VertexAttrib[i].BufferObj,NULL); + for (i = 0; i < ARRAY_SIZE(obj->VertexBinding); i++) + _mesa_reference_buffer_object(ctx, &obj->VertexBinding[i].BufferObj, NULL); -#if FEATURE_point_size_array - _mesa_reference_buffer_object(ctx, &obj->PointSize.BufferObj, NULL); -#endif + for (i = 0; i < ARRAY_SIZE(obj->_VertexAttrib); i++) + _mesa_reference_buffer_object(ctx, &obj->_VertexAttrib[i].BufferObj, NULL); } /** * Allocate and initialize a new vertex array object. - * - * This function is intended to be called via - * \c dd_function_table::NewArrayObject. */ -struct gl_array_object * -_mesa_new_array_object( struct gl_context *ctx, GLuint name ) +struct gl_vertex_array_object * +_mesa_new_vao(struct gl_context *ctx, GLuint name) { - struct gl_array_object *obj = CALLOC_STRUCT(gl_array_object); + struct gl_vertex_array_object *obj = CALLOC_STRUCT(gl_vertex_array_object); if (obj) - _mesa_initialize_array_object(ctx, obj, name); + _mesa_initialize_vao(ctx, obj, name); return obj; } /** * Delete an array object. - * - * This function is intended to be called via - * \c dd_function_table::DeleteArrayObject. */ void -_mesa_delete_array_object( struct gl_context *ctx, struct gl_array_object *obj ) +_mesa_delete_vao(struct gl_context *ctx, struct gl_vertex_array_object *obj) { - (void) ctx; unbind_array_object_vbos(ctx, obj); - _glthread_DESTROY_MUTEX(obj->Mutex); + _mesa_reference_buffer_object(ctx, &obj->IndexBufferObj, NULL); + mtx_destroy(&obj->Mutex); + free(obj->Label); free(obj); } /** - * Set ptr to arrayObj w/ reference counting. + * Set ptr to vao w/ reference counting. + * Note: this should only be called from the _mesa_reference_vao() + * inline function. */ void -_mesa_reference_array_object(struct gl_context *ctx, - struct gl_array_object **ptr, - struct gl_array_object *arrayObj) +_mesa_reference_vao_(struct gl_context *ctx, + struct gl_vertex_array_object **ptr, + struct gl_vertex_array_object *vao) { - if (*ptr == arrayObj) - return; + assert(*ptr != vao); if (*ptr) { /* Unreference the old array object */ GLboolean deleteFlag = GL_FALSE; - struct gl_array_object *oldObj = *ptr; + struct gl_vertex_array_object *oldObj = *ptr; - _glthread_LOCK_MUTEX(oldObj->Mutex); - ASSERT(oldObj->RefCount > 0); + mtx_lock(&oldObj->Mutex); + assert(oldObj->RefCount > 0); oldObj->RefCount--; -#if 0 - printf("ArrayObj %p %d DECR to %d\n", - (void *) oldObj, oldObj->Name, oldObj->RefCount); -#endif deleteFlag = (oldObj->RefCount == 0); - _glthread_UNLOCK_MUTEX(oldObj->Mutex); + mtx_unlock(&oldObj->Mutex); - if (deleteFlag) { - ASSERT(ctx->Driver.DeleteArrayObject); - ctx->Driver.DeleteArrayObject(ctx, oldObj); - } + if (deleteFlag) + _mesa_delete_vao(ctx, oldObj); *ptr = NULL; } - ASSERT(!*ptr); + assert(!*ptr); - if (arrayObj) { + if (vao) { /* reference new array object */ - _glthread_LOCK_MUTEX(arrayObj->Mutex); - if (arrayObj->RefCount == 0) { + mtx_lock(&vao->Mutex); + if (vao->RefCount == 0) { /* this array's being deleted (look just above) */ /* Not sure this can every really happen. Warn if it does. */ _mesa_problem(NULL, "referencing deleted array object"); *ptr = NULL; } else { - arrayObj->RefCount++; -#if 0 - printf("ArrayObj %p %d INCR to %d\n", - (void *) arrayObj, arrayObj->Name, arrayObj->RefCount); -#endif - *ptr = arrayObj; + vao->RefCount++; + *ptr = vao; } - _glthread_UNLOCK_MUTEX(arrayObj->Mutex); + mtx_unlock(&vao->Mutex); } } - +/** + * Initialize attribtes of a vertex array within a vertex array object. + * \param vao the container vertex array object + * \param index which array in the VAO to initialize + * \param size number of components (1, 2, 3 or 4) per attribute + * \param type datatype of the attribute (GL_FLOAT, GL_INT, etc). + */ static void init_array(struct gl_context *ctx, - struct gl_client_array *array, GLint size, GLint type) + struct gl_vertex_array_object *vao, + GLuint index, GLint size, GLint type) { + struct gl_vertex_attrib_array *array = &vao->VertexAttrib[index]; + struct gl_vertex_buffer_binding *binding = &vao->VertexBinding[index]; + array->Size = size; array->Type = type; array->Format = GL_RGBA; /* only significant for GL_EXT_vertex_array_bgra */ array->Stride = 0; - array->StrideB = 0; array->Ptr = NULL; + array->RelativeOffset = 0; array->Enabled = GL_FALSE; array->Normalized = GL_FALSE; + array->Integer = GL_FALSE; + array->Doubles = GL_FALSE; array->_ElementSize = size * _mesa_sizeof_type(type); -#if FEATURE_ARB_vertex_buffer_object + array->BufferBindingIndex = index; + + binding->Offset = 0; + binding->Stride = array->_ElementSize; + binding->BufferObj = NULL; + binding->_BoundArrays = BITFIELD64_BIT(index); + /* Vertex array buffers */ - _mesa_reference_buffer_object(ctx, &array->BufferObj, + _mesa_reference_buffer_object(ctx, &binding->BufferObj, ctx->Shared->NullBufferObj); -#endif } /** - * Initialize a gl_array_object's arrays. + * Initialize a gl_vertex_array_object's arrays. */ void -_mesa_initialize_array_object( struct gl_context *ctx, - struct gl_array_object *obj, - GLuint name ) +_mesa_initialize_vao(struct gl_context *ctx, + struct gl_vertex_array_object *vao, + GLuint name) { GLuint i; - obj->Name = name; + vao->Name = name; - _glthread_INIT_MUTEX(obj->Mutex); - obj->RefCount = 1; + mtx_init(&vao->Mutex, mtx_plain); + vao->RefCount = 1; /* Init the individual arrays */ - init_array(ctx, &obj->Vertex, 4, GL_FLOAT); - init_array(ctx, &obj->Weight, 1, GL_FLOAT); - init_array(ctx, &obj->Normal, 3, GL_FLOAT); - init_array(ctx, &obj->Color, 4, GL_FLOAT); - init_array(ctx, &obj->SecondaryColor, 3, GL_FLOAT); - init_array(ctx, &obj->FogCoord, 1, GL_FLOAT); - init_array(ctx, &obj->Index, 1, GL_FLOAT); - for (i = 0; i < Elements(obj->TexCoord); i++) { - init_array(ctx, &obj->TexCoord[i], 4, GL_FLOAT); - } - init_array(ctx, &obj->EdgeFlag, 1, GL_BOOL); - for (i = 0; i < Elements(obj->VertexAttrib); i++) { - init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT); + for (i = 0; i < ARRAY_SIZE(vao->VertexAttrib); i++) { + switch (i) { + case VERT_ATTRIB_WEIGHT: + init_array(ctx, vao, VERT_ATTRIB_WEIGHT, 1, GL_FLOAT); + break; + case VERT_ATTRIB_NORMAL: + init_array(ctx, vao, VERT_ATTRIB_NORMAL, 3, GL_FLOAT); + break; + case VERT_ATTRIB_COLOR1: + init_array(ctx, vao, VERT_ATTRIB_COLOR1, 3, GL_FLOAT); + break; + case VERT_ATTRIB_FOG: + init_array(ctx, vao, VERT_ATTRIB_FOG, 1, GL_FLOAT); + break; + case VERT_ATTRIB_COLOR_INDEX: + init_array(ctx, vao, VERT_ATTRIB_COLOR_INDEX, 1, GL_FLOAT); + break; + case VERT_ATTRIB_EDGEFLAG: + init_array(ctx, vao, VERT_ATTRIB_EDGEFLAG, 1, GL_BOOL); + break; + case VERT_ATTRIB_POINT_SIZE: + init_array(ctx, vao, VERT_ATTRIB_POINT_SIZE, 1, GL_FLOAT); + break; + default: + init_array(ctx, vao, i, 4, GL_FLOAT); + break; + } } -#if FEATURE_point_size_array - init_array(ctx, &obj->PointSize, 1, GL_FLOAT); -#endif + _mesa_reference_buffer_object(ctx, &vao->IndexBufferObj, + ctx->Shared->NullBufferObj); } @@ -258,11 +316,11 @@ _mesa_initialize_array_object( struct gl_context *ctx, * Add the given array object to the array object pool. */ static void -save_array_object( struct gl_context *ctx, struct gl_array_object *obj ) +save_array_object(struct gl_context *ctx, struct gl_vertex_array_object *vao) { - if (obj->Name > 0) { + if (vao->Name > 0) { /* insert into hash table */ - _mesa_HashInsert(ctx->Array.Objects, obj->Name, obj); + _mesa_HashInsert(ctx->Array.Objects, vao->Name, vao); } } @@ -272,61 +330,104 @@ save_array_object( struct gl_context *ctx, struct gl_array_object *obj ) * Do not deallocate the array object though. */ static void -remove_array_object( struct gl_context *ctx, struct gl_array_object *obj ) +remove_array_object(struct gl_context *ctx, struct gl_vertex_array_object *vao) { - if (obj->Name > 0) { + if (vao->Name > 0) { /* remove from hash table */ - _mesa_HashRemove(ctx->Array.Objects, obj->Name); + _mesa_HashRemove(ctx->Array.Objects, vao->Name); } } - /** - * Helper for update_arrays(). - * \return min(current min, array->_MaxElement). + * Updates the derived gl_client_arrays when a gl_vertex_attrib_array + * or a gl_vertex_buffer_binding has changed. */ -static GLuint -update_min(GLuint min, struct gl_client_array *array) +void +_mesa_update_vao_client_arrays(struct gl_context *ctx, + struct gl_vertex_array_object *vao) { - if (array->Enabled) { - _mesa_update_array_max_element(array); - return MIN2(min, array->_MaxElement); + GLbitfield64 arrays = vao->NewArrays; + + while (arrays) { + const int attrib = u_bit_scan64(&arrays); + + struct gl_client_array *client_array; + struct gl_vertex_attrib_array *attrib_array; + struct gl_vertex_buffer_binding *buffer_binding; + + attrib_array = &vao->VertexAttrib[attrib]; + buffer_binding = &vao->VertexBinding[attrib_array->BufferBindingIndex]; + client_array = &vao->_VertexAttrib[attrib]; + + _mesa_update_client_array(ctx, client_array, attrib_array, + buffer_binding); } - else - return min; } -/** - * Examine vertex arrays to update the gl_array_object::_MaxElement field. - */ -void -_mesa_update_array_object_max_element(struct gl_context *ctx, - struct gl_array_object *arrayObj) +bool +_mesa_all_varyings_in_vbos(const struct gl_vertex_array_object *vao) { - GLuint i, min = ~0; - - min = update_min(min, &arrayObj->Vertex); - min = update_min(min, &arrayObj->Weight); - min = update_min(min, &arrayObj->Normal); - min = update_min(min, &arrayObj->Color); - min = update_min(min, &arrayObj->SecondaryColor); - min = update_min(min, &arrayObj->FogCoord); - min = update_min(min, &arrayObj->Index); - min = update_min(min, &arrayObj->EdgeFlag); -#if FEATURE_point_size_array - min = update_min(min, &arrayObj->PointSize); -#endif - for (i = 0; i < ctx->Const.MaxTextureCoordUnits; i++) - min = update_min(min, &arrayObj->TexCoord[i]); - for (i = 0; i < Elements(arrayObj->VertexAttrib); i++) - min = update_min(min, &arrayObj->VertexAttrib[i]); - - /* _MaxElement is one past the last legal array element */ - arrayObj->_MaxElement = min; + /* Walk those enabled arrays that have the default vbo attached */ + GLbitfield64 mask = vao->_Enabled & ~vao->VertexAttribBufferMask; + + while (mask) { + /* Do not use u_bit_scan64 as we can walk multiple + * attrib arrays at once + */ + const int i = ffsll(mask) - 1; + const struct gl_vertex_attrib_array *attrib_array = + &vao->VertexAttrib[i]; + const struct gl_vertex_buffer_binding *buffer_binding = + &vao->VertexBinding[attrib_array->BufferBindingIndex]; + + /* Only enabled arrays shall appear in the _Enabled bitmask */ + assert(attrib_array->Enabled); + /* We have already masked out vao->VertexAttribBufferMask */ + assert(!_mesa_is_bufferobj(buffer_binding->BufferObj)); + + /* Bail out once we find the first non vbo with a non zero stride */ + if (buffer_binding->Stride != 0) + return false; + + /* Note that we cannot use the xor variant since the _BoundArray mask + * may contain array attributes that are bound but not enabled. + */ + mask &= ~buffer_binding->_BoundArrays; + } + + return true; } +bool +_mesa_all_buffers_are_unmapped(const struct gl_vertex_array_object *vao) +{ + /* Walk the enabled arrays that have a vbo attached */ + GLbitfield64 mask = vao->_Enabled & vao->VertexAttribBufferMask; + + while (mask) { + const int i = ffsll(mask) - 1; + const struct gl_vertex_attrib_array *attrib_array = + &vao->VertexAttrib[i]; + const struct gl_vertex_buffer_binding *buffer_binding = + &vao->VertexBinding[attrib_array->BufferBindingIndex]; + + /* Only enabled arrays shall appear in the _Enabled bitmask */ + assert(attrib_array->Enabled); + /* We have already masked with vao->VertexAttribBufferMask */ + assert(_mesa_is_bufferobj(buffer_binding->BufferObj)); + + /* Bail out once we find the first disallowed mapping */ + if (_mesa_check_disallowed_mapping(buffer_binding->BufferObj)) + return false; + + /* We have handled everything that is bound to this buffer_binding. */ + mask &= ~buffer_binding->_BoundArrays; + } + + return true; +} /**********************************************************************/ /* API Functions */ @@ -341,11 +442,10 @@ _mesa_update_array_object_max_element(struct gl_context *ctx, static void bind_vertex_array(struct gl_context *ctx, GLuint id, GLboolean genRequired) { - struct gl_array_object * const oldObj = ctx->Array.ArrayObj; - struct gl_array_object *newObj = NULL; - ASSERT_OUTSIDE_BEGIN_END(ctx); + struct gl_vertex_array_object * const oldObj = ctx->Array.VAO; + struct gl_vertex_array_object *newObj = NULL; - ASSERT(oldObj != NULL); + assert(oldObj != NULL); if ( oldObj->Name == id ) return; /* rebinding the same array object- no change */ @@ -357,34 +457,57 @@ bind_vertex_array(struct gl_context *ctx, GLuint id, GLboolean genRequired) /* The spec says there is no array object named 0, but we use * one internally because it simplifies things. */ - newObj = ctx->Array.DefaultArrayObj; + newObj = ctx->Array.DefaultVAO; } else { /* non-default array object */ - newObj = lookup_arrayobj(ctx, id); + newObj = _mesa_lookup_vao(ctx, id); if (!newObj) { if (genRequired) { - _mesa_error(ctx, GL_INVALID_OPERATION, "glBindVertexArray(id)"); + _mesa_error(ctx, GL_INVALID_OPERATION, + "glBindVertexArray(non-gen name)"); return; } /* For APPLE version, generate a new array object now */ - newObj = (*ctx->Driver.NewArrayObject)(ctx, id); + newObj = _mesa_new_vao(ctx, id); if (!newObj) { _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindVertexArrayAPPLE"); return; } + save_array_object(ctx, newObj); } + + if (!newObj->EverBound) { + /* The "Interactions with APPLE_vertex_array_object" section of the + * GL_ARB_vertex_array_object spec says: + * + * "The first bind call, either BindVertexArray or + * BindVertexArrayAPPLE, determines the semantic of the object." + */ + newObj->ARBsemantics = genRequired; + newObj->EverBound = GL_TRUE; + } } - ctx->NewState |= _NEW_ARRAY; - ctx->Array.NewState |= _NEW_ARRAY_ALL; - _mesa_reference_array_object(ctx, &ctx->Array.ArrayObj, newObj); + if (ctx->Array.DrawMethod == DRAW_ARRAYS) { + /* The _DrawArrays pointer is pointing at the VAO being unbound and + * that VAO may be in the process of being deleted. If it's not going + * to be deleted, this will have no effect, because the pointer needs + * to be updated by the VBO module anyway. + * + * Before the VBO module can update the pointer, we have to set it + * to NULL for drivers not to set up arrays which are not bound, + * or to prevent a crash if the VAO being unbound is going to be + * deleted. + */ + ctx->Array._DrawArrays = NULL; + ctx->Array.DrawMethod = DRAW_NONE; + } - /* Pass BindVertexArray call to device driver */ - if (ctx->Driver.BindArrayObject && newObj) - ctx->Driver.BindArrayObject(ctx, newObj); + ctx->NewState |= _NEW_ARRAY; + _mesa_reference_vao(ctx, &ctx->Array.VAO, newObj); } @@ -420,43 +543,45 @@ _mesa_BindVertexArrayAPPLE( GLuint id ) /** * Delete a set of array objects. - * + * * \param n Number of array objects to delete. * \param ids Array of \c n array object IDs. */ void GLAPIENTRY -_mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids) +_mesa_DeleteVertexArrays(GLsizei n, const GLuint *ids) { GET_CURRENT_CONTEXT(ctx); GLsizei i; - ASSERT_OUTSIDE_BEGIN_END(ctx); if (n < 0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteVertexArrayAPPLE(n)"); + _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteVertexArray(n)"); return; } for (i = 0; i < n; i++) { - struct gl_array_object *obj = lookup_arrayobj(ctx, ids[i]); + struct gl_vertex_array_object *obj = _mesa_lookup_vao(ctx, ids[i]); if ( obj != NULL ) { - ASSERT( obj->Name == ids[i] ); + assert( obj->Name == ids[i] ); /* If the array object is currently bound, the spec says "the binding * for that object reverts to zero and the default vertex array * becomes current." */ - if ( obj == ctx->Array.ArrayObj ) { - CALL_BindVertexArrayAPPLE( ctx->Exec, (0) ); + if ( obj == ctx->Array.VAO ) { + _mesa_BindVertexArray(0); } /* The ID is immediately freed for re-use */ remove_array_object(ctx, obj); + if (ctx->Array.LastLookedUpVAO == obj) + _mesa_reference_vao(ctx, &ctx->Array.LastLookedUpVAO, NULL); + /* Unreference the array object. * If refcount hits zero, the object will be deleted. */ - _mesa_reference_array_object(ctx, &obj, NULL); + _mesa_reference_vao(ctx, &obj, NULL); } } } @@ -464,21 +589,23 @@ _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids) /** * Generate a set of unique array object IDs and store them in \c arrays. - * Helper for _mesa_GenVertexArrays[APPLE]() functions below. + * Helper for _mesa_GenVertexArrays[APPLE]() and _mesa_CreateVertexArrays() + * below. + * * \param n Number of IDs to generate. * \param arrays Array of \c n locations to store the IDs. - * \param vboOnly Will arrays have to reside in VBOs? + * \param create Indicates that the objects should also be created. + * \param func The name of the GL entry point. */ -static void +static void gen_vertex_arrays(struct gl_context *ctx, GLsizei n, GLuint *arrays, - GLboolean vboOnly) + bool create, const char *func) { GLuint first; GLint i; - ASSERT_OUTSIDE_BEGIN_END(ctx); if (n < 0) { - _mesa_error(ctx, GL_INVALID_VALUE, "glGenVertexArraysAPPLE"); + _mesa_error(ctx, GL_INVALID_VALUE, "%s(n < 0)", func); return; } @@ -488,17 +615,20 @@ gen_vertex_arrays(struct gl_context *ctx, GLsizei n, GLuint *arrays, first = _mesa_HashFindFreeKeyBlock(ctx->Array.Objects, n); - /* Allocate new, empty array objects and return identifiers */ + /* For the sake of simplicity we create the array objects in both + * the Gen* and Create* cases. The only difference is the value of + * EverBound, which is set to true in the Create* case. + */ for (i = 0; i < n; i++) { - struct gl_array_object *obj; + struct gl_vertex_array_object *obj; GLuint name = first + i; - obj = (*ctx->Driver.NewArrayObject)( ctx, name ); + obj = _mesa_new_vao(ctx, name); if (!obj) { - _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenVertexArraysAPPLE"); + _mesa_error(ctx, GL_OUT_OF_MEMORY, "%s", func); return; } - obj->VBOonly = vboOnly; + obj->EverBound = create; save_array_object(ctx, obj); arrays[i] = first + i; } @@ -513,7 +643,7 @@ void GLAPIENTRY _mesa_GenVertexArrays(GLsizei n, GLuint *arrays) { GET_CURRENT_CONTEXT(ctx); - gen_vertex_arrays(ctx, n, arrays, GL_TRUE); + gen_vertex_arrays(ctx, n, arrays, false, "glGenVertexArrays"); } @@ -525,28 +655,117 @@ void GLAPIENTRY _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays) { GET_CURRENT_CONTEXT(ctx); - gen_vertex_arrays(ctx, n, arrays, GL_FALSE); + gen_vertex_arrays(ctx, n, arrays, false, "glGenVertexArraysAPPLE"); +} + + +/** + * ARB_direct_state_access + * Generates ID's and creates the array objects. + */ +void GLAPIENTRY +_mesa_CreateVertexArrays(GLsizei n, GLuint *arrays) +{ + GET_CURRENT_CONTEXT(ctx); + gen_vertex_arrays(ctx, n, arrays, true, "glCreateVertexArrays"); } /** * Determine if ID is the name of an array object. - * + * * \param id ID of the potential array object. - * \return \c GL_TRUE if \c id is the name of a array object, + * \return \c GL_TRUE if \c id is the name of a array object, * \c GL_FALSE otherwise. */ GLboolean GLAPIENTRY -_mesa_IsVertexArrayAPPLE( GLuint id ) +_mesa_IsVertexArray( GLuint id ) { - struct gl_array_object * obj; + struct gl_vertex_array_object * obj; GET_CURRENT_CONTEXT(ctx); ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE); if (id == 0) return GL_FALSE; - obj = lookup_arrayobj(ctx, id); + obj = _mesa_lookup_vao(ctx, id); + if (obj == NULL) + return GL_FALSE; + + return obj->EverBound; +} + + +/** + * Sets the element array buffer binding of a vertex array object. + * + * This is the ARB_direct_state_access equivalent of + * glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, buffer). + */ +void GLAPIENTRY +_mesa_VertexArrayElementBuffer(GLuint vaobj, GLuint buffer) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_vertex_array_object *vao; + struct gl_buffer_object *bufObj; + + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* The GL_ARB_direct_state_access specification says: + * + * "An INVALID_OPERATION error is generated by VertexArrayElementBuffer + * if is not [compatibility profile: zero or] the name of an + * existing vertex array object." + */ + vao =_mesa_lookup_vao_err(ctx, vaobj, "glVertexArrayElementBuffer"); + if (!vao) + return; + + /* The GL_ARB_direct_state_access specification says: + * + * "An INVALID_OPERATION error is generated if is not zero or + * the name of an existing buffer object." + */ + if (buffer != 0) + bufObj = _mesa_lookup_bufferobj_err(ctx, buffer, + "glVertexArrayElementBuffer"); + else + bufObj = ctx->Shared->NullBufferObj; + + if (bufObj) + _mesa_reference_buffer_object(ctx, &vao->IndexBufferObj, bufObj); +} + + +void GLAPIENTRY +_mesa_GetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param) +{ + GET_CURRENT_CONTEXT(ctx); + struct gl_vertex_array_object *vao; + + ASSERT_OUTSIDE_BEGIN_END(ctx); + + /* The GL_ARB_direct_state_access specification says: + * + * "An INVALID_OPERATION error is generated if is not + * [compatibility profile: zero or] the name of an existing + * vertex array object." + */ + vao =_mesa_lookup_vao_err(ctx, vaobj, "glGetVertexArrayiv"); + if (!vao) + return; + + /* The GL_ARB_direct_state_access specification says: + * + * "An INVALID_ENUM error is generated if is not + * ELEMENT_ARRAY_BUFFER_BINDING." + */ + if (pname != GL_ELEMENT_ARRAY_BUFFER_BINDING) { + _mesa_error(ctx, GL_INVALID_ENUM, + "glGetVertexArrayiv(pname != " + "GL_ELEMENT_ARRAY_BUFFER_BINDING)"); + return; + } - return (obj != NULL) ? GL_TRUE : GL_FALSE; + param[0] = vao->IndexBufferObj->Name; }