src/mesa/main/arrayobj.c

   1 /*
   2  * Mesa 3-D graphics library
   3  * Version:  7.2
   4  *
   5  * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.
   6  * (C) Copyright IBM Corporation 2006
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included
  16  * in all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * BRIAN PAUL OR IBM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  23  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  */
  26
  27
  28 /**
  29  * \file arrayobj.c
  30  * Functions for the GL_APPLE_vertex_array_object extension.
  31  *
  32  * \todo
  33  * The code in this file borrows a lot from bufferobj.c.  There's a certain
  34  * amount of cruft left over from that origin that may be unnecessary.
  35  *
  36  * \author Ian Romanick <idr@us.ibm.com>
  37  * \author Brian Paul
  38  */
  39
  40
  41 #include "glheader.h"
  42 #include "hash.h"
  43 #include "imports.h"
  44 #include "context.h"
  45 #if FEATURE_ARB_vertex_buffer_object
  46 #include "bufferobj.h"
  47 #endif
  48 #include "arrayobj.h"
  49 #include "glapi/dispatch.h"
  50
  51
  52 /**
  53  * Look up the array object for the given ID.
  54  *
  55  * \returns
  56  * Either a pointer to the array object with the specified ID or \c NULL for
  57  * a non-existent ID.  The spec defines ID 0 as being technically
  58  * non-existent.
  59  */
  60
  61 static INLINE struct gl_array_object *
  62 lookup_arrayobj(GLcontext *ctx, GLuint id)
  63 {
  64    return (id == 0)
  65      ? NULL
  66      : (struct gl_array_object *) _mesa_HashLookup(ctx->Shared->ArrayObjects,
  67                                                    id);
  68 }
  69
  70
  71 /**
  72  * Allocate and initialize a new vertex array object.
  73  *
  74  * This function is intended to be called via
  75  * \c dd_function_table::NewArrayObject.
  76  */
  77 struct gl_array_object *
  78 _mesa_new_array_object( GLcontext *ctx, GLuint name )
  79 {
  80    struct gl_array_object *obj = CALLOC_STRUCT(gl_array_object);
  81    if (obj)
  82       _mesa_initialize_array_object(ctx, obj, name);
  83    return obj;
  84 }
  85
  86
  87 /**
  88  * Delete an array object.
  89  *
  90  * This function is intended to be called via
  91  * \c dd_function_table::DeleteArrayObject.
  92  */
  93 void
  94 _mesa_delete_array_object( GLcontext *ctx, struct gl_array_object *obj )
  95 {
  96    (void) ctx;
  97    _glthread_DESTROY_MUTEX(obj->Mutex);
  98    _mesa_free(obj);
  99 }
 100
 101
 102 /**
 103  * Set ptr to arrayObj w/ reference counting.
 104  */
 105 void
 106 _mesa_reference_array_object(GLcontext *ctx,
 107                              struct gl_array_object **ptr,
 108                              struct gl_array_object *arrayObj)
 109 {
 110    if (*ptr == arrayObj)
 111       return;
 112
 113    if (*ptr) {
 114       /* Unreference the old array object */
 115       GLboolean deleteFlag = GL_FALSE;
 116       struct gl_array_object *oldObj = *ptr;
 117
 118       _glthread_LOCK_MUTEX(oldObj->Mutex);
 119       ASSERT(oldObj->RefCount > 0);
 120       oldObj->RefCount--;
 121 #if 0
 122       printf("ArrayObj %p %d DECR to %d\n",
 123              (void *) oldObj, oldObj->Name, oldObj->RefCount);
 124 #endif
 125       deleteFlag = (oldObj->RefCount == 0);
 126       _glthread_UNLOCK_MUTEX(oldObj->Mutex);
 127
 128       if (deleteFlag) {
 129          ASSERT(ctx->Driver.DeleteArrayObject);
 130          ctx->Driver.DeleteArrayObject(ctx, oldObj);
 131       }
 132
 133       *ptr = NULL;
 134    }
 135    ASSERT(!*ptr);
 136
 137    if (arrayObj) {
 138       /* reference new array object */
 139       _glthread_LOCK_MUTEX(arrayObj->Mutex);
 140       if (arrayObj->RefCount == 0) {
 141          /* this array's being deleted (look just above) */
 142          /* Not sure this can every really happen.  Warn if it does. */
 143          _mesa_problem(NULL, "referencing deleted array object");
 144          *ptr = NULL;
 145       }
 146       else {
 147          arrayObj->RefCount++;
 148 #if 0
 149          printf("ArrayObj %p %d INCR to %d\n",
 150                 (void *) arrayObj, arrayObj->Name, arrayObj->RefCount);
 151 #endif
 152          *ptr = arrayObj;
 153       }
 154       _glthread_UNLOCK_MUTEX(arrayObj->Mutex);
 155    }
 156 }
 157
 158
 159
 160 static void
 161 init_array(GLcontext *ctx,
 162            struct gl_client_array *array, GLint size, GLint type)
 163 {
 164    array->Size = size;
 165    array->Type = type;
 166    array->Format = GL_RGBA; /* only significant for GL_EXT_vertex_array_bgra */
 167    array->Stride = 0;
 168    array->StrideB = 0;
 169    array->Ptr = NULL;
 170    array->Enabled = GL_FALSE;
 171    array->Normalized = GL_FALSE;
 172 #if FEATURE_ARB_vertex_buffer_object
 173    /* Vertex array buffers */
 174    _mesa_reference_buffer_object(ctx, &array->BufferObj,
 175                                  ctx->Shared->NullBufferObj);
 176 #endif
 177 }
 178
 179
 180 /**
 181  * Initialize a gl_array_object's arrays.
 182  */
 183 void
 184 _mesa_initialize_array_object( GLcontext *ctx,
 185                                struct gl_array_object *obj,
 186                                GLuint name )
 187 {
 188    GLuint i;
 189
 190    obj->Name = name;
 191
 192    _glthread_INIT_MUTEX(obj->Mutex);
 193    obj->RefCount = 1;
 194
 195    /* Init the individual arrays */
 196    init_array(ctx, &obj->Vertex, 4, GL_FLOAT);
 197    init_array(ctx, &obj->Normal, 3, GL_FLOAT);
 198    init_array(ctx, &obj->Color, 4, GL_FLOAT);
 199    init_array(ctx, &obj->SecondaryColor, 4, GL_FLOAT);
 200    init_array(ctx, &obj->FogCoord, 1, GL_FLOAT);
 201    init_array(ctx, &obj->Index, 1, GL_FLOAT);
 202    for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
 203       init_array(ctx, &obj->TexCoord[i], 4, GL_FLOAT);
 204    }
 205    init_array(ctx, &obj->EdgeFlag, 1, GL_BOOL);
 206    for (i = 0; i < VERT_ATTRIB_MAX; i++) {
 207       init_array(ctx, &obj->VertexAttrib[i], 4, GL_FLOAT);
 208    }
 209
 210 #if FEATURE_point_size_array
 211    init_array(ctx, &obj->PointSize, 1, GL_FLOAT);
 212 #endif
 213 }
 214
 215
 216 /**
 217  * Add the given array object to the array object pool.
 218  */
 219 void
 220 _mesa_save_array_object( GLcontext *ctx, struct gl_array_object *obj )
 221 {
 222    if (obj->Name > 0) {
 223       /* insert into hash table */
 224       _mesa_HashInsert(ctx->Shared->ArrayObjects, obj->Name, obj);
 225    }
 226 }
 227
 228
 229 /**
 230  * Remove the given array object from the array object pool.
 231  * Do not deallocate the array object though.
 232  */
 233 void
 234 _mesa_remove_array_object( GLcontext *ctx, struct gl_array_object *obj )
 235 {
 236    if (obj->Name > 0) {
 237       /* remove from hash table */
 238       _mesa_HashRemove(ctx->Shared->ArrayObjects, obj->Name);
 239    }
 240 }
 241
 242
 243 static void
 244 unbind_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
 245 {
 246    if (bufObj != ctx->Shared->NullBufferObj) {
 247       _mesa_reference_buffer_object(ctx, &bufObj, NULL);
 248    }
 249 }
 250
 251
 252 /**********************************************************************/
 253 /* API Functions                                                      */
 254 /**********************************************************************/
 255
 256 /**
 257  * Bind a new array.
 258  *
 259  * \todo
 260  * The binding could be done more efficiently by comparing the non-NULL
 261  * pointers in the old and new objects.  The only arrays that are "dirty" are
 262  * the ones that are non-NULL in either object.
 263  */
 264 void GLAPIENTRY
 265 _mesa_BindVertexArrayAPPLE( GLuint id )
 266 {
 267    GET_CURRENT_CONTEXT(ctx);
 268    struct gl_array_object * const oldObj = ctx->Array.ArrayObj;
 269    struct gl_array_object *newObj = NULL;
 270    ASSERT_OUTSIDE_BEGIN_END(ctx);
 271
 272    ASSERT(oldObj != NULL);
 273
 274    if ( oldObj->Name == id )
 275       return;   /* rebinding the same array object- no change */
 276
 277    /*
 278     * Get pointer to new array object (newBufObj)
 279     */
 280    if (id == 0) {
 281       /* The spec says there is no array object named 0, but we use
 282        * one internally because it simplifies things.
 283        */
 284       newObj = ctx->Array.DefaultArrayObj;
 285    }
 286    else {
 287       /* non-default array object */
 288       newObj = lookup_arrayobj(ctx, id);
 289       if (!newObj) {
 290          /* If this is a new array object id, allocate an array object now.
 291           */
 292          newObj = (*ctx->Driver.NewArrayObject)(ctx, id);
 293          if (!newObj) {
 294             _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindVertexArrayAPPLE");
 295             return;
 296          }
 297          _mesa_save_array_object(ctx, newObj);
 298       }
 299    }
 300
 301    ctx->NewState |= _NEW_ARRAY;
 302    ctx->Array.NewState |= _NEW_ARRAY_ALL;
 303    _mesa_reference_array_object(ctx, &ctx->Array.ArrayObj, newObj);
 304
 305    /* Pass BindVertexArray call to device driver */
 306    if (ctx->Driver.BindArrayObject && newObj)
 307       (*ctx->Driver.BindArrayObject)( ctx, newObj );
 308 }
 309
 310
 311 /**
 312  * Delete a set of array objects.
 313  *
 314  * \param n      Number of array objects to delete.
 315  * \param ids    Array of \c n array object IDs.
 316  */
 317 void GLAPIENTRY
 318 _mesa_DeleteVertexArraysAPPLE(GLsizei n, const GLuint *ids)
 319 {
 320    GET_CURRENT_CONTEXT(ctx);
 321    GLsizei i;
 322    ASSERT_OUTSIDE_BEGIN_END(ctx);
 323
 324    if (n < 0) {
 325       _mesa_error(ctx, GL_INVALID_VALUE, "glDeleteVertexArrayAPPLE(n)");
 326       return;
 327    }
 328
 329    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
 330
 331    for (i = 0; i < n; i++) {
 332       struct gl_array_object *obj = lookup_arrayobj(ctx, ids[i]);
 333
 334       if ( obj != NULL ) {
 335          ASSERT( obj->Name == ids[i] );
 336
 337
 338          /* If the array object is currently bound, the spec says "the binding
 339           * for that object reverts to zero and the default vertex array
 340           * becomes current."
 341           */
 342          if ( obj == ctx->Array.ArrayObj ) {
 343             CALL_BindVertexArrayAPPLE( ctx->Exec, (0) );
 344          }
 345
 346 #if FEATURE_ARB_vertex_buffer_object
 347          /* Unbind any buffer objects that might be bound to arrays in
 348           * this array object.
 349           */
 350          unbind_buffer_object( ctx, obj->Vertex.BufferObj );
 351          unbind_buffer_object( ctx, obj->Normal.BufferObj );
 352          unbind_buffer_object( ctx, obj->Color.BufferObj );
 353          unbind_buffer_object( ctx, obj->SecondaryColor.BufferObj );
 354          unbind_buffer_object( ctx, obj->FogCoord.BufferObj );
 355          unbind_buffer_object( ctx, obj->Index.BufferObj );
 356          for (i = 0; i < MAX_TEXTURE_COORD_UNITS; i++) {
 357             unbind_buffer_object( ctx, obj->TexCoord[i].BufferObj );
 358          }
 359          unbind_buffer_object( ctx, obj->EdgeFlag.BufferObj );
 360          for (i = 0; i < VERT_ATTRIB_MAX; i++) {
 361             unbind_buffer_object( ctx, obj->VertexAttrib[i].BufferObj );
 362          }
 363 #endif
 364
 365          /* The ID is immediately freed for re-use */
 366          _mesa_remove_array_object(ctx, obj);
 367          ctx->Driver.DeleteArrayObject(ctx, obj);
 368       }
 369    }
 370
 371    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 372 }
 373
 374
 375 /**
 376  * Generate a set of unique array object IDs and store them in \c arrays.
 377  *
 378  * \param n       Number of IDs to generate.
 379  * \param arrays  Array of \c n locations to store the IDs.
 380  */
 381 void GLAPIENTRY
 382 _mesa_GenVertexArraysAPPLE(GLsizei n, GLuint *arrays)
 383 {
 384    GET_CURRENT_CONTEXT(ctx);
 385    GLuint first;
 386    GLint i;
 387    ASSERT_OUTSIDE_BEGIN_END(ctx);
 388
 389    if (n < 0) {
 390       _mesa_error(ctx, GL_INVALID_VALUE, "glGenVertexArraysAPPLE");
 391       return;
 392    }
 393
 394    if (!arrays) {
 395       return;
 396    }
 397
 398    /*
 399     * This must be atomic (generation and allocation of array object IDs)
 400     */
 401    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
 402
 403    first = _mesa_HashFindFreeKeyBlock(ctx->Shared->ArrayObjects, n);
 404
 405    /* Allocate new, empty array objects and return identifiers */
 406    for (i = 0; i < n; i++) {
 407       struct gl_array_object *obj;
 408       GLuint name = first + i;
 409
 410       obj = (*ctx->Driver.NewArrayObject)( ctx, name );
 411       if (!obj) {
 412          _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 413          _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenVertexArraysAPPLE");
 414          return;
 415       }
 416       _mesa_save_array_object(ctx, obj);
 417       arrays[i] = first + i;
 418    }
 419
 420    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 421 }
 422
 423
 424 /**
 425  * Determine if ID is the name of an array object.
 426  *
 427  * \param id  ID of the potential array object.
 428  * \return  \c GL_TRUE if \c id is the name of a array object,
 429  *          \c GL_FALSE otherwise.
 430  */
 431 GLboolean GLAPIENTRY
 432 _mesa_IsVertexArrayAPPLE( GLuint id )
 433 {
 434    struct gl_array_object * obj;
 435    GET_CURRENT_CONTEXT(ctx);
 436    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 437
 438    if (id == 0)
 439       return GL_FALSE;
 440
 441    _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
 442    obj = lookup_arrayobj(ctx, id);
 443    _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 444
 445    return (obj != NULL) ? GL_TRUE : GL_FALSE;
 446 }