Added most of the infrastructure required to support

ARB_vertex_buffer_object.  THIS IS INCOMPLETE.

src/mesa/main/bufferobj.c

@@ -25,39 +25,392 @@
 
 /**
  * \file bufferobj.c
- * Functions for the GL_ARB_vertex_buffer_object extension.
+ * \brief Functions for the GL_ARB_vertex_buffer_object extension.
  * \author Brian Paul
  */
 
 
 #include "glheader.h"
+#include "hash.h"
 #include "imports.h"
 #include "context.h"
 #include "bufferobj.h"
 
+struct gl_buffer_object {
+   GLint RefCount;
+   GLuint Name;
+   GLenum Target;
+   
+   GLenum usage;
+   GLenum access;
+   GLvoid * pointer;
+   GLuint  size;
+
+   void * data;
+};
+
+void _mesa_initialize_buffer_object( struct gl_buffer_object *obj,
+    GLuint name, GLenum target );
+
+
+/**
+ * Get the buffer object bound to the specified target in a GL context.
+ *
+ * \param ctx     GL context
+ * \param target  Buffer object target to be retrieved.  Currently this must
+ *                be either \c GL_ARRAY_BUFFER or \c GL_ELEMENT_ARRAY_BUFFER.
+ * \param str     Name of caller for logging errors.
+ * \return   A pointer to the buffer object bound to \c target in the
+ *           specified context or \c NULL if \c target is invalid or no
+ *           buffer object is bound.
+ */
+
+static __inline struct gl_buffer_object *
+_mesa_buffer_object_get_target( GLcontext *ctx, GLenum target,
+				const char * str )
+{
+   struct gl_buffer_object * bufObj = NULL;
+
+   switch (target) {
+      case GL_ARRAY_BUFFER_ARB:
+         bufObj = ctx->ArrayBuffer;
+         break;
+      case GL_ELEMENT_ARRAY_BUFFER_ARB:
+         bufObj = ctx->ElementArrayBuffer;
+         break;
+      default:
+         _mesa_error(ctx, GL_INVALID_ENUM, "gl%s(target)", str);
+         break;
+   }
+   
+   return bufObj;
+}
+
+
+/**
+ * Tests the subdata range parameters and sets the GL error code for
+ * \c glBufferSubDataARB and \c glGetBufferSubDataARB.
+ *
+ * \param ctx     GL context.
+ * \param target  Buffer object target on which to operate.
+ * \param offset  Offset of the first byte of the subdata range.
+ * \param size    Size, in bytes, of the subdata range.
+ * \param str     Name of caller for logging errors.
+ * \return   A pointer to the buffer object bound to \c target in the
+ *           specified context or \c NULL if any of the parameter or state
+ *           conditions for \c glBufferSubDataARB or \c glGetBufferSubDataARB
+ *           are invalid.
+ *
+ * \sa glBufferSubDataARB, glGetBufferSubDataARB
+ */
+
+static struct gl_buffer_object *
+_mesa_buffer_object_subdata_range_good( GLcontext * ctx, GLenum target, 
+					GLintptrARB offset, GLsizeiptrARB size,
+					const char * str )
+{
+   struct gl_buffer_object *bufObj;
+
+   if (size < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "gl%s(size < 0)", str);
+      return NULL;
+   }
+
+   if (offset < 0) {
+      _mesa_error(ctx, GL_INVALID_VALUE, "gl%s(offset < 0)", str);
+      return NULL;
+   }
+
+   bufObj = _mesa_buffer_object_get_target( ctx, target, str );
+   if ( bufObj == NULL ) {
+      return NULL;
+   }
+
+   if ( (offset + size) > bufObj->size ) {
+      _mesa_error(ctx, GL_INVALID_VALUE,
+		  "gl%s(size + offset > buffer size)", str);
+      return NULL;
+   }
+
+   if ( bufObj->pointer != NULL ) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "gl%s", str);
+      return NULL;
+   }
+
+   return bufObj;
+}
+
+
+/**
+ * Allocate and initialize a new buffer object.
+ * 
+ * This function is intended to be called via
+ * \c dd_function_table::NewBufferObject.
+ */
+
+struct gl_buffer_object *
+_mesa_new_buffer_object( GLcontext *ctx, GLuint name, GLenum target )
+{
+   struct gl_buffer_object *obj;
+   obj = CALLOC_STRUCT(gl_buffer_object);
+   _mesa_initialize_buffer_object(obj, name, target);
+   return obj;
+}
+
+
+/**
+ * Initialize a buffer object to default values.
+ */
+
+void
+_mesa_initialize_buffer_object( struct gl_buffer_object *obj,
+				GLuint name, GLenum target )
+{
+   obj->RefCount = 1;
+   obj->Name = name;
+}
+
+
+/**
+ * Add the given buffer object to the buffer object pool.
+ */
+
+void
+_mesa_save_buffer_object( GLcontext *ctx, struct gl_buffer_object *obj )
+{
+   if (obj->Name > 0) {
+      /* insert into hash table */
+      _mesa_HashInsert(ctx->Shared->BufferObjects, obj->Name, obj);
+   }
+}
+
+
+/**
+ * Remove the given buffer object from the buffer object pool.
+ * Do not deallocate the buffer object though.
+ */
+
+void
+_mesa_remove_buffer_object( GLcontext *ctx, struct gl_buffer_object *bufObj )
+{
+   if (bufObj->Name > 0) {
+      /* remove from hash table */
+      _mesa_HashRemove(ctx->Shared->BufferObjects, bufObj->Name);
+   }
+}
+
+
+/**
+ * Allocate space for and store data in a buffer object.  Any data that was
+ * previously stored in the buffer object is lost.  If \c data is \c NULL,
+ * memory will be allocated, but no copy will occur.
+ *
+ * This function is intended to be called via
+ * \c dd_function_table::BufferData.  This function need not set GL error
+ * codes.  The input parameters will have been tested before calling.
+ *
+ * \param ctx     GL context.
+ * \param target  Buffer object target on which to operate.
+ * \param size    Size, in bytes, of the new data store.
+ * \param data    Pointer to the data to store in the buffer object.  This
+ *                pointer may be \c NULL.
+ * \param usage   Hints about how the data will be used.
+ * \param bufObj  Object to be used.
+ *
+ * \sa glBufferDataARB, dd_function_table::BufferData.
+ */
+
+void
+_mesa_buffer_data( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
+		   const GLvoid * data, GLenum usage,
+		   struct gl_buffer_object * bufObj )
+{
+   void * new_data;
+
+   (void) target;
+
+   new_data = _mesa_realloc( bufObj->data, bufObj->size, size );
+   if ( new_data != NULL ) {
+      bufObj->data = new_data;
+      bufObj->size = size;
+      bufObj->usage = usage;
+
+      if ( data != NULL ) {
+	 memcpy( bufObj->data, data, size );
+      }
+   }
+}
+
+
+/**
+ * Replace data in a subrange of buffer object.  If the data range
+ * specified by \c size + \c offset extends beyond the end of the buffer or
+ * if \c data is \c NULL, no copy is performed.
+ *
+ * This function is intended to be called by
+ * \c dd_function_table::BufferSubData.  This function need not set GL error
+ * codes.  The input parameters will have been tested before calling.
+ *
+ * \param ctx     GL context.
+ * \param target  Buffer object target on which to operate.
+ * \param offset  Offset of the first byte to be modified.
+ * \param size    Size, in bytes, of the data range.
+ * \param data    Pointer to the data to store in the buffer object.
+ * \param bufObj  Object to be used.
+ *
+ * \sa glBufferSubDataARB, dd_function_table::BufferSubData.
+ */
+
+void
+_mesa_buffer_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
+		      GLsizeiptrARB size, const GLvoid * data,
+		      struct gl_buffer_object * bufObj )
+{
+   if ( (bufObj->data != NULL)
+	&& ((size + offset) <= bufObj->size) ) {
+      memcpy( (GLubyte *) bufObj->data + offset, data, size );
+   }
+}
+
+
+/**
+ * Retrieve data from a subrange of buffer object.  If the data range
+ * specified by \c size + \c offset extends beyond the end of the buffer or
+ * if \c data is \c NULL, no copy is performed.
+ *
+ * This function is intended to be called by
+ * \c dd_function_table::BufferGetSubData.  This function need not set GL error
+ * codes.  The input parameters will have been tested before calling.
+ *
+ * \param ctx     GL context.
+ * \param target  Buffer object target on which to operate.
+ * \param offset  Offset of the first byte to be modified.
+ * \param size    Size, in bytes, of the data range.
+ * \param data    Pointer to the data to store in the buffer object.
+ * \param bufObj  Object to be used.
+ *
+ * \sa glBufferGetSubDataARB, dd_function_table::GetBufferSubData.
+ */
+
+void
+_mesa_buffer_get_subdata( GLcontext *ctx, GLenum target, GLintptrARB offset,
+			  GLsizeiptrARB size, GLvoid * data,
+			  struct gl_buffer_object * bufObj )
+{
+   if ( (bufObj->data != NULL)
+	&& ((size + offset) <= bufObj->size) ) {
+      memcpy( data, (GLubyte *) bufObj->data + offset, size );
+   }
+}
+
+
+/**
+ * Maps the private data buffer into the processor's address space.
+ *
+ * This function is intended to be called by \c dd_function_table::MapBuffer.
+ * This function need not set GL error codes.  The input parameters will have
+ * been tested before calling.
+ *
+ * \param ctx     GL context.
+ * \param target  Buffer object target on which to operate.
+ * \param access  Information about how the buffer will be accessed.
+ * \param bufObj  Object to be used.
+ * \return  A pointer to the object's internal data store that can be accessed
+ *          by the processor
+ *
+ * \sa glMapBufferARB, dd_function_table::MapBuffer
+ */
+
+void *
+_mesa_buffer_map( GLcontext *ctx, GLenum target, GLenum access,
+		  struct gl_buffer_object * bufObj )
+{
+   return bufObj->data;
+}
+
 
 void
 _mesa_BindBufferARB(GLenum target, GLuint buffer)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *oldBufObj;
+   struct gl_buffer_object *newBufObj = 0;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (target == GL_ARRAY_BUFFER_ARB) {
-
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
+   oldBufObj = _mesa_buffer_object_get_target( ctx, target, "BindBufferARB" );
+   if ( (oldBufObj != NULL) && (oldBufObj->Name == buffer) )
+      return;   /* rebinding the same buffer object- no change */
 
+   /*
+    * Get pointer to new buffer object (newBufObj)
+    */
+   if ( buffer == 0 ) {
+      newBufObj = NULL;
    }
    else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target)");
-      return;
+      /* non-default buffer object */
+      const struct _mesa_HashTable *hash = ctx->Shared->BufferObjects;
+      newBufObj = (struct gl_buffer_object *) _mesa_HashLookup(hash, buffer);
+      if ( newBufObj != NULL ) {
+         /* error checking */
+         if (newBufObj->Target != 0 && newBufObj->Target != target) {
+            /* the named buffer object's target doesn't match the target */
+            _mesa_error( ctx, GL_INVALID_OPERATION,
+                         "glBindBufferARB(wrong target)" );
+            return;
+         }
+      }
+      else {
+         /* if this is a new buffer object id, allocate a buffer object now */
+	 newBufObj = (*ctx->Driver.NewBufferObject)(ctx, buffer, target);
+         if (!newBufObj) {
+            _mesa_error(ctx, GL_OUT_OF_MEMORY, "glBindBufferARB");
+            return;
+         }
+         _mesa_save_buffer_object(ctx, newBufObj);
+      }
+      newBufObj->Target = target;
+      newBufObj->RefCount++;
+   }
+   
+   switch (target) {
+      case GL_ARRAY_BUFFER_ARB:
+         ctx->ArrayBuffer = newBufObj;
+         break;
+      case GL_ELEMENT_ARRAY_BUFFER_ARB:
+         ctx->ElementArrayBuffer = newBufObj;
+         break;
+   }
+
+   /* Pass BindBuffer call to device driver */
+   if ( (ctx->Driver.BindBuffer != NULL) && (newBufObj != NULL) )
+      (*ctx->Driver.BindBuffer)( ctx, target, newBufObj );
+
+   if ( oldBufObj != NULL ) {
+      oldBufObj->RefCount--;
+      assert(oldBufObj->RefCount >= 0);
+      if (oldBufObj->RefCount == 0) {
+	 assert(oldBufObj->Name != 0);
+	 _mesa_remove_buffer_object(ctx, oldBufObj);
+	 ASSERT(ctx->Driver.DeleteBuffer);
+	 (*ctx->Driver.DeleteBuffer)( ctx, oldBufObj );
+      }
    }
 }
 
+
+/**
+ * Delete a set of buffer objects.
+ * 
+ * \param n      Number of buffer objects to delete.
+ * \param buffer Array of \c n buffer object IDs.
+ */
+
 void
-_mesa_DeleteBuffersARB(GLsizei n, const GLuint *buffer)
+_mesa_DeleteBuffersARB(GLsizei n, const GLuint *ids)
 {
    GET_CURRENT_CONTEXT(ctx);
+   unsigned i;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (n < 0) {
@@ -65,31 +418,125 @@ _mesa_DeleteBuffersARB(GLsizei n, const GLuint *buffer)
       return;
    }
 
+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+
+   for (i = 0; i < n; i++) {
+      if (ids[i] != 0) {
+         struct gl_buffer_object *bufObj = (struct gl_buffer_object *)
+            _mesa_HashLookup(ctx->Shared->BufferObjects, ids[i]);
+         if (bufObj) {
+            if ( (bufObj->Target == GL_ARRAY_BUFFER_ARB)
+		 || (bufObj->Target == GL_ELEMENT_ARRAY_BUFFER_ARB) ) {
+	       _mesa_BindBufferARB( bufObj->Target, 0 );
+            }
+	    else if (bufObj->Target == 0) {
+	       /* The buffer object is not bound.
+		*/
+	    }
+            else {
+               _mesa_problem(ctx, "bad target in glDeleteBufferARB");
+               return;
+            }
+            bufObj->RefCount--;
+            if (bufObj->RefCount <= 0) {
+               ASSERT(bufObj->Name != 0);
+               _mesa_remove_buffer_object(ctx, bufObj);
+               ASSERT(ctx->Driver.DeleteBuffer);
+               (*ctx->Driver.DeleteBuffer)(ctx, bufObj);
+            }
+         }
+      }
+   }
+
+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 }
 
+
+/**
+ * Generate a set of unique buffer object IDs and store them in \c buffer.
+ * 
+ * \param n       Number of IDs to generate.
+ * \param buffer  Array of \c n locations to store the IDs.
+ */
+
 void
 _mesa_GenBuffersARB(GLsizei n, GLuint *buffer)
 {
    GET_CURRENT_CONTEXT(ctx);
+   GLuint first;
+   GLint i;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (n < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGenBuffersARB(n)");
+      _mesa_error(ctx, GL_INVALID_VALUE, "glGenBuffersARB");
       return;
    }
+
+   if ( buffer == NULL ) {
+      return;
+   }
+
+   /*
+    * This must be atomic (generation and allocation of buffer object IDs)
+    */
+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+
+   first = _mesa_HashFindFreeKeyBlock(ctx->Shared->BufferObjects, n);
+
+   /* Return the buffer names */
+   for (i=0;i<n;i++) {
+      buffer[i] = first + i;
+   }
+
+   /* Allocate new, empty buffer objects */
+   for (i = 0; i < n; i++) {
+      struct gl_buffer_object *bufObj;
+      GLuint name = first + i;
+      GLenum target = 0;
+      bufObj = (*ctx->Driver.NewBufferObject)( ctx, name, target );
+      if ( bufObj != NULL ) {
+         _mesa_error(ctx, GL_OUT_OF_MEMORY, "glGenBuffersARB");
+         return;
+      }
+      _mesa_save_buffer_object(ctx, bufObj);
+   }
+
+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
 }
 
+
+/**
+ * Determine if ID is the name of a buffer object.
+ * 
+ * \param id  ID of the potential buffer object.
+ * \return  \c GL_TRUE if \c id is the name of a buffer object, 
+ *          \c GL_FALSE otherwise.
+ */
+
 GLboolean
-_mesa_IsBufferARB(GLuint buffer)
+_mesa_IsBufferARB(GLuint id)
 {
-   return GL_FALSE;
+   struct gl_buffer_object * bufObj;
+   GET_CURRENT_CONTEXT(ctx);
+   ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
+
+   if (id == 0)
+      return GL_FALSE;
+
+   _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
+   bufObj = (struct gl_buffer_object *) _mesa_HashLookup(ctx->Shared->BufferObjects, id);
+   _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
+
+   return (bufObj != NULL);
 }
 
+
 void
 _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,
                     const GLvoid * data, GLenum usage)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *bufObj;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (size < 0) {
@@ -114,16 +561,15 @@ _mesa_BufferDataARB(GLenum target, GLsizeiptrARB size,
          return;
    }
 
-   if (target == GL_ARRAY_BUFFER_ARB) {
-
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
-
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferDataARB(target)");
+   bufObj = _mesa_buffer_object_get_target( ctx, target, "BufferDataARB" );
+   if ( bufObj == NULL ) {
       return;
    }
+   
+   ASSERT(ctx->Driver.BufferData);
+
+   /* Give the buffer object to the driver!  <data> may be null! */
+   (*ctx->Driver.BufferData)( ctx, target, size, data, usage, bufObj );
 }
 
 void
@@ -131,22 +577,14 @@ _mesa_BufferSubDataARB(GLenum target, GLintptrARB offset,
                        GLsizeiptrARB size, const GLvoid * data)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *bufObj;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (size < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glBufferSubDataARB(size < 0)");
-      return;
-   }
-
-   if (target == GL_ARRAY_BUFFER_ARB) {
-
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
-
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glBufferSubDataARB(target)");
-      return;
+   bufObj = _mesa_buffer_object_subdata_range_good( ctx, target, offset, size,
+						    "BufferSubDataARB" );
+   if ( bufObj != NULL ) {
+      ASSERT(ctx->Driver.BufferSubData);
+      (*ctx->Driver.BufferSubData)( ctx, target, offset, size, data, bufObj );
    }
 }
 
@@ -155,22 +593,14 @@ _mesa_GetBufferSubDataARB(GLenum target, GLintptrARB offset,
                           GLsizeiptrARB size, void * data)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *bufObj;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
-   if (size < 0) {
-      _mesa_error(ctx, GL_INVALID_VALUE, "glGetBufferSubDataARB(size < 0)");
-      return;
-   }
-
-   if (target == GL_ARRAY_BUFFER_ARB) {
-
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
-
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferSubDataARB(target)");
-      return;
+   bufObj = _mesa_buffer_object_subdata_range_good( ctx, target, offset, size,
+						    "GetBufferSubDataARB" );
+   if ( bufObj != NULL ) {
+      ASSERT(ctx->Driver.GetBufferSubData);
+      (*ctx->Driver.GetBufferSubData)( ctx, target, offset, size, data, bufObj );
    }
 }
 
@@ -178,6 +608,7 @@ void *
 _mesa_MapBufferARB(GLenum target, GLenum access)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object * bufObj;
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, NULL);
 
    switch (access) {
@@ -191,73 +622,92 @@ _mesa_MapBufferARB(GLenum target, GLenum access)
          return NULL;
    }
 
-   if (target == GL_ARRAY_BUFFER_ARB) {
-
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
-
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glMapBufferARB(target)");
+   bufObj = _mesa_buffer_object_get_target( ctx, target, 
+					    "MapBufferARB" );
+   if ( bufObj == NULL ) {
       return NULL;
    }
 
-   return NULL;
+   if ( bufObj->pointer != NULL ) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glMapBufferARB");
+      return NULL;
+   }
+
+   ASSERT(ctx->Driver.MapBuffer);
+   bufObj->pointer = (*ctx->Driver.MapBuffer)( ctx, target, access, bufObj );
+   if ( bufObj->pointer == NULL ) {
+      _mesa_error(ctx, GL_OUT_OF_MEMORY, "glMapBufferARB(access)");
+   }
+
+   return bufObj->pointer;
 }
 
 GLboolean
 _mesa_UnmapBufferARB(GLenum target)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *bufObj;
+   GLboolean status = GL_TRUE;
    ASSERT_OUTSIDE_BEGIN_END_WITH_RETVAL(ctx, GL_FALSE);
 
-   if (target == GL_ARRAY_BUFFER_ARB) {
 
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
-
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glUnmapBufferARB(target)");
+   bufObj = _mesa_buffer_object_get_target( ctx, target, 
+					    "UnmapBufferARB" );
+   if ( bufObj == NULL ) {
       return GL_FALSE;
    }
-   return GL_FALSE;
+
+   if ( bufObj->pointer == NULL ) {
+      _mesa_error(ctx, GL_INVALID_OPERATION, "glUnmapBufferARB");
+      return GL_FALSE;
+   }
+
+   if ( ctx->Driver.UnmapBuffer != NULL ) {
+      status = (*ctx->Driver.UnmapBuffer)( ctx, target, bufObj );
+   }
+
+   bufObj->pointer = NULL;
+
+   return status;
 }
 
 void
 _mesa_GetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object *bufObj;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
+   bufObj = _mesa_buffer_object_get_target( ctx, target, 
+					    "GetBufferParameterivARB" );
+   if ( bufObj == NULL ) {
+      return;
+   }
+
    switch (pname) {
       case GL_BUFFER_SIZE_ARB:
+         *params = bufObj->size;
+         break;
       case GL_BUFFER_USAGE_ARB:
+         *params = bufObj->usage;
+         break;
       case GL_BUFFER_ACCESS_ARB:
+         *params = bufObj->access;
+         break;
       case GL_BUFFER_MAPPED_ARB:
-         /* ok */
+         *params = (bufObj->pointer != NULL);
          break;
       default:
          _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname)");
          return;
    }
-
-   if (target == GL_ARRAY_BUFFER_ARB) {
-
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
-
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterARB(target)");
-      return;
-   }
 }
 
 void
 _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
 {
    GET_CURRENT_CONTEXT(ctx);
+   struct gl_buffer_object * bufObj;
    ASSERT_OUTSIDE_BEGIN_END(ctx);
 
    if (pname != GL_BUFFER_MAP_POINTER_ARB) {
@@ -265,14 +715,11 @@ _mesa_GetBufferPointervARB(GLenum target, GLenum pname, GLvoid **params)
       return;
    }
 
-   if (target == GL_ARRAY_BUFFER_ARB) {
-
-   }
-   else if (target == GL_ELEMENT_ARRAY_BUFFER_ARB) {
-
-   }
-   else {
-      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferPointervARB(target)");
+   bufObj = _mesa_buffer_object_get_target( ctx, target,
+					    "GetBufferPointervARB" );
+   if ( bufObj == NULL ) {
       return;
    }
+
+   *params = bufObj->pointer;
 }

src/mesa/main/context.c

@@ -840,6 +840,8 @@ alloc_shared_state( GLcontext *ctx )
       goto cleanup;
 #endif
 
+   ss->BufferObjects = _mesa_NewHashTable();
+
    ss->Default1D = (*ctx->Driver.NewTextureObject)(ctx, 0, GL_TEXTURE_1D);
    if (!ss->Default1D)
       goto cleanup;
@@ -895,6 +897,9 @@ alloc_shared_state( GLcontext *ctx )
    if (ss->DefaultFragmentProgram)
       _mesa_delete_program(ctx, ss->DefaultFragmentProgram);
 #endif
+   if (ss->BufferObjects)
+      _mesa_DeleteHashTable(ss->BufferObjects);
+
    if (ss->Default1D)
       (*ctx->Driver.DeleteTexture)(ctx, ss->Default1D);
    if (ss->Default2D)
@@ -972,6 +977,8 @@ free_shared_state( GLcontext *ctx, struct gl_shared_state *ss )
    _mesa_DeleteHashTable(ss->Programs);
 #endif
 
+   _mesa_DeleteHashTable(ss->BufferObjects);
+
    _glthread_DESTROY_MUTEX(ss->Mutex);
 
    FREE(ss);

src/mesa/main/dd.h

@@ -829,6 +829,39 @@ struct dd_function_table {
     */
    void (*UnlockArraysEXT)( GLcontext *ctx );
    /*@}*/
+
+
+   /**
+    * \name Vertex buffer object functions
+    */
+   /*@{*/
+
+   void (*BindBuffer)( GLcontext *ctx, GLenum target,
+		       struct gl_buffer_object *obj );
+
+   struct gl_buffer_object * (*NewBufferObject)( GLcontext *ctx, int buffer,
+						 GLenum target );
+   
+   void (*DeleteBuffer)( GLcontext *ctx, struct gl_buffer_object *obj );
+
+   void (*BufferData)( GLcontext *ctx, GLenum target, GLsizeiptrARB size,
+		       const GLvoid *data, GLenum usage,
+		       struct gl_buffer_object *obj );
+
+   void (*BufferSubData)( GLcontext *ctx, GLenum target, GLintptrARB offset,
+			  GLsizeiptrARB size, const GLvoid *data,
+			  struct gl_buffer_object *obj );
+
+   void (*GetBufferSubData)( GLcontext *ctx, GLenum target,
+			     GLintptrARB offset, GLsizeiptrARB size,
+			     GLvoid *data, struct gl_buffer_object *obj );
+
+   void * (*MapBuffer)( GLcontext *ctx, GLenum target, GLenum access,
+			struct gl_buffer_object *obj );
+
+   GLboolean (*UnmapBuffer)( GLcontext *ctx, GLenum target,
+			     struct gl_buffer_object *obj );
+   /*@}*/
 };
 
 

src/mesa/main/mtypes.h

@@ -1598,6 +1598,9 @@ struct gl_shared_state
 #endif
    /*@}*/
 
+   /** GL_ARB_vertex_buffer_objects */
+   struct _mesa_HashTable *BufferObjects;
+
    void *DriverData;  /**< Device driver shared state */
 };
 
@@ -1985,6 +1988,7 @@ typedef union node Node;
 
 
 /* This has to be included here. */
+struct gl_buffer_object;
 #include "dd.h"
 
 
@@ -2220,6 +2224,18 @@ struct __GLcontextRec {
    /** Core tnl module support */
    struct gl_tnl_module TnlModule;
 
+   /**
+    * \name GL_ARB_vertex_buffer_object state
+    * 
+    * These pointers track the buffer objects last bound via
+    * \c glBindBufferObjectARB.  If it the last bound object ID was 0 for a
+    * given target, the pointer will be \c NULL.
+    */
+   /*@{*/
+   struct gl_buffer_object * ArrayBuffer;
+   struct gl_buffer_object * ElementArrayBuffer;
+   /*@}*/
+
    /**
     * \name Hooks for module contexts.  
     *